From 9be33d7c899509d24f68ca41bb33ca49bf254272 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Fri, 21 Apr 2023 23:57:35 +0000
Subject: [PATCH 01/37] Adding BaseWriteable and ProtobufWriteable

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../common/io/stream/BaseWriteable.java       | 53 +++++++++++++
 .../common/io/stream/ProtobufWriteable.java   | 76 +++++++++++++++++++
 2 files changed, 129 insertions(+)
 create mode 100644 server/src/main/java/org/opensearch/common/io/stream/BaseWriteable.java
 create mode 100644 server/src/main/java/org/opensearch/common/io/stream/ProtobufWriteable.java

diff --git a/server/src/main/java/org/opensearch/common/io/stream/BaseWriteable.java b/server/src/main/java/org/opensearch/common/io/stream/BaseWriteable.java
new file mode 100644
index 0000000000000..7d7fa18bb6afa
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/io/stream/BaseWriteable.java
@@ -0,0 +1,53 @@
+/*
+ * 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.
+ */
+
+package org.opensearch.common.io.stream;
+
+import java.io.IOException;
+
+/**
+ * This interface can be extended to different types of serialization and deserialization mechanisms.
+ *
+ * @opensearch.internal
+ */
+public interface BaseWriteable<T, S> {
+
+    /**
+     * Write this into the stream output.
+    */
+    void writeTo(T out) throws IOException;
+    
+    /**
+     * Reference to a method that can write some object to a given type.
+     */
+    @FunctionalInterface
+    interface Writer<T, V> {
+
+        /**
+         * Write {@code V}-type {@code value} to the {@code T}-type stream.
+         *
+         * @param out Output to write the {@code value} too
+         * @param value The value to add
+         */
+        void write(T out, V value) throws IOException;
+    }
+
+    /**
+     * Reference to a method that can read some object from a given stream type.
+     */
+    @FunctionalInterface
+    interface Reader<S, V> {
+ 
+        /**
+         * Read {@code V}-type value from a {@code T}-type stream.
+        *
+        * @param in Input to read the value from
+        */
+        V read(S in) throws IOException;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufWriteable.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufWriteable.java
new file mode 100644
index 0000000000000..86f71cf6e5bf2
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/io/stream/ProtobufWriteable.java
@@ -0,0 +1,76 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.common.io.stream;
+
+import java.io.IOException;
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
+/**
+ * Implementers can be written to write to output and read from input using Protobuf.
+*
+* @opensearch.internal
+*/
+public interface ProtobufWriteable extends BaseWriteable<CodedOutputStream, CodedInputStream> {
+
+    /**
+     * Write this into the stream output.
+    */
+    public void writeTo(CodedOutputStream out) throws IOException;
+
+    /**
+     * Reference to a method that can write some object to a {@link CodedOutputStream}.
+     * Most classes should implement {@link ProtobufWriteable} and the {@link ProtobufWriteable#writeTo(CodedOutputStream)} method should <em>use</em>
+     * {@link CodedOutputStream} methods directly or this indirectly:
+     * <pre><code>
+     * public void writeTo(CodedOutputStream out) throws IOException {
+     *     out.writeVInt(someValue);
+     * }
+     * </code></pre>
+     */
+    @FunctionalInterface
+    interface Writer<V> {
+
+        /**
+         * Write {@code V}-type {@code value} to the {@code out}put stream.
+        *
+        * @param out Output to write the {@code value} too
+        * @param value The value to add
+        */
+        void write(CodedOutputStream out, V value) throws IOException;
+
+    }
+
+    /**
+     * Reference to a method that can read some object from a stream. By convention this is a constructor that takes
+     * {@linkplain CodedInputStream} as an argument for most classes and a static method for things like enums.
+     * <pre><code>
+     * public MyClass(final CodedInputStream in) throws IOException {
+     *     this.someValue = in.readVInt();
+     * }
+     * </code></pre>
+     */
+    @FunctionalInterface
+    interface Reader<V> {
+
+        /**
+         * Read {@code V}-type value from a stream.
+        *
+        * @param in Input to read the value from
+        */
+        V read(CodedInputStream in) throws IOException;
+
+    }
+
+}

From 0034b0a5b3e88df911e3a99828ef1b77cfe0a3d2 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Fri, 21 Apr 2023 23:58:21 +0000
Subject: [PATCH 02/37] Adding proto messages for TaskId and TaskResourceStats

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 server/src/main/proto/tasks/TaskIdProto.proto | 20 ++++++++++++++++
 .../proto/tasks/TaskResourceStatsProto.proto  | 23 +++++++++++++++++++
 2 files changed, 43 insertions(+)
 create mode 100644 server/src/main/proto/tasks/TaskIdProto.proto
 create mode 100644 server/src/main/proto/tasks/TaskResourceStatsProto.proto

diff --git a/server/src/main/proto/tasks/TaskIdProto.proto b/server/src/main/proto/tasks/TaskIdProto.proto
new file mode 100644
index 0000000000000..c2d34ca235c28
--- /dev/null
+++ b/server/src/main/proto/tasks/TaskIdProto.proto
@@ -0,0 +1,20 @@
+/*
+ * 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.
+ *
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+syntax = "proto3";
+package org.opensearch.tasks.proto;
+
+option java_outer_classname = "TaskIdProto";
+
+message TaskId {
+  string nodeId = 1;
+  int64 id = 2;
+}
diff --git a/server/src/main/proto/tasks/TaskResourceStatsProto.proto b/server/src/main/proto/tasks/TaskResourceStatsProto.proto
new file mode 100644
index 0000000000000..0e2462ba51a73
--- /dev/null
+++ b/server/src/main/proto/tasks/TaskResourceStatsProto.proto
@@ -0,0 +1,23 @@
+/*
+ * 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.
+ *
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+syntax = "proto3";
+package org.opensearch.tasks.proto;
+
+option java_outer_classname = "TaskResourceStatsProto";
+
+message TaskResourceStats {
+  message TaskResourceUsage {
+    int64 cpuTimeInNanos = 1;
+    int64 memoryInBytes = 2;
+  }
+  map<string, TaskResourceUsage> resourceUsage = 1;
+}

From cdb6806d982835b925181d764378eb8d3c00e1b9 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Fri, 21 Apr 2023 23:58:53 +0000
Subject: [PATCH 03/37] Adding Task related classes with protobuf integration

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../tasks/ProtobufCancellableTask.java        |  91 ++++
 .../org/opensearch/tasks/ProtobufTask.java    | 446 ++++++++++++++++++
 .../tasks/ProtobufTaskAwareRequest.java       |  50 ++
 .../org/opensearch/tasks/ProtobufTaskId.java  |  92 ++++
 .../opensearch/tasks/ProtobufTaskInfo.java    | 231 +++++++++
 .../tasks/ProtobufTaskResourceStats.java      |  48 ++
 .../opensearch/tasks/ProtobufTaskResult.java  | 226 +++++++++
 7 files changed, 1184 insertions(+)
 create mode 100644 server/src/main/java/org/opensearch/tasks/ProtobufCancellableTask.java
 create mode 100644 server/src/main/java/org/opensearch/tasks/ProtobufTask.java
 create mode 100644 server/src/main/java/org/opensearch/tasks/ProtobufTaskAwareRequest.java
 create mode 100644 server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
 create mode 100644 server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
 create mode 100644 server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java
 create mode 100644 server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java

diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufCancellableTask.java b/server/src/main/java/org/opensearch/tasks/ProtobufCancellableTask.java
new file mode 100644
index 0000000000000..9e47da0265e86
--- /dev/null
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufCancellableTask.java
@@ -0,0 +1,91 @@
+/*
+* 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.
+*/
+
+package org.opensearch.tasks;
+
+import org.opensearch.common.Nullable;
+import org.opensearch.common.unit.TimeValue;
+
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static org.opensearch.search.SearchService.NO_TIMEOUT;
+
+/**
+ * A task that can be canceled
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufCancellableTask extends ProtobufTask {
+
+    private volatile String reason;
+    private final AtomicBoolean cancelled = new AtomicBoolean(false);
+    private final TimeValue cancelAfterTimeInterval;
+
+    public ProtobufCancellableTask(long id, String type, String action, String description, ProtobufTaskId parentTaskId, Map<String, String> headers) {
+        this(id, type, action, description, parentTaskId, headers, NO_TIMEOUT);
+    }
+
+    public ProtobufCancellableTask(
+        long id,
+        String type,
+        String action,
+        String description,
+        ProtobufTaskId parentTaskId,
+        Map<String, String> headers,
+        TimeValue cancelAfterTimeInterval
+    ) {
+        super(id, type, action, description, parentTaskId, headers);
+        this.cancelAfterTimeInterval = cancelAfterTimeInterval;
+    }
+
+    /**
+     * This method is called by the task manager when this task is cancelled.
+    */
+    public void cancel(String reason) {
+        assert reason != null;
+        if (cancelled.compareAndSet(false, true)) {
+            this.reason = reason;
+            onCancelled();
+        }
+    }
+
+    /**
+     * Returns true if this task should be automatically cancelled if the coordinating node that
+    * requested this task left the cluster.
+    */
+    public boolean cancelOnParentLeaving() {
+        return true;
+    }
+
+    /**
+     * Returns true if this task can potentially have children that need to be cancelled when it parent is cancelled.
+    */
+    public abstract boolean shouldCancelChildrenOnCancellation();
+
+    public boolean isCancelled() {
+        return cancelled.get();
+    }
+
+    public TimeValue getCancellationTimeout() {
+        return cancelAfterTimeInterval;
+    }
+
+    /**
+     * The reason the task was cancelled or null if it hasn't been cancelled.
+    */
+    @Nullable
+    public final String getReasonCancelled() {
+        return reason;
+    }
+
+    /**
+     * Called after the task is cancelled so that it can take any actions that it has to take.
+    */
+    protected void onCancelled() {}
+}
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTask.java b/server/src/main/java/org/opensearch/tasks/ProtobufTask.java
new file mode 100644
index 0000000000000..dd3a446a0d120
--- /dev/null
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTask.java
@@ -0,0 +1,446 @@
+/*
+* 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.
+*/
+
+package org.opensearch.tasks;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.ExceptionsHelper;
+import org.opensearch.action.ActionResponse;
+import org.opensearch.action.NotifyOnceListener;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.common.io.stream.NamedWriteable;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.ToXContentObject;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Current task information
+*
+* @opensearch.internal
+*/
+public class ProtobufTask {
+
+    private static final Logger logger = LogManager.getLogger(ProtobufTask.class);
+
+    /**
+     * The request header to mark tasks with specific ids
+    */
+    public static final String X_OPAQUE_ID = "X-Opaque-Id";
+
+    private static final String TOTAL = "total";
+
+    private final long id;
+
+    private final String type;
+
+    private final String action;
+
+    private final String description;
+
+    private final ProtobufTaskId parentTask;
+
+    private final Map<String, String> headers;
+
+    private final Map<Long, List<ThreadResourceInfo>> resourceStats;
+
+    private final List<NotifyOnceListener<ProtobufTask>> resourceTrackingCompletionListeners;
+
+    /**
+     * Keeps track of the number of active resource tracking threads for this task. It is initialized to 1 to track
+    * the task's own/self thread. When this value becomes 0, all threads have been marked inactive and the resource
+    * tracking can be stopped for this task.
+    */
+    private final AtomicInteger numActiveResourceTrackingThreads = new AtomicInteger(1);
+
+    /**
+     * The task's start time as a wall clock time since epoch ({@link System#currentTimeMillis()} style).
+    */
+    private final long startTime;
+
+    /**
+     * The task's start time as a relative time ({@link System#nanoTime()} style).
+    */
+    private final long startTimeNanos;
+
+    public ProtobufTask(long id, String type, String action, String description, ProtobufTaskId parentTask, Map<String, String> headers) {
+        this(
+            id,
+            type,
+            action,
+            description,
+            parentTask,
+            System.currentTimeMillis(),
+            System.nanoTime(),
+            headers,
+            new ConcurrentHashMap<>(),
+            new ArrayList<>()
+        );
+    }
+
+    public ProtobufTask(
+        long id,
+        String type,
+        String action,
+        String description,
+        ProtobufTaskId parentTask,
+        long startTime,
+        long startTimeNanos,
+        Map<String, String> headers,
+        ConcurrentHashMap<Long, List<ThreadResourceInfo>> resourceStats,
+        List<NotifyOnceListener<ProtobufTask>> resourceTrackingCompletionListeners
+    ) {
+        this.id = id;
+        this.type = type;
+        this.action = action;
+        this.description = description;
+        this.parentTask = parentTask;
+        this.startTime = startTime;
+        this.startTimeNanos = startTimeNanos;
+        this.headers = headers;
+        this.resourceStats = resourceStats;
+        this.resourceTrackingCompletionListeners = resourceTrackingCompletionListeners;
+    }
+
+    /**
+     * Build a version of the task status you can throw over the wire and back
+    * to the user.
+    *
+    * @param localNodeId
+    *            the id of the node this task is running on
+    * @param detailed
+    *            should the information include detailed, potentially slow to
+    *            generate data?
+    */
+    public final ProtobufTaskInfo taskInfo(String localNodeId, boolean detailed) {
+        return taskInfo(localNodeId, detailed, detailed == false);
+    }
+
+    /**
+     * Build a version of the task status you can throw over the wire and back
+    * with the option to include resource stats or not.
+    * This method is only used during creating TaskResult to avoid storing resource information into the task index.
+    *
+    * @param excludeStats should information exclude resource stats.
+    *                     By default, detailed flag is used to control including resource information.
+    *                     But inorder to avoid storing resource stats into task index as strict mapping is enforced and breaks when adding this field.
+    *                     In the future, task-index-mapping.json can be modified to add resource stats.
+    */
+    private ProtobufTaskInfo taskInfo(String localNodeId, boolean detailed, boolean excludeStats) {
+        String description = null;
+        ProtobufTask.Status status = null;
+        ProtobufTaskResourceStats resourceStats = null;
+        if (detailed) {
+            description = getDescription();
+            status = getStatus();
+        }
+        if (excludeStats == false) {
+            resourceStats = new ProtobufTaskResourceStats(new HashMap<>() {
+                {
+                    put(TOTAL, getTotalResourceStats());
+                }
+            });
+        }
+        return taskInfo(localNodeId, description, status, resourceStats);
+    }
+
+    /**
+     * Build a {@link ProtobufTaskInfo} for this task without resource stats.
+    */
+    protected final ProtobufTaskInfo taskInfo(String localNodeId, String description, Status status) {
+        return taskInfo(localNodeId, description, status, null);
+    }
+
+    /**
+     * Build a proper {@link ProtobufTaskInfo} for this task.
+    */
+    protected final ProtobufTaskInfo taskInfo(String localNodeId, String description, Status status, TaskResourceStats resourceStats) {
+        return new ProtobufTaskInfo(
+            new ProtobufTaskId(localNodeId, getId()),
+            getType(),
+            getAction(),
+            description,
+            status,
+            startTime,
+            System.nanoTime() - startTimeNanos,
+            this instanceof ProtobufCancellableTask,
+            this instanceof ProtobufCancellableTask && ((ProtobufCancellableTask) this).isCancelled(),
+            parentTask,
+            headers,
+            resourceStats
+        );
+    }
+
+    /**
+     * Returns task id
+    */
+    public long getId() {
+        return id;
+    }
+
+    /**
+     * Returns task channel type (netty, transport, direct)
+    */
+    public String getType() {
+        return type;
+    }
+
+    /**
+     * Returns task action
+    */
+    public String getAction() {
+        return action;
+    }
+
+    /**
+     * Generates task description
+    */
+    public String getDescription() {
+        return description;
+    }
+
+    /**
+     * Returns the task's start time as a wall clock time since epoch ({@link System#currentTimeMillis()} style).
+    */
+    public long getStartTime() {
+        return startTime;
+    }
+
+    /**
+     * Returns the task's start time in nanoseconds ({@link System#nanoTime()} style).
+    */
+    public long getStartTimeNanos() {
+        return startTimeNanos;
+    }
+
+    /**
+     * Returns id of the parent task or NO_PARENT_ID if the task doesn't have any parent tasks
+    */
+    public ProtobufTaskId getParentTaskId() {
+        return parentTask;
+    }
+
+    /**
+     * Build a status for this task or null if this task doesn't have status.
+    * Since most tasks don't have status this defaults to returning null. While
+    * this can never perform IO it might be a costly operation, requiring
+    * collating lists of results, etc. So only use it if you need the value.
+    */
+    public Status getStatus() {
+        return null;
+    }
+
+    /**
+     * Returns thread level resource consumption of the task
+    */
+    public Map<Long, List<ThreadResourceInfo>> getResourceStats() {
+        return Collections.unmodifiableMap(resourceStats);
+    }
+
+    /**
+     * Returns current total resource usage of the task.
+    * Currently, this method is only called on demand, during get and listing of tasks.
+    * In the future, these values can be cached as an optimization.
+    */
+    public TaskResourceUsage getTotalResourceStats() {
+        return new TaskResourceUsage(getTotalResourceUtilization(ResourceStats.CPU), getTotalResourceUtilization(ResourceStats.MEMORY));
+    }
+
+    /**
+     * Returns total resource consumption for a specific task stat.
+    */
+    public long getTotalResourceUtilization(ResourceStats stats) {
+        long totalResourceConsumption = 0L;
+        for (List<ThreadResourceInfo> threadResourceInfosList : resourceStats.values()) {
+            for (ThreadResourceInfo threadResourceInfo : threadResourceInfosList) {
+                final ResourceUsageInfo.ResourceStatsInfo statsInfo = threadResourceInfo.getResourceUsageInfo().getStatsInfo().get(stats);
+                if (threadResourceInfo.getStatsType().isOnlyForAnalysis() == false && statsInfo != null) {
+                    totalResourceConsumption += statsInfo.getTotalValue();
+                }
+            }
+        }
+        return totalResourceConsumption;
+    }
+
+    /**
+     * Adds thread's starting resource consumption information
+    * @param threadId ID of the thread
+    * @param statsType stats type
+    * @param resourceUsageMetrics resource consumption metrics of the thread
+    * @throws IllegalStateException matching active thread entry was found which is not expected.
+    */
+    public void startThreadResourceTracking(long threadId, ResourceStatsType statsType, ResourceUsageMetric... resourceUsageMetrics) {
+        final List<ThreadResourceInfo> threadResourceInfoList = resourceStats.computeIfAbsent(threadId, k -> new ArrayList<>());
+        // active thread entry should not be present in the list
+        for (ThreadResourceInfo threadResourceInfo : threadResourceInfoList) {
+            if (threadResourceInfo.getStatsType() == statsType && threadResourceInfo.isActive()) {
+                throw new IllegalStateException(
+                    "unexpected active thread resource entry present [" + threadId + "]:[" + threadResourceInfo + "]"
+                );
+            }
+        }
+        threadResourceInfoList.add(new ThreadResourceInfo(threadId, statsType, resourceUsageMetrics));
+        incrementResourceTrackingThreads();
+    }
+
+    /**
+     * This method is used to update the resource consumption stats so that the data isn't too stale for long-running task.
+    * If active thread entry is present in the list, the entry is updated. If one is not found, it throws an exception.
+    * @param threadId ID of the thread
+    * @param statsType stats type
+    * @param resourceUsageMetrics resource consumption metrics of the thread
+    * @throws IllegalStateException if no matching active thread entry was found.
+    */
+    public void updateThreadResourceStats(long threadId, ResourceStatsType statsType, ResourceUsageMetric... resourceUsageMetrics) {
+        final List<ThreadResourceInfo> threadResourceInfoList = resourceStats.get(threadId);
+        if (threadResourceInfoList != null) {
+            for (ThreadResourceInfo threadResourceInfo : threadResourceInfoList) {
+                // the active entry present in the list is updated
+                if (threadResourceInfo.getStatsType() == statsType && threadResourceInfo.isActive()) {
+                    threadResourceInfo.recordResourceUsageMetrics(resourceUsageMetrics);
+                    return;
+                }
+            }
+        }
+        throw new IllegalStateException("cannot update if active thread resource entry is not present");
+    }
+
+    /**
+     * Record the thread's final resource consumption values.
+    * If active thread entry is present in the list, the entry is updated. If one is not found, it throws an exception.
+    * @param threadId ID of the thread
+    * @param statsType stats type
+    * @param resourceUsageMetrics resource consumption metrics of the thread
+    * @throws IllegalStateException if no matching active thread entry was found.
+    */
+    public void stopThreadResourceTracking(long threadId, ResourceStatsType statsType, ResourceUsageMetric... resourceUsageMetrics) {
+        final List<ThreadResourceInfo> threadResourceInfoList = resourceStats.get(threadId);
+        if (threadResourceInfoList != null) {
+            for (ThreadResourceInfo threadResourceInfo : threadResourceInfoList) {
+                if (threadResourceInfo.getStatsType() == statsType && threadResourceInfo.isActive()) {
+                    threadResourceInfo.setActive(false);
+                    threadResourceInfo.recordResourceUsageMetrics(resourceUsageMetrics);
+                    decrementResourceTrackingThreads();
+                    return;
+                }
+            }
+        }
+        throw new IllegalStateException("cannot update final values if active thread resource entry is not present");
+    }
+
+    /**
+     * Individual tasks can override this if they want to support task resource tracking. We just need to make sure that
+    * the ThreadPool on which the task runs on have runnable wrapper similar to
+    * {@link org.opensearch.common.util.concurrent.OpenSearchExecutors#newResizable}
+    *
+    * @return true if resource tracking is supported by the task
+    */
+    public boolean supportsResourceTracking() {
+        return false;
+    }
+
+    /**
+     * Report of the internal status of a task. These can vary wildly from task
+    * to task because each task is implemented differently but we should try
+    * to keep each task consistent from version to version where possible.
+    * That means each implementation of {@linkplain ProtobufTask.Status#toXContent}
+    * should avoid making backwards incompatible changes to the rendered
+    * result. But if we change the way a request is implemented it might not
+    * be possible to preserve backwards compatibility. In that case, we
+    * <b>can</b> change this on version upgrade but we should be careful
+    * because some statuses (reindex) have become defacto standardized because
+    * they are used by systems like Kibana.
+    */
+    public interface Status extends ToXContentObject, NamedWriteable {}
+
+    /**
+     * Returns stored task header associated with the task
+    */
+    public String getHeader(String header) {
+        return headers.get(header);
+    }
+
+    public ProtobufTaskResult result(DiscoveryNode node, Exception error) throws IOException {
+        return new ProtobufTaskResult(taskInfo(node.getId(), true, true), error);
+    }
+
+    public ProtobufTaskResult result(DiscoveryNode node, ActionResponse response) throws IOException {
+        if (response instanceof ToXContent) {
+            return new ProtobufTaskResult(taskInfo(node.getId(), true, true), (ToXContent) response);
+        } else {
+            throw new IllegalStateException("response has to implement ToXContent to be able to store the results");
+        }
+    }
+
+    /**
+     * Registers a task resource tracking completion listener on this task if resource tracking is still active.
+    * Returns true on successful subscription, false otherwise.
+    */
+    public boolean addResourceTrackingCompletionListener(NotifyOnceListener<ProtobufTask> listener) {
+        if (numActiveResourceTrackingThreads.get() > 0) {
+            resourceTrackingCompletionListeners.add(listener);
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Increments the number of active resource tracking threads.
+    *
+    * @return the number of active resource tracking threads.
+    */
+    public int incrementResourceTrackingThreads() {
+        return numActiveResourceTrackingThreads.incrementAndGet();
+    }
+
+    /**
+     * Decrements the number of active resource tracking threads.
+    * This method is called when threads finish execution, and also when the task is unregistered (to mark the task's
+    * own thread as complete). When the active thread count becomes zero, the onTaskResourceTrackingCompleted method
+    * is called exactly once on all registered listeners.
+    *
+    * Since a task is unregistered after the message is processed, it implies that the threads responsible to produce
+    * the response must have started prior to it (i.e. startThreadResourceTracking called before unregister).
+    * This ensures that the number of active threads doesn't drop to zero pre-maturely.
+    *
+    * Rarely, some threads may even start execution after the task is unregistered. As resource stats are piggy-backed
+    * with the response, any thread usage info captured after the task is unregistered may be irrelevant.
+    *
+    * @return the number of active resource tracking threads.
+    */
+    public int decrementResourceTrackingThreads() {
+        int count = numActiveResourceTrackingThreads.decrementAndGet();
+
+        if (count == 0) {
+            List<Exception> listenerExceptions = new ArrayList<>();
+            resourceTrackingCompletionListeners.forEach(listener -> {
+                try {
+                    listener.onResponse(this);
+                } catch (Exception e1) {
+                    try {
+                        listener.onFailure(e1);
+                    } catch (Exception e2) {
+                        listenerExceptions.add(e2);
+                    }
+                }
+            });
+            ExceptionsHelper.maybeThrowRuntimeAndSuppress(listenerExceptions);
+        }
+
+        return count;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskAwareRequest.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskAwareRequest.java
new file mode 100644
index 0000000000000..beebdea5beebb
--- /dev/null
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskAwareRequest.java
@@ -0,0 +1,50 @@
+/*
+* 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.
+*/
+
+package org.opensearch.tasks;
+
+import java.util.Map;
+
+/**
+ * An interface for a request that can be used to register a task manager task
+*
+* @opensearch.internal
+*/
+public interface ProtobufTaskAwareRequest {
+    /**
+     * Set a reference to task that caused this task to be run.
+    */
+    default void setParentTask(String parentTaskNode, long parentTaskId) {
+        setParentTask(new ProtobufTaskId(parentTaskNode, parentTaskId));
+    }
+
+    /**
+     * Set a reference to task that created this request.
+    */
+    void setParentTask(ProtobufTaskId taskId);
+
+    /**
+     * Get a reference to the task that created this request. Implementers should default to
+    * {@link ProtobufTaskId#EMPTY_TASK_ID}, meaning "there is no parent".
+    */
+    ProtobufTaskId getParentTask();
+
+    /**
+     * Returns the task object that should be used to keep track of the processing of the request.
+    */
+    default ProtobufTask createTask(long id, String type, String action, ProtobufTaskId parentTaskId, Map<String, String> headers) {
+        return new ProtobufTask(id, type, action, getDescription(), parentTaskId, headers);
+    }
+
+    /**
+     * Returns optional description of the request to be displayed by the task manager
+    */
+    default String getDescription() {
+        return "";
+    }
+}
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
new file mode 100644
index 0000000000000..81ba9e2cabd5d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
@@ -0,0 +1,92 @@
+/*
+* 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.
+*/
+
+package org.opensearch.tasks;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.OpenSearchParseException;
+import org.opensearch.common.Strings;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.tasks.proto.TaskIdProto;
+
+import java.io.IOException;
+
+/**
+ * Task id that consists of node id and id of the task on the node
+*
+* @opensearch.internal
+*/
+public final class ProtobufTaskId implements ProtobufWriteable {
+
+    public static final ProtobufTaskId EMPTY_TASK_ID = new ProtobufTaskId();
+
+    private final TaskIdProto.TaskId taskId;
+
+    public ProtobufTaskId(String nodeId, long id) {
+        this.taskId = TaskIdProto.TaskId.newBuilder().setNodeId(nodeId).setId(id).build();
+    }
+
+    /**
+     * Builds {@link #EMPTY_TASK_ID}.
+    */
+    private ProtobufTaskId() {
+        this.taskId = TaskIdProto.TaskId.newBuilder().setNodeId("").setId(-1L).build();
+    }
+
+    public ProtobufTaskId(String taskId) {
+        if (Strings.hasLength(taskId) && "unset".equals(taskId) == false) {
+            String[] s = Strings.split(taskId, ":");
+            if (s == null || s.length != 2) {
+                throw new IllegalArgumentException("malformed task id " + taskId);
+            }
+            String nodeId = s[0];
+            try {
+                long id = Long.parseLong(s[1]);
+                this.taskId = TaskIdProto.TaskId.newBuilder().setNodeId(nodeId).setId(id).build();
+            } catch (NumberFormatException ex) {
+                throw new IllegalArgumentException("malformed task id " + taskId, ex);
+            }
+        } else {
+            this.taskId = EMPTY_TASK_ID.taskId;
+        }
+    }
+
+    /**
+     * Read a {@linkplain ProtobufTaskId} from a stream. {@linkplain ProtobufTaskId} has this rather than the usual constructor that takes a
+    * {@linkplain CodedInputStream} so we can return the {@link #EMPTY_TASK_ID} without allocating.
+    */
+    public static ProtobufTaskId readFromStream(CodedInputStream in) throws IOException {
+        String nodeId = in.readString();
+        if (nodeId.isEmpty()) {
+            /*
+            * The only TaskId allowed to have the empty string as its nodeId is the EMPTY_TASK_ID and there is only ever one of it and it
+            * never writes its taskId to save bytes on the wire because it is by far the most common TaskId.
+            */
+            return EMPTY_TASK_ID;
+        }
+        return new ProtobufTaskId(nodeId, in.readInt64());
+    }
+
+    @Override
+    public void writeTo(com.google.protobuf.CodedOutputStream out) throws IOException {
+        this.taskId.writeTo(out);
+    }
+
+    public String getNodeId() {
+        return this.taskId.getNodeId();
+    }
+
+    public long getId() {
+        return this.taskId.getId();
+    }
+
+    public boolean isSet() {
+        return this.taskId.getId() != -1L;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
new file mode 100644
index 0000000000000..e0acdb7f54ec1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
@@ -0,0 +1,231 @@
+/*
+* 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.
+*/
+
+package org.opensearch.tasks;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.Version;
+import org.opensearch.common.Strings;
+import org.opensearch.common.bytes.BytesReference;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.io.stream.Writeable;
+import org.opensearch.common.unit.TimeValue;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+
+import static org.opensearch.core.xcontent.ConstructingObjectParser.constructorArg;
+import static org.opensearch.core.xcontent.ConstructingObjectParser.optionalConstructorArg;
+
+/**
+ * Information about a currently running task.
+* <p>
+* Tasks are used for communication with transport actions. As a result, they can contain callback
+* references as well as mutable state. That makes it impractical to send tasks over transport channels
+* and use in APIs. Instead, immutable and writeable ProtobufTaskInfo objects are used to represent
+* snapshot information about currently running tasks.
+*
+* @opensearch.internal
+*/
+public final class ProtobufTaskInfo implements ProtobufWriteable {
+    private final ProtobufTaskId taskId;
+
+    private final String type;
+
+    private final String action;
+
+    private final String description;
+
+    private final long startTime;
+
+    private final long runningTimeNanos;
+
+    private final ProtobufTask.Status status;
+
+    private final boolean cancellable;
+
+    private final boolean cancelled;
+
+    private final ProtobufTaskId parentTaskId;
+
+    private final Map<String, String> headers;
+
+    private final ProtobufTaskResourceStats resourceStats;
+
+    private ProtobufStreamInput protobufStreamInput;
+
+    private ProtobufStreamOutput protobufStreamOutput;
+
+    public ProtobufTaskInfo(
+        ProtobufTaskId taskId,
+        String type,
+        String action,
+        String description,
+        ProtobufTask.Status status,
+        long startTime,
+        long runningTimeNanos,
+        boolean cancellable,
+        boolean cancelled,
+        ProtobufTaskId parentTaskId,
+        Map<String, String> headers,
+        ProtobufTaskResourceStats resourceStats
+    ) {
+        if (cancellable == false && cancelled == true) {
+            throw new IllegalArgumentException("task cannot be cancelled");
+        }
+        this.taskId = taskId;
+        this.type = type;
+        this.action = action;
+        this.description = description;
+        this.status = status;
+        this.startTime = startTime;
+        this.runningTimeNanos = runningTimeNanos;
+        this.cancellable = cancellable;
+        this.cancelled = cancelled;
+        this.parentTaskId = parentTaskId;
+        this.headers = headers;
+        this.resourceStats = resourceStats;
+    }
+
+    /**
+     * Read from a stream.
+    */
+    @SuppressWarnings("unchecked")
+    public ProtobufTaskInfo(CodedInputStream in) throws IOException {
+        protobufStreamInput = new ProtobufStreamInput();
+        taskId = ProtobufTaskId.readFromStream(in);
+        type = in.readString();
+        action = in.readString();
+        description = protobufStreamInput.readOptionalString(in);
+        //TODO: fix this
+        status = null;
+        startTime = in.readInt64();
+        runningTimeNanos = in.readInt64();
+        cancellable = in.readBool();
+        if (protobufStreamInput.getVersion().onOrAfter(Version.V_2_0_0)) {
+            cancelled = in.readBool();
+        } else {
+            cancelled = false;
+        }
+        if (cancellable == false && cancelled == true) {
+            throw new IllegalArgumentException("task cannot be cancelled");
+        }
+        parentTaskId = ProtobufTaskId.readFromStream(in);
+        headers = protobufStreamInput.readMap(CodedInputStream::readString, CodedInputStream::readString, in);
+        if (protobufStreamInput.getVersion().onOrAfter(Version.V_2_1_0)) {
+            resourceStats = protobufStreamInput.readOptionalWriteable(ProtobufTaskResourceStats::new, in);
+        } else {
+            resourceStats = null;
+        }
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        protobufStreamOutput = new ProtobufStreamOutput();
+        taskId.writeTo(out);
+        out.writeString(1, type);
+        out.writeString(2, action);
+        out.writeString(3, description);
+        //TODO: fix this
+        // out.writeOptionalNamedWriteable(status);
+        out.writeInt64(4, startTime);
+        out.writeInt64(5, runningTimeNanos);
+        out.writeBool(6, cancellable);
+        if (protobufStreamOutput.getVersion().onOrAfter(Version.V_2_0_0)) {
+            out.writeBool(7, cancelled);
+        }
+        parentTaskId.writeTo(out);
+        protobufStreamOutput.writeMap(headers, CodedOutputStream::writeString, CodedOutputStream::writeString, out);
+        if (protobufStreamOutput.getVersion().onOrAfter(Version.V_2_1_0)) {
+            out.writeOptionalWriteable(resourceStats, out);
+        }
+    }
+
+    public ProtobufTaskId getTaskId() {
+        return taskId;
+    }
+
+    public long getId() {
+        return taskId.getId();
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public String getAction() {
+        return action;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    /**
+     * The status of the running task. Only available if TaskInfos were build
+    * with the detailed flag.
+    */
+    public ProtobufTask.Status getStatus() {
+        return status;
+    }
+
+    /**
+     * Returns the task start time
+    */
+    public long getStartTime() {
+        return startTime;
+    }
+
+    /**
+     * Returns the task running time
+    */
+    public long getRunningTimeNanos() {
+        return runningTimeNanos;
+    }
+
+    /**
+     * Returns true if the task supports cancellation
+    */
+    public boolean isCancellable() {
+        return cancellable;
+    }
+
+    /**
+     * Returns true if the task has been cancelled
+    */
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    /**
+     * Returns the parent task id
+    */
+    public ProtobufTaskId getParentTaskId() {
+        return parentTaskId;
+    }
+
+    /**
+     * Returns the task headers
+    */
+    public Map<String, String> getHeaders() {
+        return headers;
+    }
+
+    /**
+     * Returns the task resource information
+    */
+    public ProtobufTaskResourceStats getResourceStats() {
+        return resourceStats;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java
new file mode 100644
index 0000000000000..30de39551c335
--- /dev/null
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java
@@ -0,0 +1,48 @@
+/*
+* 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.
+*/
+
+package org.opensearch.tasks;
+
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.tasks.proto.TaskResourceStatsProto;
+
+import com.google.protobuf.CodedOutputStream;
+import com.google.protobuf.CodedInputStream;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Resource information about a currently running task.
+* <p>
+* Writeable TaskResourceStats objects are used to represent resource
+* snapshot information about currently running task.
+*
+* @opensearch.internal
+*/
+public class ProtobufTaskResourceStats implements ProtobufWriteable {
+    private final TaskResourceStatsProto.TaskResourceStats taskResourceStats;
+
+    /**
+     * Read from a stream.
+    */
+    public ProtobufTaskResourceStats(CodedInputStream in) throws IOException {
+        this.taskResourceStats = TaskResourceStatsProto.TaskResourceStats.parseFrom(in.readByteArray());
+    }
+
+    public Map<String, TaskResourceStatsProto.TaskResourceStats.TaskResourceUsage> getResourceUsageInfo() {
+        return this.taskResourceStats.getResourceUsageMap();
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        this.taskResourceStats.writeTo(out);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
new file mode 100644
index 0000000000000..c3314ae40455f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
@@ -0,0 +1,226 @@
+/*
+* 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.
+*/
+
+package org.opensearch.tasks;
+
+import org.opensearch.OpenSearchException;
+import org.opensearch.client.Requests;
+import org.opensearch.common.Nullable;
+import org.opensearch.core.ParseField;
+import org.opensearch.common.Strings;
+import org.opensearch.common.bytes.BytesReference;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.StreamOutput;
+import org.opensearch.common.io.stream.Writeable;
+import org.opensearch.core.xcontent.InstantiatingObjectParser;
+import org.opensearch.common.xcontent.ObjectParserHelper;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.ToXContentObject;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.common.xcontent.XContentFactory;
+import org.opensearch.common.xcontent.XContentHelper;
+import org.opensearch.common.xcontent.XContentType;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.Objects;
+
+import static java.util.Collections.emptyMap;
+import static java.util.Objects.requireNonNull;
+import static org.opensearch.core.xcontent.ConstructingObjectParser.constructorArg;
+import static org.opensearch.core.xcontent.ConstructingObjectParser.optionalConstructorArg;
+import static org.opensearch.common.xcontent.XContentHelper.convertToMap;
+
+/**
+ * Information about a running task or a task that stored its result. Running tasks just have a {@link #getTask()} while
+* tasks with stored result will have either a {@link #getError()} or {@link #getResponse()}.
+*
+* @opensearch.internal
+*/
+public final class ProtobufTaskResult implements ProtobufWriteable, ToXContentObject {
+    private final boolean completed;
+    private final ProtobufTaskInfo task;
+    @Nullable
+    private final BytesReference error;
+    @Nullable
+    private final BytesReference response;
+
+    /**
+     * Construct a {@linkplain TaskResult} for a task for which we don't have a result or error. That usually means that the task
+    * is incomplete, but it could also mean that we waited for the task to complete but it didn't save any error information.
+    */
+    public ProtobufTaskResult(boolean completed, ProtobufTaskInfo task) {
+        this(completed, task, null, null);
+    }
+
+    /**
+     * Construct a {@linkplain TaskResult} for a task that completed with an error.
+    */
+    public ProtobufTaskResult(ProtobufTaskInfo task, Exception error) throws IOException {
+        this(true, task, toXContent(error), null);
+    }
+
+    /**
+     * Construct a {@linkplain ProtobufTaskResult} for a task that completed successfully.
+    */
+    public ProtobufTaskResult(ProtobufTaskInfo task, ToXContent response) throws IOException {
+        this(true, task, null, XContentHelper.toXContent(response, Requests.INDEX_CONTENT_TYPE, true));
+    }
+
+    public ProtobufTaskResult(boolean completed, ProtobufTaskInfo task, @Nullable BytesReference error, @Nullable BytesReference result) {
+        this.completed = completed;
+        this.task = requireNonNull(task, "task is required");
+        this.error = error;
+        this.response = result;
+    }
+
+    /**
+     * Read from a stream.
+    */
+    public ProtobufTaskResult(com.google.protobuf.CodedInputStream in) throws IOException {
+        completed = in.readBool();
+        task = new ProtobufTaskInfo(in);
+        error = in.readOptionalBytesReference();
+        response = in.readOptionalBytesReference();
+    }
+
+    @Override
+    public void writeTo(com.google.protobuf.CodedOutputStream out) throws IOException {
+        out.writeBool(0, completed);
+        task.writeTo(out);
+        out.writeByteArray(1, error);
+        out.writeOptionalBytesReference(response);
+    }
+
+    /**
+     * Get the task that this wraps.
+    */
+    public ProtobufTaskInfo getTask() {
+        return task;
+    }
+
+    /**
+     * Get the error that finished this task. Will return null if the task didn't finish with an error, it hasn't yet finished, or didn't
+    * store its result.
+    */
+    public BytesReference getError() {
+        return error;
+    }
+
+    /**
+     * Convert {@link #getError()} from XContent to a Map for easy processing. Will return an empty map if the task didn't finish with an
+    * error, hasn't yet finished, or didn't store its result.
+    */
+    public Map<String, Object> getErrorAsMap() {
+        if (error == null) {
+            return emptyMap();
+        }
+        return convertToMap(error, false).v2();
+    }
+
+    /**
+     * Get the response that this task finished with. Will return null if the task was finished by an error, it hasn't yet finished, or
+    * didn't store its result.
+    */
+    public BytesReference getResponse() {
+        return response;
+    }
+
+    /**
+     * Convert {@link #getResponse()} from XContent to a Map for easy processing. Will return an empty map if the task was finished with an
+    * error, hasn't yet finished, or didn't store its result.
+    */
+    public Map<String, Object> getResponseAsMap() {
+        if (response == null) {
+            return emptyMap();
+        }
+        return convertToMap(response, false).v2();
+    }
+
+    public boolean isCompleted() {
+        return completed;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        innerToXContent(builder, params);
+        return builder.endObject();
+    }
+
+    public XContentBuilder innerToXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.field("completed", completed);
+        builder.startObject("task");
+        task.toXContent(builder, params);
+        builder.endObject();
+        if (error != null) {
+            XContentHelper.writeRawField("error", error, builder, params);
+        }
+        if (response != null) {
+            XContentHelper.writeRawField("response", response, builder, params);
+        }
+        return builder;
+    }
+
+    public static final InstantiatingObjectParser<ProtobufTaskResult, Void> PARSER;
+
+    static {
+        InstantiatingObjectParser.Builder<ProtobufTaskResult, Void> parser = InstantiatingObjectParser.builder(
+            "stored_task_result",
+            true,
+            ProtobufTaskResult.class
+        );
+        parser.declareBoolean(constructorArg(), new ParseField("completed"));
+        parser.declareObject(constructorArg(), ProtobufTaskInfo.PARSER, new ParseField("task"));
+        ObjectParserHelper<ProtobufTaskResult, Void> parserHelper = new ObjectParserHelper<>();
+        parserHelper.declareRawObject(parser, optionalConstructorArg(), new ParseField("error"));
+        parserHelper.declareRawObject(parser, optionalConstructorArg(), new ParseField("response"));
+        PARSER = parser.build();
+    }
+
+    @Override
+    public String toString() {
+        return Strings.toString(XContentType.JSON, this);
+    }
+
+    // Implements equals and hashcode for testing
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null || obj.getClass() != ProtobufTaskResult.class) {
+            return false;
+        }
+        ProtobufTaskResult other = (ProtobufTaskResult) obj;
+        /*
+        * Equality of error and result is done by converting them to a map first. Not efficient but ignores field order and spacing
+        * differences so perfect for testing.
+        */
+        return Objects.equals(completed, other.completed)
+            && Objects.equals(task, other.task)
+            && Objects.equals(getErrorAsMap(), other.getErrorAsMap())
+            && Objects.equals(getResponseAsMap(), other.getResponseAsMap());
+    }
+
+    @Override
+    public int hashCode() {
+        /*
+        * Hashing of error and result is done by converting them to a map first. Not efficient but ignores field order and spacing
+        * differences so perfect for testing.
+        */
+        return Objects.hash(completed, task, getErrorAsMap(), getResponseAsMap());
+    }
+
+    private static BytesReference toXContent(Exception error) throws IOException {
+        try (XContentBuilder builder = XContentFactory.contentBuilder(Requests.INDEX_CONTENT_TYPE)) {
+            builder.startObject();
+            OpenSearchException.generateThrowableXContent(builder, ToXContent.EMPTY_PARAMS, error);
+            builder.endObject();
+            return BytesReference.bytes(builder);
+        }
+    }
+}

From c8c2f538a27178ac830eed7e9731dbcca5d8506c Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Fri, 21 Apr 2023 23:59:39 +0000
Subject: [PATCH 04/37] Adding ProtobufStreamInput and ProtobufStreamOutput for
 additional stream related functionality

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../common/io/stream/ProtobufStreamInput.java | 141 ++++++++++++++++++
 .../io/stream/ProtobufStreamOutput.java       |  63 ++++++++
 2 files changed, 204 insertions(+)
 create mode 100644 server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java
 create mode 100644 server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java

diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java
new file mode 100644
index 0000000000000..da867e7e487e1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java
@@ -0,0 +1,141 @@
+/*
+* 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.
+*/
+
+package org.opensearch.common.io.stream;
+
+import com.google.protobuf.CodedInputStream;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+
+import org.apache.lucene.util.ArrayUtil;
+import org.opensearch.Version;
+import org.opensearch.common.Nullable;
+
+public class ProtobufStreamInput {
+
+    private Version version = Version.CURRENT;
+
+    /**
+     * The version of the node on the other side of this stream.
+     */
+    public Version getVersion() {
+        return this.version;
+    }
+
+    /**
+     * Set the version of the node on the other side of this stream.
+     */
+    public void setVersion(Version version) {
+        this.version = version;
+    }
+
+    @Nullable
+    public String readOptionalString(CodedInputStream in) throws IOException {
+        if (readBoolean(in)) {
+            return in.readString();
+        }
+        return null;
+    }
+
+    /**
+     * If the returned map contains any entries it will be mutable. If it is empty it might be immutable.
+     */
+    public <K, V> Map<K, V> readMap(ProtobufWriteable.Reader<K> keyReader, ProtobufWriteable.Reader<V> valueReader, CodedInputStream in) throws IOException {
+        int size = readArraySize(in);
+        if (size == 0) {
+            return Collections.emptyMap();
+        }
+        Map<K, V> map = new HashMap<>(size);
+        for (int i = 0; i < size; i++) {
+            K key = keyReader.read(in);
+            V value = valueReader.read(in);
+            map.put(key, value);
+        }
+        return map;
+    }
+
+    @Nullable
+    public <T extends ProtobufWriteable> T readOptionalWriteable(ProtobufWriteable.Reader<T> reader, CodedInputStream in) throws IOException {
+        if (readBoolean(in)) {
+            T t = reader.read(in);
+            if (t == null) {
+                throw new IOException(
+                    "Writeable.Reader [" + reader + "] returned null which is not allowed and probably means it screwed up the stream."
+                );
+            }
+            return t;
+        } else {
+            return null;
+        }
+    }
+
+    private int readArraySize(CodedInputStream in) throws IOException {
+        final int arraySize = readVInt(in);
+        if (arraySize > ArrayUtil.MAX_ARRAY_LENGTH) {
+            throw new IllegalStateException("array length must be <= to " + ArrayUtil.MAX_ARRAY_LENGTH + " but was: " + arraySize);
+        }
+        if (arraySize < 0) {
+            throw new NegativeArraySizeException("array size must be positive but was: " + arraySize);
+        }
+        // lets do a sanity check that if we are reading an array size that is bigger that the remaining bytes we can safely
+        // throw an exception instead of allocating the array based on the size. A simple corrutpted byte can make a node go OOM
+        // if the size is large and for perf reasons we allocate arrays ahead of time
+        // ensureCanReadBytes(arraySize);
+        return arraySize;
+    }
+
+    public int readVInt(CodedInputStream in) throws IOException {
+        byte b = in.readRawByte();
+        int i = b & 0x7F;
+        if ((b & 0x80) == 0) {
+            return i;
+        }
+        b = in.readRawByte();
+        i |= (b & 0x7F) << 7;
+        if ((b & 0x80) == 0) {
+            return i;
+        }
+        b = in.readRawByte();
+        i |= (b & 0x7F) << 14;
+        if ((b & 0x80) == 0) {
+            return i;
+        }
+        b = in.readRawByte();
+        i |= (b & 0x7F) << 21;
+        if ((b & 0x80) == 0) {
+            return i;
+        }
+        b = in.readRawByte();
+        if ((b & 0x80) != 0) {
+            throw new IOException("Invalid vInt ((" + Integer.toHexString(b) + " & 0x7f) << 28) | " + Integer.toHexString(i));
+        }
+        return i | ((b & 0x7F) << 28);
+    }
+
+    /**
+     * Reads a boolean.
+     */
+    public final boolean readBoolean(CodedInputStream in) throws IOException {
+        return readBoolean(in.readRawByte());
+    }
+
+    private boolean readBoolean(final byte value) {
+        if (value == 0) {
+            return false;
+        } else if (value == 1) {
+            return true;
+        } else {
+            final String message = String.format(Locale.ROOT, "unexpected byte [0x%02x]", value);
+            throw new IllegalStateException(message);
+        }
+    }
+}
\ No newline at end of file
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java
new file mode 100644
index 0000000000000..7b69249a661bd
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java
@@ -0,0 +1,63 @@
+/*
+* 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.
+*/
+
+package org.opensearch.common.io.stream;
+
+import com.google.protobuf.CodedOutputStream;
+
+import java.io.IOException;
+import java.util.Map;
+
+import org.opensearch.Version;
+import org.opensearch.common.Nullable;
+
+public class ProtobufStreamOutput {
+
+    private Version version = Version.CURRENT;
+
+    /**
+     * The version of the node on the other side of this stream.
+     */
+    public Version getVersion() {
+        return this.version;
+    }
+
+    /**
+     * Set the version of the node on the other side of this stream.
+     */
+    public void setVersion(Version version) {
+        this.version = version;
+    }
+
+    /**
+     * Write a {@link Map} of {@code K}-type keys to {@code V}-type.
+     * <pre><code>
+     * Map&lt;String, String&gt; map = ...;
+     * out.writeMap(map, StreamOutput::writeString, StreamOutput::writeString);
+     * </code></pre>
+     *
+     * @param keyWriter The key writer
+     * @param valueWriter The value writer
+     */
+    public final <K, V> void writeMap(final Map<K, V> map, final ProtobufWriteable.Writer<K> keyWriter, final ProtobufWriteable.Writer<V> valueWriter, CodedOutputStream out) throws IOException {
+        for (final Map.Entry<K, V> entry : map.entrySet()) {
+            keyWriter.write(out, entry.getKey());
+            valueWriter.write(out, entry.getValue());
+        }
+    }
+
+    public void writeOptionalWriteable(@Nullable ProtobufWriteable writeable, CodedOutputStream out) throws IOException {
+        if (writeable != null) {
+            out.writeBool(1, true);
+            writeable.writeTo(out);
+        } else {
+            out.writeBool(1, false);
+        }
+    }
+
+}
\ No newline at end of file

From a2be2fa46ec67478031eba797ea738cbcfee5d60 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Sat, 22 Apr 2023 00:00:23 +0000
Subject: [PATCH 05/37] Adding TransportMessage and TransportRequest classes
 with protobuf integration

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../transport/ProtobufTransportMessage.java   | 43 ++++++++++++++
 .../transport/ProtobufTransportRequest.java   | 59 +++++++++++++++++++
 2 files changed, 102 insertions(+)
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportMessage.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportRequest.java

diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportMessage.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportMessage.java
new file mode 100644
index 0000000000000..0bca490774ec4
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportMessage.java
@@ -0,0 +1,43 @@
+/*
+ * 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.
+ */
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.transport.TransportAddress;
+
+/**
+ * Message over the transport interface with Protobuf serialization.
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufTransportMessage implements ProtobufWriteable {
+
+    private TransportAddress remoteAddress;
+
+    public void remoteAddress(TransportAddress remoteAddress) {
+        this.remoteAddress = remoteAddress;
+    }
+
+    public TransportAddress remoteAddress() {
+        return remoteAddress;
+    }
+
+    /**
+     * Constructs a new empty transport message
+    */
+    public ProtobufTransportMessage() {}
+
+    /**
+     * Constructs a new transport message with the data from the {@link CodedInputStream}. This is
+    * currently a no-op
+    */
+    public ProtobufTransportMessage(com.google.protobuf.CodedInputStream in) {}
+}
+ 
\ No newline at end of file
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportRequest.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportRequest.java
new file mode 100644
index 0000000000000..ec78e3cdb2bf1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportRequest.java
@@ -0,0 +1,59 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.StreamOutput;
+import org.opensearch.tasks.ProtobufTaskId;
+import org.opensearch.tasks.ProtobufTaskAwareRequest;
+import org.opensearch.tasks.TaskId;
+
+import java.io.IOException;
+
+/**
+ * A transport request with Protobuf serialization.
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufTransportRequest extends ProtobufTransportMessage implements ProtobufTaskAwareRequest {
+
+    /**
+     * Parent of this request. Defaults to {@link TaskId#EMPTY_TASK_ID}, meaning "no parent".
+    */
+    private ProtobufTaskId parentTaskId = ProtobufTaskId.EMPTY_TASK_ID;
+
+    public ProtobufTransportRequest() {}
+
+    public ProtobufTransportRequest(com.google.protobuf.CodedInputStream in) throws IOException {
+        parentTaskId = ProtobufTaskId.readFromStream(in);
+    }
+
+    /**
+     * Set a reference to task that created this request.
+    */
+    @Override
+    public void setParentTask(ProtobufTaskId taskId) {
+        this.parentTaskId = taskId;
+    }
+
+    /**
+     * Get a reference to the task that created this request. Defaults to {@link TaskId#EMPTY_TASK_ID}, meaning "there is no parent".
+    */
+    @Override
+    public ProtobufTaskId getParentTask() {
+        return parentTaskId;
+    }
+
+    @Override
+    public void writeTo(com.google.protobuf.CodedOutputStream out) throws IOException {
+        parentTaskId.writeTo(out);
+    }
+}

From c0bbf92ba1380d35871b9e30a389ac2934491532 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Tue, 25 Apr 2023 00:16:31 +0000
Subject: [PATCH 06/37] Fixing build and precommit

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 server/build.gradle                           |  1 +
 .../common/io/stream/BaseWriteable.java       |  4 +-
 .../common/io/stream/ProtobufStreamInput.java | 40 +++++++-
 .../io/stream/ProtobufStreamOutput.java       | 16 ++-
 .../tasks/ProtobufCancellableTask.java        | 14 ++-
 .../org/opensearch/tasks/ProtobufTask.java    | 20 +++-
 .../tasks/ProtobufTaskAwareRequest.java       |  3 +
 .../org/opensearch/tasks/ProtobufTaskId.java  |  6 +-
 .../opensearch/tasks/ProtobufTaskInfo.java    | 72 ++++++++++----
 .../tasks/ProtobufTaskResourceStats.java      | 28 +++++-
 .../opensearch/tasks/ProtobufTaskResult.java  | 99 +++++--------------
 .../transport/ProtobufTransportMessage.java   | 18 ++--
 .../transport/ProtobufTransportRequest.java   |  9 +-
 13 files changed, 204 insertions(+), 126 deletions(-)

diff --git a/server/build.gradle b/server/build.gradle
index 3fde1b745c546..efe2eae553364 100644
--- a/server/build.gradle
+++ b/server/build.gradle
@@ -394,6 +394,7 @@ tasks.named("licenseHeaders").configure {
     excludes << 'org/opensearch/client/documentation/placeholder.txt'
     // Ignore for protobuf generated code
     excludes << 'org/opensearch/extensions/proto/*'
+    excludes << 'org/opensearch/tasks/proto/*'
 }
 
 tasks.test {
diff --git a/server/src/main/java/org/opensearch/common/io/stream/BaseWriteable.java b/server/src/main/java/org/opensearch/common/io/stream/BaseWriteable.java
index 7d7fa18bb6afa..7364e1c24e47f 100644
--- a/server/src/main/java/org/opensearch/common/io/stream/BaseWriteable.java
+++ b/server/src/main/java/org/opensearch/common/io/stream/BaseWriteable.java
@@ -21,7 +21,7 @@ public interface BaseWriteable<T, S> {
      * Write this into the stream output.
     */
     void writeTo(T out) throws IOException;
-    
+
     /**
      * Reference to a method that can write some object to a given type.
      */
@@ -42,7 +42,7 @@ interface Writer<T, V> {
      */
     @FunctionalInterface
     interface Reader<S, V> {
- 
+
         /**
          * Read {@code V}-type value from a {@code T}-type stream.
         *
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java
index da867e7e487e1..843d6755e42d7 100644
--- a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java
+++ b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java
@@ -17,9 +17,15 @@
 import java.util.Map;
 
 import org.apache.lucene.util.ArrayUtil;
+
+import org.opensearch.common.bytes.BytesArray;
+import org.opensearch.common.bytes.BytesReference;
 import org.opensearch.Version;
 import org.opensearch.common.Nullable;
 
+/**
+ * A class for additional methods to read from a {@link CodedInputStream}.
+ */
 public class ProtobufStreamInput {
 
     private Version version = Version.CURRENT;
@@ -49,7 +55,8 @@ public String readOptionalString(CodedInputStream in) throws IOException {
     /**
      * If the returned map contains any entries it will be mutable. If it is empty it might be immutable.
      */
-    public <K, V> Map<K, V> readMap(ProtobufWriteable.Reader<K> keyReader, ProtobufWriteable.Reader<V> valueReader, CodedInputStream in) throws IOException {
+    public <K, V> Map<K, V> readMap(ProtobufWriteable.Reader<K> keyReader, ProtobufWriteable.Reader<V> valueReader, CodedInputStream in)
+        throws IOException {
         int size = readArraySize(in);
         if (size == 0) {
             return Collections.emptyMap();
@@ -64,7 +71,8 @@ public <K, V> Map<K, V> readMap(ProtobufWriteable.Reader<K> keyReader, ProtobufW
     }
 
     @Nullable
-    public <T extends ProtobufWriteable> T readOptionalWriteable(ProtobufWriteable.Reader<T> reader, CodedInputStream in) throws IOException {
+    public <T extends ProtobufWriteable> T readOptionalWriteable(ProtobufWriteable.Reader<T> reader, CodedInputStream in)
+        throws IOException {
         if (readBoolean(in)) {
             T t = reader.read(in);
             if (t == null) {
@@ -128,6 +136,32 @@ public final boolean readBoolean(CodedInputStream in) throws IOException {
         return readBoolean(in.readRawByte());
     }
 
+    /**
+     * Reads an optional bytes reference from this stream. It might hold an actual reference to the underlying bytes of the stream. Use this
+     * only if you must differentiate null from empty.
+     */
+    @Nullable
+    public BytesReference readOptionalBytesReference(CodedInputStream in) throws IOException {
+        int length = readVInt(in) - 1;
+        if (length < 0) {
+            return null;
+        }
+        return readBytesReference(length, in);
+    }
+
+    /**
+     * Reads a bytes reference from this stream, might hold an actual reference to the underlying
+     * bytes of the stream.
+     */
+    public BytesReference readBytesReference(int length, CodedInputStream in) throws IOException {
+        if (length == 0) {
+            return BytesArray.EMPTY;
+        }
+        byte[] bytes = new byte[length];
+        bytes = in.readByteArray();
+        return new BytesArray(bytes, 0, length);
+    }
+
     private boolean readBoolean(final byte value) {
         if (value == 0) {
             return false;
@@ -138,4 +172,4 @@ private boolean readBoolean(final byte value) {
             throw new IllegalStateException(message);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java
index 7b69249a661bd..b6082159d024a 100644
--- a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java
+++ b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java
@@ -16,6 +16,9 @@
 import org.opensearch.Version;
 import org.opensearch.common.Nullable;
 
+/**
+ * A class for additional methods to write to a {@link CodedOutputStream}.
+ */
 public class ProtobufStreamOutput {
 
     private Version version = Version.CURRENT;
@@ -44,7 +47,12 @@ public void setVersion(Version version) {
      * @param keyWriter The key writer
      * @param valueWriter The value writer
      */
-    public final <K, V> void writeMap(final Map<K, V> map, final ProtobufWriteable.Writer<K> keyWriter, final ProtobufWriteable.Writer<V> valueWriter, CodedOutputStream out) throws IOException {
+    public final <K, V> void writeMap(
+        final Map<K, V> map,
+        final ProtobufWriteable.Writer<K> keyWriter,
+        final ProtobufWriteable.Writer<V> valueWriter,
+        CodedOutputStream out
+    ) throws IOException {
         for (final Map.Entry<K, V> entry : map.entrySet()) {
             keyWriter.write(out, entry.getKey());
             valueWriter.write(out, entry.getValue());
@@ -53,11 +61,11 @@ public final <K, V> void writeMap(final Map<K, V> map, final ProtobufWriteable.W
 
     public void writeOptionalWriteable(@Nullable ProtobufWriteable writeable, CodedOutputStream out) throws IOException {
         if (writeable != null) {
-            out.writeBool(1, true);
+            out.writeBoolNoTag(true);
             writeable.writeTo(out);
         } else {
-            out.writeBool(1, false);
+            out.writeBoolNoTag(false);
         }
     }
 
-}
\ No newline at end of file
+}
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufCancellableTask.java b/server/src/main/java/org/opensearch/tasks/ProtobufCancellableTask.java
index 9e47da0265e86..fad1565390cd3 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufCancellableTask.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufCancellableTask.java
@@ -4,6 +4,9 @@
 * The OpenSearch Contributors require contributions made to
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
+*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
 */
 
 package org.opensearch.tasks;
@@ -17,7 +20,7 @@
 import static org.opensearch.search.SearchService.NO_TIMEOUT;
 
 /**
- * A task that can be canceled
+ * A protobuf task that can be canceled
 *
 * @opensearch.internal
 */
@@ -27,7 +30,14 @@ public abstract class ProtobufCancellableTask extends ProtobufTask {
     private final AtomicBoolean cancelled = new AtomicBoolean(false);
     private final TimeValue cancelAfterTimeInterval;
 
-    public ProtobufCancellableTask(long id, String type, String action, String description, ProtobufTaskId parentTaskId, Map<String, String> headers) {
+    public ProtobufCancellableTask(
+        long id,
+        String type,
+        String action,
+        String description,
+        ProtobufTaskId parentTaskId,
+        Map<String, String> headers
+    ) {
         this(id, type, action, description, parentTaskId, headers, NO_TIMEOUT);
     }
 
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTask.java b/server/src/main/java/org/opensearch/tasks/ProtobufTask.java
index dd3a446a0d120..7c7ee83adb679 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTask.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTask.java
@@ -4,6 +4,9 @@
 * The OpenSearch Contributors require contributions made to
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
+*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
 */
 
 package org.opensearch.tasks;
@@ -17,6 +20,7 @@
 import org.opensearch.common.io.stream.NamedWriteable;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.ToXContentObject;
+import org.opensearch.tasks.proto.TaskResourceStatsProto;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -28,7 +32,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 
 /**
- * Current task information
+ * Current protobuf task information
 *
 * @opensearch.internal
 */
@@ -167,7 +171,12 @@ protected final ProtobufTaskInfo taskInfo(String localNodeId, String description
     /**
      * Build a proper {@link ProtobufTaskInfo} for this task.
     */
-    protected final ProtobufTaskInfo taskInfo(String localNodeId, String description, Status status, TaskResourceStats resourceStats) {
+    protected final ProtobufTaskInfo taskInfo(
+        String localNodeId,
+        String description,
+        Status status,
+        ProtobufTaskResourceStats resourceStats
+    ) {
         return new ProtobufTaskInfo(
             new ProtobufTaskId(localNodeId, getId()),
             getType(),
@@ -255,8 +264,11 @@ public Map<Long, List<ThreadResourceInfo>> getResourceStats() {
     * Currently, this method is only called on demand, during get and listing of tasks.
     * In the future, these values can be cached as an optimization.
     */
-    public TaskResourceUsage getTotalResourceStats() {
-        return new TaskResourceUsage(getTotalResourceUtilization(ResourceStats.CPU), getTotalResourceUtilization(ResourceStats.MEMORY));
+    public TaskResourceStatsProto.TaskResourceStats.TaskResourceUsage getTotalResourceStats() {
+        return TaskResourceStatsProto.TaskResourceStats.TaskResourceUsage.newBuilder()
+            .setCpuTimeInNanos(getTotalResourceUtilization(ResourceStats.CPU))
+            .setMemoryInBytes(getTotalResourceUtilization(ResourceStats.MEMORY))
+            .build();
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskAwareRequest.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskAwareRequest.java
index beebdea5beebb..3ff06c87fb880 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskAwareRequest.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskAwareRequest.java
@@ -4,6 +4,9 @@
 * The OpenSearch Contributors require contributions made to
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
+*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
 */
 
 package org.opensearch.tasks;
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
index 81ba9e2cabd5d..5e0270c470f0b 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
@@ -4,13 +4,15 @@
 * The OpenSearch Contributors require contributions made to
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
+*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
 */
 
 package org.opensearch.tasks;
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
-import org.opensearch.OpenSearchParseException;
 import org.opensearch.common.Strings;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.tasks.proto.TaskIdProto;
@@ -74,7 +76,7 @@ public static ProtobufTaskId readFromStream(CodedInputStream in) throws IOExcept
     }
 
     @Override
-    public void writeTo(com.google.protobuf.CodedOutputStream out) throws IOException {
+    public void writeTo(CodedOutputStream out) throws IOException {
         this.taskId.writeTo(out);
     }
 
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
index e0acdb7f54ec1..71939b4be2bfb 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
@@ -4,6 +4,9 @@
 * The OpenSearch Contributors require contributions made to
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
+*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
 */
 
 package org.opensearch.tasks;
@@ -11,23 +14,17 @@
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
 import org.opensearch.Version;
-import org.opensearch.common.Strings;
-import org.opensearch.common.bytes.BytesReference;
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.io.stream.Writeable;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
 
 import java.io.IOException;
-import java.util.Collections;
 import java.util.Map;
-import java.util.Objects;
 import java.util.concurrent.TimeUnit;
 
-import static org.opensearch.core.xcontent.ConstructingObjectParser.constructorArg;
-import static org.opensearch.core.xcontent.ConstructingObjectParser.optionalConstructorArg;
-
 /**
  * Information about a currently running task.
 * <p>
@@ -38,7 +35,7 @@
 *
 * @opensearch.internal
 */
-public final class ProtobufTaskInfo implements ProtobufWriteable {
+public final class ProtobufTaskInfo implements ProtobufWriteable, ToXContentFragment {
     private final ProtobufTaskId taskId;
 
     private final String type;
@@ -108,7 +105,7 @@ public ProtobufTaskInfo(CodedInputStream in) throws IOException {
         type = in.readString();
         action = in.readString();
         description = protobufStreamInput.readOptionalString(in);
-        //TODO: fix this
+        // TODO: fix this
         status = null;
         startTime = in.readInt64();
         runningTimeNanos = in.readInt64();
@@ -134,21 +131,21 @@ public ProtobufTaskInfo(CodedInputStream in) throws IOException {
     public void writeTo(CodedOutputStream out) throws IOException {
         protobufStreamOutput = new ProtobufStreamOutput();
         taskId.writeTo(out);
-        out.writeString(1, type);
-        out.writeString(2, action);
-        out.writeString(3, description);
-        //TODO: fix this
+        out.writeStringNoTag(type);
+        out.writeStringNoTag(action);
+        out.writeStringNoTag(description);
+        // TODO: fix this
         // out.writeOptionalNamedWriteable(status);
-        out.writeInt64(4, startTime);
-        out.writeInt64(5, runningTimeNanos);
-        out.writeBool(6, cancellable);
+        out.writeInt64NoTag(startTime);
+        out.writeInt64NoTag(runningTimeNanos);
+        out.writeBoolNoTag(cancellable);
         if (protobufStreamOutput.getVersion().onOrAfter(Version.V_2_0_0)) {
-            out.writeBool(7, cancelled);
+            out.writeBoolNoTag(cancelled);
         }
         parentTaskId.writeTo(out);
-        protobufStreamOutput.writeMap(headers, CodedOutputStream::writeString, CodedOutputStream::writeString, out);
+        protobufStreamOutput.writeMap(headers, CodedOutputStream::writeStringNoTag, CodedOutputStream::writeStringNoTag, out);
         if (protobufStreamOutput.getVersion().onOrAfter(Version.V_2_1_0)) {
-            out.writeOptionalWriteable(resourceStats, out);
+            protobufStreamOutput.writeOptionalWriteable(resourceStats, out);
         }
     }
 
@@ -228,4 +225,39 @@ public Map<String, String> getHeaders() {
     public ProtobufTaskResourceStats getResourceStats() {
         return resourceStats;
     }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.field("node", taskId.getNodeId());
+        builder.field("id", taskId.getId());
+        builder.field("type", type);
+        builder.field("action", action);
+        if (status != null) {
+            builder.field("status", status, params);
+        }
+        if (description != null) {
+            builder.field("description", description);
+        }
+        builder.timeField("start_time_in_millis", "start_time", startTime);
+        if (builder.humanReadable()) {
+            builder.field("running_time", new TimeValue(runningTimeNanos, TimeUnit.NANOSECONDS).toString());
+        }
+        builder.field("running_time_in_nanos", runningTimeNanos);
+        builder.field("cancellable", cancellable);
+        builder.field("cancelled", cancelled);
+        if (parentTaskId.isSet()) {
+            builder.field("parent_task_id", parentTaskId.toString());
+        }
+        builder.startObject("headers");
+        for (Map.Entry<String, String> attribute : headers.entrySet()) {
+            builder.field(attribute.getKey(), attribute.getValue());
+        }
+        builder.endObject();
+        if (resourceStats != null) {
+            builder.startObject("resource_stats");
+            resourceStats.toXContent(builder, params);
+            builder.endObject();
+        }
+        return builder;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java
index 30de39551c335..61220be1026a9 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java
@@ -4,20 +4,23 @@
 * The OpenSearch Contributors require contributions made to
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
+*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
 */
 
 package org.opensearch.tasks;
 
 import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.tasks.proto.TaskResourceStatsProto;
 
 import com.google.protobuf.CodedOutputStream;
 import com.google.protobuf.CodedInputStream;
 
 import java.io.IOException;
-import java.util.HashMap;
 import java.util.Map;
-import java.util.Objects;
 
 /**
  * Resource information about a currently running task.
@@ -27,9 +30,13 @@
 *
 * @opensearch.internal
 */
-public class ProtobufTaskResourceStats implements ProtobufWriteable {
+public class ProtobufTaskResourceStats implements ProtobufWriteable, ToXContentFragment {
     private final TaskResourceStatsProto.TaskResourceStats taskResourceStats;
 
+    public ProtobufTaskResourceStats(Map<String, TaskResourceStatsProto.TaskResourceStats.TaskResourceUsage> resourceUsage) {
+        this.taskResourceStats = TaskResourceStatsProto.TaskResourceStats.newBuilder().putAllResourceUsage(resourceUsage).build();
+    }
+
     /**
      * Read from a stream.
     */
@@ -45,4 +52,19 @@ public Map<String, TaskResourceStatsProto.TaskResourceStats.TaskResourceUsage> g
     public void writeTo(CodedOutputStream out) throws IOException {
         this.taskResourceStats.writeTo(out);
     }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        Map<String, TaskResourceStatsProto.TaskResourceStats.TaskResourceUsage> resourceUsage = this.taskResourceStats
+            .getResourceUsageMap();
+        for (Map.Entry<String, TaskResourceStatsProto.TaskResourceStats.TaskResourceUsage> resourceUsageEntry : resourceUsage.entrySet()) {
+            builder.startObject(resourceUsageEntry.getKey());
+            if (resourceUsageEntry.getValue() != null) {
+                builder.field("cpu_time_in_nanos", resourceUsageEntry.getValue().getCpuTimeInNanos());
+                builder.field("memory_in_bytes", resourceUsageEntry.getValue().getMemoryInBytes());
+            }
+            builder.endObject();
+        }
+        return builder;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
index c3314ae40455f..d4a2402961cc1 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
@@ -4,41 +4,36 @@
 * The OpenSearch Contributors require contributions made to
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
+*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
 */
 
 package org.opensearch.tasks;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
 import org.opensearch.OpenSearchException;
 import org.opensearch.client.Requests;
 import org.opensearch.common.Nullable;
-import org.opensearch.core.ParseField;
-import org.opensearch.common.Strings;
 import org.opensearch.common.bytes.BytesReference;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.io.stream.StreamInput;
-import org.opensearch.common.io.stream.StreamOutput;
-import org.opensearch.common.io.stream.Writeable;
-import org.opensearch.core.xcontent.InstantiatingObjectParser;
-import org.opensearch.common.xcontent.ObjectParserHelper;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.ToXContentObject;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.common.xcontent.XContentFactory;
 import org.opensearch.common.xcontent.XContentHelper;
-import org.opensearch.common.xcontent.XContentType;
 
 import java.io.IOException;
 import java.util.Map;
-import java.util.Objects;
 
 import static java.util.Collections.emptyMap;
 import static java.util.Objects.requireNonNull;
-import static org.opensearch.core.xcontent.ConstructingObjectParser.constructorArg;
-import static org.opensearch.core.xcontent.ConstructingObjectParser.optionalConstructorArg;
 import static org.opensearch.common.xcontent.XContentHelper.convertToMap;
 
 /**
- * Information about a running task or a task that stored its result. Running tasks just have a {@link #getTask()} while
+* Information about a running task or a task that stored its result. Running tasks just have a {@link #getTask()} while
 * tasks with stored result will have either a {@link #getError()} or {@link #getResponse()}.
 *
 * @opensearch.internal
@@ -51,6 +46,8 @@ public final class ProtobufTaskResult implements ProtobufWriteable, ToXContentOb
     @Nullable
     private final BytesReference response;
 
+    private ProtobufStreamInput protobufStreamInput;
+
     /**
      * Construct a {@linkplain TaskResult} for a task for which we don't have a result or error. That usually means that the task
     * is incomplete, but it could also mean that we waited for the task to complete but it didn't save any error information.
@@ -60,14 +57,14 @@ public ProtobufTaskResult(boolean completed, ProtobufTaskInfo task) {
     }
 
     /**
-     * Construct a {@linkplain TaskResult} for a task that completed with an error.
+    * Construct a {@linkplain TaskResult} for a task that completed with an error.
     */
     public ProtobufTaskResult(ProtobufTaskInfo task, Exception error) throws IOException {
         this(true, task, toXContent(error), null);
     }
 
     /**
-     * Construct a {@linkplain ProtobufTaskResult} for a task that completed successfully.
+    * Construct a {@linkplain ProtobufTaskResult} for a task that completed successfully.
     */
     public ProtobufTaskResult(ProtobufTaskInfo task, ToXContent response) throws IOException {
         this(true, task, null, XContentHelper.toXContent(response, Requests.INDEX_CONTENT_TYPE, true));
@@ -81,32 +78,33 @@ public ProtobufTaskResult(boolean completed, ProtobufTaskInfo task, @Nullable By
     }
 
     /**
-     * Read from a stream.
+    * Read from a stream.
     */
-    public ProtobufTaskResult(com.google.protobuf.CodedInputStream in) throws IOException {
+    public ProtobufTaskResult(CodedInputStream in) throws IOException {
+        protobufStreamInput = new ProtobufStreamInput();
         completed = in.readBool();
         task = new ProtobufTaskInfo(in);
-        error = in.readOptionalBytesReference();
-        response = in.readOptionalBytesReference();
+        error = protobufStreamInput.readOptionalBytesReference(in);
+        response = protobufStreamInput.readOptionalBytesReference(in);
     }
 
     @Override
-    public void writeTo(com.google.protobuf.CodedOutputStream out) throws IOException {
-        out.writeBool(0, completed);
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeBoolNoTag(completed);
         task.writeTo(out);
-        out.writeByteArray(1, error);
-        out.writeOptionalBytesReference(response);
+        out.writeByteArrayNoTag(BytesReference.toBytes(error));
+        out.writeByteArrayNoTag(BytesReference.toBytes(response));
     }
 
     /**
-     * Get the task that this wraps.
+    * Get the task that this wraps.
     */
     public ProtobufTaskInfo getTask() {
         return task;
     }
 
     /**
-     * Get the error that finished this task. Will return null if the task didn't finish with an error, it hasn't yet finished, or didn't
+    * Get the error that finished this task. Will return null if the task didn't finish with an error, it hasn't yet finished, or didn't
     * store its result.
     */
     public BytesReference getError() {
@@ -114,7 +112,7 @@ public BytesReference getError() {
     }
 
     /**
-     * Convert {@link #getError()} from XContent to a Map for easy processing. Will return an empty map if the task didn't finish with an
+    * Convert {@link #getError()} from XContent to a Map for easy processing. Will return an empty map if the task didn't finish with an
     * error, hasn't yet finished, or didn't store its result.
     */
     public Map<String, Object> getErrorAsMap() {
@@ -125,7 +123,7 @@ public Map<String, Object> getErrorAsMap() {
     }
 
     /**
-     * Get the response that this task finished with. Will return null if the task was finished by an error, it hasn't yet finished, or
+    * Get the response that this task finished with. Will return null if the task was finished by an error, it hasn't yet finished, or
     * didn't store its result.
     */
     public BytesReference getResponse() {
@@ -133,7 +131,7 @@ public BytesReference getResponse() {
     }
 
     /**
-     * Convert {@link #getResponse()} from XContent to a Map for easy processing. Will return an empty map if the task was finished with an
+    * Convert {@link #getResponse()} from XContent to a Map for easy processing. Will return an empty map if the task was finished with an
     * error, hasn't yet finished, or didn't store its result.
     */
     public Map<String, Object> getResponseAsMap() {
@@ -168,53 +166,6 @@ public XContentBuilder innerToXContent(XContentBuilder builder, Params params) t
         return builder;
     }
 
-    public static final InstantiatingObjectParser<ProtobufTaskResult, Void> PARSER;
-
-    static {
-        InstantiatingObjectParser.Builder<ProtobufTaskResult, Void> parser = InstantiatingObjectParser.builder(
-            "stored_task_result",
-            true,
-            ProtobufTaskResult.class
-        );
-        parser.declareBoolean(constructorArg(), new ParseField("completed"));
-        parser.declareObject(constructorArg(), ProtobufTaskInfo.PARSER, new ParseField("task"));
-        ObjectParserHelper<ProtobufTaskResult, Void> parserHelper = new ObjectParserHelper<>();
-        parserHelper.declareRawObject(parser, optionalConstructorArg(), new ParseField("error"));
-        parserHelper.declareRawObject(parser, optionalConstructorArg(), new ParseField("response"));
-        PARSER = parser.build();
-    }
-
-    @Override
-    public String toString() {
-        return Strings.toString(XContentType.JSON, this);
-    }
-
-    // Implements equals and hashcode for testing
-    @Override
-    public boolean equals(Object obj) {
-        if (obj == null || obj.getClass() != ProtobufTaskResult.class) {
-            return false;
-        }
-        ProtobufTaskResult other = (ProtobufTaskResult) obj;
-        /*
-        * Equality of error and result is done by converting them to a map first. Not efficient but ignores field order and spacing
-        * differences so perfect for testing.
-        */
-        return Objects.equals(completed, other.completed)
-            && Objects.equals(task, other.task)
-            && Objects.equals(getErrorAsMap(), other.getErrorAsMap())
-            && Objects.equals(getResponseAsMap(), other.getResponseAsMap());
-    }
-
-    @Override
-    public int hashCode() {
-        /*
-        * Hashing of error and result is done by converting them to a map first. Not efficient but ignores field order and spacing
-        * differences so perfect for testing.
-        */
-        return Objects.hash(completed, task, getErrorAsMap(), getResponseAsMap());
-    }
-
     private static BytesReference toXContent(Exception error) throws IOException {
         try (XContentBuilder builder = XContentFactory.contentBuilder(Requests.INDEX_CONTENT_TYPE)) {
             builder.startObject();
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportMessage.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportMessage.java
index 0bca490774ec4..0ec5f5cb5de9c 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportMessage.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportMessage.java
@@ -1,10 +1,13 @@
 /*
- * 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.
- */
+* 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.
+*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
 
 package org.opensearch.transport;
 
@@ -38,6 +41,5 @@ public ProtobufTransportMessage() {}
      * Constructs a new transport message with the data from the {@link CodedInputStream}. This is
     * currently a no-op
     */
-    public ProtobufTransportMessage(com.google.protobuf.CodedInputStream in) {}
+    public ProtobufTransportMessage(CodedInputStream in) {}
 }
- 
\ No newline at end of file
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportRequest.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportRequest.java
index ec78e3cdb2bf1..3511655702a89 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportRequest.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportRequest.java
@@ -4,14 +4,15 @@
 * The OpenSearch Contributors require contributions made to
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
+*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
 */
 
 package org.opensearch.transport;
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.StreamInput;
-import org.opensearch.common.io.stream.StreamOutput;
 import org.opensearch.tasks.ProtobufTaskId;
 import org.opensearch.tasks.ProtobufTaskAwareRequest;
 import org.opensearch.tasks.TaskId;
@@ -32,7 +33,7 @@ public abstract class ProtobufTransportRequest extends ProtobufTransportMessage
 
     public ProtobufTransportRequest() {}
 
-    public ProtobufTransportRequest(com.google.protobuf.CodedInputStream in) throws IOException {
+    public ProtobufTransportRequest(CodedInputStream in) throws IOException {
         parentTaskId = ProtobufTaskId.readFromStream(in);
     }
 
@@ -53,7 +54,7 @@ public ProtobufTaskId getParentTask() {
     }
 
     @Override
-    public void writeTo(com.google.protobuf.CodedOutputStream out) throws IOException {
+    public void writeTo(CodedOutputStream out) throws IOException {
         parentTaskId.writeTo(out);
     }
 }

From 551fe82c4768fc483098edd94cde68d60d03f6da Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Mon, 8 May 2023 06:40:51 +0000
Subject: [PATCH 07/37] Adding protobuf integrations for client, transport,
 request

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../src/main/java/org/opensearch/Build.java   |   50 +
 .../src/main/java/org/opensearch/Version.java |    5 +
 .../ProtobufOpenSearchException.java          |   45 +
 .../action/ProtobufActionRequest.java         |   53 +
 .../action/ProtobufActionRequestBuilder.java  |   67 +
 .../action/ProtobufActionResponse.java        |   33 +
 .../opensearch/action/ProtobufActionType.java |   65 +
 .../action/ProtobufFailedNodeException.java   |   46 +
 .../cluster/node/info/ProtobufNodeInfo.java   |  335 ++++
 .../node/info/ProtobufNodesInfoRequest.java   |  165 ++
 .../node/info/ProtobufNodesInfoResponse.java  |   76 +
 .../node/info/ProtobufPluginsAndModules.java  |   77 +
 .../node/stats/ProtobufNodesStatsRequest.java |  202 +++
 .../state/ProtobufClusterStateAction.java     |   27 +
 .../state/ProtobufClusterStateRequest.java    |  199 +++
 .../ProtobufClusterStateRequestBuilder.java   |  119 ++
 .../state/ProtobufClusterStateResponse.java   |   85 +
 .../stats/ProtobufCommonStatsFlags.java       |  279 +++
 .../action/support/IndicesOptions.java        |   18 +
 .../action/support/ProtobufActionFilter.java  |   67 +
 .../support/ProtobufActionFilterChain.java    |   30 +
 .../action/support/ProtobufActionFilters.java |   40 +
 .../support/ProtobufTransportAction.java      |  245 +++
 ...terManagerNodeOperationRequestBuilder.java |   76 +
 ...anagerNodeReadOperationRequestBuilder.java |   39 +
 ...ProtobufClusterManagerNodeReadRequest.java |   58 +
 .../ProtobufClusterManagerNodeRequest.java    |  108 ++
 .../nodes/ProtobufBaseNodeResponse.java       |   53 +
 .../nodes/ProtobufBaseNodesRequest.java       |  119 ++
 .../nodes/ProtobufBaseNodesResponse.java      |  133 ++
 .../opensearch/client/ClusterAdminClient.java |    4 +
 .../client/ProtobufAdminClient.java           |   48 +
 .../org/opensearch/client/ProtobufClient.java |   32 +
 .../client/ProtobufClusterAdminClient.java    |  220 +++
 .../client/ProtobufOpenSearchClient.java      |   63 +
 .../client/node/ProtobufNodeClient.java       |  139 ++
 .../client/support/AbstractClient.java        |   19 +
 .../support/ProtobufAbstractClient.java       |  581 ++++++
 .../cluster/ProtobufClusterChangedEvent.java  |  307 ++++
 .../cluster/ProtobufClusterName.java          |   61 +
 .../cluster/ProtobufClusterState.java         |  803 +++++++++
 .../cluster/ProtobufClusterStateApplier.java  |   29 +
 .../org/opensearch/cluster/ProtobufDiff.java  |   29 +
 .../opensearch/cluster/ProtobufDiffable.java  |   30 +
 .../cluster/ProtobufDiffableUtils.java        |  812 +++++++++
 .../opensearch/cluster/ProtobufNamedDiff.java |   32 +
 .../cluster/ProtobufNamedDiffable.java        |   24 +
 .../ProtobufNamedDiffableValueSerializer.java |   59 +
 .../cluster/node/ProtobufDiscoveryNode.java   |  518 ++++++
 .../cluster/node/ProtobufDiscoveryNodes.java  |  886 ++++++++++
 .../cluster/routing/RoutingNodes.java         |   59 +
 .../io/stream/ProtobufNamedWriteable.java     |   29 +
 .../common/io/stream/ProtobufStreamInput.java |  155 ++
 .../io/stream/ProtobufStreamOutput.java       |  120 ++
 .../ProtobufVersionedNamedWriteable.java      |   34 +
 .../opensearch/common/settings/Settings.java  |   29 +
 .../ProtobufBoundTransportAddress.java        |   68 +
 .../transport/ProtobufTransportAddress.java   |  108 ++
 .../common/unit/ProtobufSizeValue.java        |  136 ++
 .../common/util/concurrent/ThreadContext.java |   48 +-
 .../org/opensearch/http/ProtobufHttpInfo.java |   64 +
 .../opensearch/ingest/ProtobufIngestInfo.java |   59 +
 .../ingest/ProtobufProcessorInfo.java         |   48 +
 .../monitor/jvm/ProtobufJvmInfo.java          |  571 ++++++
 .../opensearch/monitor/os/ProtobufOsInfo.java |  103 ++
 .../monitor/process/ProtobufProcessInfo.java  |   65 +
 .../node/ProtobufReportingService.java        |   29 +
 .../plugins/ProtobufPluginInfo.java           |  350 ++++
 .../org/opensearch/rest/BaseRestHandler.java  |   29 +
 .../rest/action/cat/RestNodesAction.java      |   36 +-
 .../support/ProtobufAggregationInfo.java      |   71 +
 .../pipeline/ProtobufSearchPipelineInfo.java  |   56 +
 .../org/opensearch/tasks/ProtobufTask.java    |    8 +-
 .../ProtobufTaskCancellationService.java      |  236 +++
 .../opensearch/tasks/ProtobufTaskManager.java |  752 ++++++++
 .../ProtobufTaskResourceTrackingService.java  |  270 +++
 .../opensearch/tasks/TaskResultsService.java  |   58 +
 .../threadpool/ProtobufExecutorBuilder.java   |   91 +
 .../ProtobufFixedExecutorBuilder.java         |  182 ++
 .../ProtobufResizableExecutorBuilder.java     |  134 ++
 .../ProtobufScalingExecutorBuilder.java       |  141 ++
 .../threadpool/ProtobufThreadPool.java        |  860 +++++++++
 .../threadpool/ProtobufThreadPoolInfo.java    |   51 +
 .../transport/ProtobufNetworkMessage.java     |   62 +
 .../transport/ProtobufOutboundMessage.java    |  191 ++
 .../ProtobufRequestHandlerRegistry.java       |  125 ++
 .../ProtobufTaskTransportChannel.java         |   67 +
 .../ProtobufTcpTransportChannel.java          |  112 ++
 .../transport/ProtobufTransport.java          |  274 +++
 .../transport/ProtobufTransportChannel.java   |   56 +
 .../transport/ProtobufTransportInfo.java      |  138 ++
 .../ProtobufTransportMessageListener.java     |   69 +
 .../ProtobufTransportRequestHandler.java      |   22 +
 .../transport/ProtobufTransportResponse.java  |   59 +
 .../transport/ProtobufTransportService.java   | 1557 +++++++++++++++++
 95 files changed, 15372 insertions(+), 20 deletions(-)
 create mode 100644 server/src/main/java/org/opensearch/ProtobufOpenSearchException.java
 create mode 100644 server/src/main/java/org/opensearch/action/ProtobufActionRequest.java
 create mode 100644 server/src/main/java/org/opensearch/action/ProtobufActionRequestBuilder.java
 create mode 100644 server/src/main/java/org/opensearch/action/ProtobufActionResponse.java
 create mode 100644 server/src/main/java/org/opensearch/action/ProtobufActionType.java
 create mode 100644 server/src/main/java/org/opensearch/action/ProtobufFailedNodeException.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufPluginsAndModules.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateAction.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequestBuilder.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStatsFlags.java
 create mode 100644 server/src/main/java/org/opensearch/action/support/ProtobufActionFilter.java
 create mode 100644 server/src/main/java/org/opensearch/action/support/ProtobufActionFilterChain.java
 create mode 100644 server/src/main/java/org/opensearch/action/support/ProtobufActionFilters.java
 create mode 100644 server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
 create mode 100644 server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeOperationRequestBuilder.java
 create mode 100644 server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadOperationRequestBuilder.java
 create mode 100644 server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadRequest.java
 create mode 100644 server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeRequest.java
 create mode 100644 server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
 create mode 100644 server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
 create mode 100644 server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java
 create mode 100644 server/src/main/java/org/opensearch/client/ProtobufAdminClient.java
 create mode 100644 server/src/main/java/org/opensearch/client/ProtobufClient.java
 create mode 100644 server/src/main/java/org/opensearch/client/ProtobufClusterAdminClient.java
 create mode 100644 server/src/main/java/org/opensearch/client/ProtobufOpenSearchClient.java
 create mode 100644 server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java
 create mode 100644 server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufClusterChangedEvent.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufClusterName.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufClusterStateApplier.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufDiff.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufDiffableUtils.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufNamedDiff.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffable.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffableValueSerializer.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNode.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java
 create mode 100644 server/src/main/java/org/opensearch/common/io/stream/ProtobufNamedWriteable.java
 create mode 100644 server/src/main/java/org/opensearch/common/io/stream/ProtobufVersionedNamedWriteable.java
 create mode 100644 server/src/main/java/org/opensearch/common/transport/ProtobufBoundTransportAddress.java
 create mode 100644 server/src/main/java/org/opensearch/common/transport/ProtobufTransportAddress.java
 create mode 100644 server/src/main/java/org/opensearch/common/unit/ProtobufSizeValue.java
 create mode 100644 server/src/main/java/org/opensearch/http/ProtobufHttpInfo.java
 create mode 100644 server/src/main/java/org/opensearch/ingest/ProtobufIngestInfo.java
 create mode 100644 server/src/main/java/org/opensearch/ingest/ProtobufProcessorInfo.java
 create mode 100644 server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java
 create mode 100644 server/src/main/java/org/opensearch/monitor/os/ProtobufOsInfo.java
 create mode 100644 server/src/main/java/org/opensearch/monitor/process/ProtobufProcessInfo.java
 create mode 100644 server/src/main/java/org/opensearch/node/ProtobufReportingService.java
 create mode 100644 server/src/main/java/org/opensearch/plugins/ProtobufPluginInfo.java
 create mode 100644 server/src/main/java/org/opensearch/search/aggregations/support/ProtobufAggregationInfo.java
 create mode 100644 server/src/main/java/org/opensearch/search/pipeline/ProtobufSearchPipelineInfo.java
 create mode 100644 server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
 create mode 100644 server/src/main/java/org/opensearch/tasks/ProtobufTaskManager.java
 create mode 100644 server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceTrackingService.java
 create mode 100644 server/src/main/java/org/opensearch/threadpool/ProtobufExecutorBuilder.java
 create mode 100644 server/src/main/java/org/opensearch/threadpool/ProtobufFixedExecutorBuilder.java
 create mode 100644 server/src/main/java/org/opensearch/threadpool/ProtobufResizableExecutorBuilder.java
 create mode 100644 server/src/main/java/org/opensearch/threadpool/ProtobufScalingExecutorBuilder.java
 create mode 100644 server/src/main/java/org/opensearch/threadpool/ProtobufThreadPool.java
 create mode 100644 server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufNetworkMessage.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTaskTransportChannel.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTcpTransportChannel.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransport.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportChannel.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportInfo.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportRequestHandler.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportResponse.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportService.java

diff --git a/libs/core/src/main/java/org/opensearch/Build.java b/libs/core/src/main/java/org/opensearch/Build.java
index 67a50a8a31a0e..8a2d3e94bc0ec 100644
--- a/libs/core/src/main/java/org/opensearch/Build.java
+++ b/libs/core/src/main/java/org/opensearch/Build.java
@@ -32,6 +32,8 @@
 
 package org.opensearch;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
 import org.opensearch.common.Booleans;
 import org.opensearch.core.util.FileSystemUtils;
 
@@ -206,6 +208,54 @@ public String date() {
         return date;
     }
 
+    public static Build readBuild(StreamInput in) throws IOException {
+        // the following is new for opensearch: we write the distribution to support any "forks"
+        final String distribution = in.readString();
+        // be lenient when reading on the wire, the enumeration values from other versions might be different than what we know
+        final Type type = Type.fromDisplayName(in.readString(), false);
+        String hash = in.readString();
+        String date = in.readString();
+        boolean snapshot = in.readBoolean();
+        final String version = in.readString();
+        return new Build(type, hash, date, snapshot, version, distribution);
+    }
+
+    public static Build readBuildProtobuf(CodedInputStream in) throws IOException {
+        // the following is new for opensearch: we write the distribution to support any "forks"
+        final String distribution = in.readString();
+        // be lenient when reading on the wire, the enumeration values from other versions might be different than what we know
+        final Type type = Type.fromDisplayName(in.readString(), false);
+        String hash = in.readString();
+        String date = in.readString();
+        boolean snapshot = in.readBool();
+        final String version = in.readString();
+        return new Build(type, hash, date, snapshot, version, distribution);
+    }
+
+    public static void writeBuild(Build build, StreamOutput out) throws IOException {
+        // the following is new for opensearch: we write the distribution name to support any "forks" of the code
+        out.writeString(build.distribution);
+
+        final Type buildType = build.type();
+        out.writeString(buildType.displayName());
+        out.writeString(build.hash());
+        out.writeString(build.date());
+        out.writeBoolean(build.isSnapshot());
+        out.writeString(build.getQualifiedVersion());
+    }
+
+    public static void writeBuildProtobuf(Build build, CodedOutputStream out) throws IOException {
+        // the following is new for opensearch: we write the distribution name to support any "forks" of the code
+        out.writeStringNoTag(build.distribution);
+
+        final Type buildType = build.type();
+        out.writeStringNoTag(buildType.displayName());
+        out.writeStringNoTag(build.hash());
+        out.writeStringNoTag(build.date());
+        out.writeBoolNoTag(build.isSnapshot());
+        out.writeStringNoTag(build.getQualifiedVersion());
+    }
+
     /**
      * Get the distribution name (expected to be OpenSearch; empty if legacy; something else if forked)
      * @return distribution name as a string
diff --git a/libs/core/src/main/java/org/opensearch/Version.java b/libs/core/src/main/java/org/opensearch/Version.java
index 3f83282245fd8..b1cba4f2b69fc 100644
--- a/libs/core/src/main/java/org/opensearch/Version.java
+++ b/libs/core/src/main/java/org/opensearch/Version.java
@@ -32,6 +32,7 @@
 
 package org.opensearch;
 
+import com.google.protobuf.CodedInputStream;
 import org.opensearch.common.SuppressForbidden;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
@@ -95,6 +96,10 @@ public class Version implements Comparable<Version>, ToXContentFragment {
     public static final Version V_3_0_0 = new Version(3000099, org.apache.lucene.util.Version.LUCENE_9_8_0);
     public static final Version CURRENT = V_3_0_0;
 
+    public static Version readVersionProtobuf(CodedInputStream in) throws IOException {
+        return fromId(in.readInt32());
+    }
+
     public static Version fromId(int id) {
         final Version known = LegacyESVersion.idToVersion.get(id);
         if (known != null) {
diff --git a/server/src/main/java/org/opensearch/ProtobufOpenSearchException.java b/server/src/main/java/org/opensearch/ProtobufOpenSearchException.java
new file mode 100644
index 0000000000000..30c9e8be2cfb6
--- /dev/null
+++ b/server/src/main/java/org/opensearch/ProtobufOpenSearchException.java
@@ -0,0 +1,45 @@
+/*
+* 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.
+*/
+
+package org.opensearch;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+
+import java.io.IOException;
+
+/**
+ * Base exception for a failed node
+*
+* @opensearch.internal
+*/
+public class ProtobufOpenSearchException extends RuntimeException implements ProtobufWriteable {
+
+    private String message;
+
+    public ProtobufOpenSearchException(String message) {
+        super(message);
+        this.message = message;
+    }
+
+    public ProtobufOpenSearchException(CodedInputStream in) throws IOException {
+        super(in.readString());
+        this.message = in.readString();
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeStringNoTag(this.getMessage());
+    }
+
+    public String getMessage() {
+        return this.message;
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionRequest.java b/server/src/main/java/org/opensearch/action/ProtobufActionRequest.java
new file mode 100644
index 0000000000000..013ac5cacb776
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionRequest.java
@@ -0,0 +1,53 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.action;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.transport.ProtobufTransportRequest;
+
+import java.io.IOException;
+
+/**
+ * Base action request implemented by plugins.
+*
+* @opensearch.api
+*/
+public abstract class ProtobufActionRequest extends ProtobufTransportRequest {
+
+    public ProtobufActionRequest() {
+        super();
+        // this does not set the listenerThreaded API, if needed, its up to the caller to set it
+        // since most times, we actually want it to not be threaded...
+        // this.listenerThreaded = request.listenerThreaded();
+    }
+
+    public ProtobufActionRequest(CodedInputStream in) throws IOException {
+        super(in);
+    }
+
+    public abstract ActionRequestValidationException validate();
+
+    /**
+     * Should this task store its result after it has finished?
+    */
+    public boolean getShouldStoreResult() {
+        return false;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        super.writeTo(out);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionRequestBuilder.java b/server/src/main/java/org/opensearch/action/ProtobufActionRequestBuilder.java
new file mode 100644
index 0000000000000..33c0e46f5fc92
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionRequestBuilder.java
@@ -0,0 +1,67 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action;
+
+import org.opensearch.client.OpenSearchClient;
+import org.opensearch.client.ProtobufOpenSearchClient;
+import org.opensearch.common.unit.TimeValue;
+
+import java.util.Objects;
+
+/**
+ * Base Action Request Builder
+*
+* @opensearch.api
+*/
+public abstract class ProtobufActionRequestBuilder<Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> {
+
+    protected final ProtobufActionType<Response> action;
+    protected final Request request;
+    protected final ProtobufOpenSearchClient client;
+
+    protected ProtobufActionRequestBuilder(ProtobufOpenSearchClient client, ProtobufActionType<Response> action, Request request) {
+        Objects.requireNonNull(action, "action must not be null");
+        this.action = action;
+        this.request = request;
+        this.client = client;
+    }
+
+    public Request request() {
+        return this.request;
+    }
+
+    public ActionFuture<Response> execute() {
+        return client.execute(action, request);
+    }
+
+    /**
+     * Short version of execute().actionGet().
+    */
+    public Response get() {
+        return execute().actionGet();
+    }
+
+    /**
+     * Short version of execute().actionGet().
+    */
+    public Response get(TimeValue timeout) {
+        return execute().actionGet(timeout);
+    }
+
+    /**
+     * Short version of execute().actionGet().
+    */
+    public Response get(String timeout) {
+        return execute().actionGet(timeout);
+    }
+
+    public void execute(ActionListener<Response> listener) {
+        client.execute(action, request, listener);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java b/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java
new file mode 100644
index 0000000000000..f6cf420cb86fd
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java
@@ -0,0 +1,33 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.action;
+
+import com.google.protobuf.CodedInputStream;
+import org.opensearch.transport.ProtobufTransportResponse;
+
+import java.io.IOException;
+
+/**
+ * Base class for responses to action requests implemented by plugins.
+*
+* @opensearch.api
+*/
+public abstract class ProtobufActionResponse extends ProtobufTransportResponse {
+
+    public ProtobufActionResponse() {}
+
+    public ProtobufActionResponse(CodedInputStream in) throws IOException {
+        super(in);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionType.java b/server/src/main/java/org/opensearch/action/ProtobufActionType.java
new file mode 100644
index 0000000000000..911419fb67677
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionType.java
@@ -0,0 +1,65 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action;
+
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.io.stream.Writeable;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.transport.TransportRequestOptions;
+
+/**
+ * A generic action. Should strive to make it a singleton.
+*
+* @opensearch.api
+*/
+public class ProtobufActionType<Response extends ProtobufActionResponse> {
+
+    private final String name;
+    private final ProtobufWriteable.Reader<Response> responseReader;
+
+    /**
+     * @param name The name of the action, must be unique across actions.
+    * @param responseReader A reader for the response type
+    */
+    public ProtobufActionType(String name, ProtobufWriteable.Reader<Response> responseReader) {
+        this.name = name;
+        this.responseReader = responseReader;
+    }
+
+    /**
+     * The name of the action. Must be unique across actions.
+    */
+    public String name() {
+        return this.name;
+    }
+
+    /**
+     * Get a reader that can create a new instance of the class from a {@link org.opensearch.common.io.stream.StreamInput}
+    */
+    public ProtobufWriteable.Reader<Response> getResponseReader() {
+        return responseReader;
+    }
+
+    /**
+     * Optional request options for the action.
+    */
+    public TransportRequestOptions transportOptions(Settings settings) {
+        return TransportRequestOptions.EMPTY;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        return o instanceof ProtobufActionType && name.equals(((ProtobufActionType<?>) o).name());
+    }
+
+    @Override
+    public int hashCode() {
+        return name.hashCode();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/ProtobufFailedNodeException.java b/server/src/main/java/org/opensearch/action/ProtobufFailedNodeException.java
new file mode 100644
index 0000000000000..511d933391c00
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/ProtobufFailedNodeException.java
@@ -0,0 +1,46 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.ProtobufOpenSearchException;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+
+import java.io.IOException;
+
+/**
+ * Base exception for a failed node
+*
+* @opensearch.internal
+*/
+public class ProtobufFailedNodeException extends ProtobufOpenSearchException implements ProtobufWriteable {
+
+    private final String nodeId;
+
+    public ProtobufFailedNodeException(String nodeId, String msg, Throwable cause) {
+        super(msg);
+        this.nodeId = nodeId;
+    }
+
+    public String nodeId() {
+        return this.nodeId;
+    }
+
+    public ProtobufFailedNodeException(CodedInputStream in) throws IOException {
+        super(in);
+        nodeId = in.readString();
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        super.writeTo(out);
+        out.writeStringNoTag(nodeId);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
new file mode 100644
index 0000000000000..0d1b03ae29d07
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
@@ -0,0 +1,335 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.action.admin.cluster.node.info;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.Build;
+import org.opensearch.Version;
+import org.opensearch.action.support.nodes.ProtobufBaseNodeResponse;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.http.ProtobufHttpInfo;
+import org.opensearch.ingest.ProtobufIngestInfo;
+import org.opensearch.monitor.jvm.JvmInfo;
+import org.opensearch.monitor.jvm.ProtobufJvmInfo;
+import org.opensearch.monitor.os.OsInfo;
+import org.opensearch.monitor.os.ProtobufOsInfo;
+import org.opensearch.monitor.process.ProtobufProcessInfo;
+import org.opensearch.node.ProtobufReportingService;
+import org.opensearch.search.aggregations.support.ProtobufAggregationInfo;
+import org.opensearch.search.pipeline.ProtobufSearchPipelineInfo;
+import org.opensearch.threadpool.ProtobufThreadPoolInfo;
+import org.opensearch.transport.ProtobufTransportInfo;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Node information (static, does not change over time).
+*
+* @opensearch.internal
+*/
+public class ProtobufNodeInfo extends ProtobufBaseNodeResponse {
+
+    private Version version;
+    private Build build;
+
+    @Nullable
+    private Settings settings;
+
+    /**
+     * Do not expose this map to other classes. For type safety, use {@link #getInfo(Class)}
+    * to retrieve items from this map and {@link #addInfoIfNonNull(Class, ProtobufReportingService.ProtobufInfo)}
+    * to retrieve items from it.
+    */
+    private Map<Class<? extends ProtobufReportingService.ProtobufInfo>, ProtobufReportingService.ProtobufInfo> infoMap = new HashMap<>();
+
+    @Nullable
+    private ByteSizeValue totalIndexingBuffer;
+
+    public ProtobufNodeInfo(CodedInputStream in) throws IOException {
+        super(in);
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        version = Version.readVersionProtobuf(in);
+        build = Build.readBuildProtobuf(in);
+        if (in.readBool()) {
+            totalIndexingBuffer = new ByteSizeValue(in.readInt64());
+        } else {
+            totalIndexingBuffer = null;
+        }
+        if (in.readBool()) {
+            settings = Settings.readSettingsFromStreamProtobuf(in);
+        }
+        addInfoIfNonNull(ProtobufOsInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufOsInfo::new, in));
+        addInfoIfNonNull(ProtobufProcessInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufProcessInfo::new, in));
+        addInfoIfNonNull(ProtobufJvmInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufJvmInfo::new, in));
+        addInfoIfNonNull(ProtobufThreadPoolInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufThreadPoolInfo::new, in));
+        addInfoIfNonNull(ProtobufTransportInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufTransportInfo::new, in));
+        addInfoIfNonNull(ProtobufHttpInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufHttpInfo::new, in));
+        addInfoIfNonNull(ProtobufPluginsAndModules.class, protobufStreamInput.readOptionalWriteable(ProtobufPluginsAndModules::new, in));
+        addInfoIfNonNull(ProtobufIngestInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufIngestInfo::new, in));
+        addInfoIfNonNull(ProtobufAggregationInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufAggregationInfo::new, in));
+        if (protobufStreamInput.getVersion().onOrAfter(Version.V_2_7_0)) {
+            addInfoIfNonNull(
+                ProtobufSearchPipelineInfo.class,
+                protobufStreamInput.readOptionalWriteable(ProtobufSearchPipelineInfo::new, in)
+            );
+        }
+    }
+
+    public ProtobufNodeInfo(
+        Version version,
+        Build build,
+        ProtobufDiscoveryNode node,
+        @Nullable Settings settings,
+        @Nullable ProtobufOsInfo os,
+        @Nullable ProtobufProcessInfo process,
+        @Nullable ProtobufJvmInfo jvm,
+        @Nullable ProtobufThreadPoolInfo threadPool,
+        @Nullable ProtobufTransportInfo transport,
+        @Nullable ProtobufHttpInfo http,
+        @Nullable ProtobufPluginsAndModules plugins,
+        @Nullable ProtobufIngestInfo ingest,
+        @Nullable ProtobufAggregationInfo aggsInfo,
+        @Nullable ByteSizeValue totalIndexingBuffer,
+        @Nullable ProtobufSearchPipelineInfo ProtobufSearchPipelineInfo
+    ) {
+        super(node);
+        this.version = version;
+        this.build = build;
+        this.settings = settings;
+        addInfoIfNonNull(ProtobufOsInfo.class, os);
+        addInfoIfNonNull(ProtobufProcessInfo.class, process);
+        addInfoIfNonNull(ProtobufJvmInfo.class, jvm);
+        addInfoIfNonNull(ProtobufThreadPoolInfo.class, threadPool);
+        addInfoIfNonNull(ProtobufTransportInfo.class, transport);
+        addInfoIfNonNull(ProtobufHttpInfo.class, http);
+        addInfoIfNonNull(ProtobufPluginsAndModules.class, plugins);
+        addInfoIfNonNull(ProtobufIngestInfo.class, ingest);
+        addInfoIfNonNull(ProtobufAggregationInfo.class, aggsInfo);
+        addInfoIfNonNull(ProtobufSearchPipelineInfo.class, ProtobufSearchPipelineInfo);
+        this.totalIndexingBuffer = totalIndexingBuffer;
+    }
+
+    /**
+     * System's hostname. <code>null</code> in case of UnknownHostException
+    */
+    @Nullable
+    public String getHostname() {
+        return getNode().getHostName();
+    }
+
+    /**
+     * The current OpenSearch version
+    */
+    public Version getVersion() {
+        return version;
+    }
+
+    /**
+     * The build version of the node.
+    */
+    public Build getBuild() {
+        return this.build;
+    }
+
+    /**
+     * The settings of the node.
+    */
+    @Nullable
+    public Settings getSettings() {
+        return this.settings;
+    }
+
+    /**
+     * Get a particular info object, e.g. {@link JvmInfo} or {@link OsInfo}. This
+    * generic method handles all casting in order to spare client classes the
+    * work of explicit casts. This {@link NodeInfo} class guarantees type
+    * safety for these stored info blocks.
+    *
+    * @param clazz Class for retrieval.
+    * @param <T>   Specific subtype of ReportingService.ProtobufInfo to retrieve.
+    * @return      An object of type T.
+    */
+    public <T extends ProtobufReportingService.ProtobufInfo> T getInfo(Class<T> clazz) {
+        return clazz.cast(infoMap.get(clazz));
+    }
+
+    @Nullable
+    public ByteSizeValue getTotalIndexingBuffer() {
+        return totalIndexingBuffer;
+    }
+
+    /**
+     * Add a value to the map of information blocks. This method guarantees the
+    * type safety of the storage of heterogeneous types of reporting service information.
+    */
+    private <T extends ProtobufReportingService.ProtobufInfo> void addInfoIfNonNull(Class<T> clazz, T info) {
+        if (info != null) {
+            infoMap.put(clazz, info);
+        }
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        super.writeTo(out);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        out.writeInt32NoTag(version.id);
+        Build.writeBuildProtobuf(build, out);
+        if (totalIndexingBuffer == null) {
+            out.writeBoolNoTag(false);
+        } else {
+            out.writeBoolNoTag(true);
+            out.writeInt64NoTag(totalIndexingBuffer.getBytes());
+        }
+        if (settings == null) {
+            out.writeBoolNoTag(false);
+        } else {
+            out.writeBoolNoTag(true);
+            Settings.writeSettingsToStreamProtobuf(settings, out);
+        }
+        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufOsInfo.class), out);
+        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufProcessInfo.class), out);
+        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufJvmInfo.class), out);
+        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufThreadPoolInfo.class), out);
+        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufTransportInfo.class), out);
+        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufHttpInfo.class), out);
+        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufPluginsAndModules.class), out);
+        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufIngestInfo.class), out);
+        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufAggregationInfo.class), out);
+        if (protobufStreamOutput.getVersion().onOrAfter(Version.V_2_7_0)) {
+            protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufSearchPipelineInfo.class), out);
+        }
+    }
+
+    public static ProtobufNodeInfo.Builder builder(Version version, Build build, ProtobufDiscoveryNode node) {
+        return new Builder(version, build, node);
+    }
+
+    /**
+     * Builder class to accommodate new Info types being added to NodeInfo.
+    */
+    public static class Builder {
+        private final Version version;
+        private final Build build;
+        private final ProtobufDiscoveryNode node;
+
+        private Builder(Version version, Build build, ProtobufDiscoveryNode node) {
+            this.version = version;
+            this.build = build;
+            this.node = node;
+        }
+
+        private Settings settings;
+        private ProtobufOsInfo os;
+        private ProtobufProcessInfo process;
+        private ProtobufJvmInfo jvm;
+        private ProtobufThreadPoolInfo threadPool;
+        private ProtobufTransportInfo transport;
+        private ProtobufHttpInfo http;
+        private ProtobufPluginsAndModules plugins;
+        private ProtobufIngestInfo ingest;
+        private ProtobufAggregationInfo aggsInfo;
+        private ByteSizeValue totalIndexingBuffer;
+        private ProtobufSearchPipelineInfo ProtobufSearchPipelineInfo;
+
+        public Builder setSettings(Settings settings) {
+            this.settings = settings;
+            return this;
+        }
+
+        public Builder setOs(ProtobufOsInfo os) {
+            this.os = os;
+            return this;
+        }
+
+        public Builder setProcess(ProtobufProcessInfo process) {
+            this.process = process;
+            return this;
+        }
+
+        public Builder setJvm(ProtobufJvmInfo jvm) {
+            this.jvm = jvm;
+            return this;
+        }
+
+        public Builder setThreadPool(ProtobufThreadPoolInfo threadPool) {
+            this.threadPool = threadPool;
+            return this;
+        }
+
+        public Builder setTransport(ProtobufTransportInfo transport) {
+            this.transport = transport;
+            return this;
+        }
+
+        public Builder setHttp(ProtobufHttpInfo http) {
+            this.http = http;
+            return this;
+        }
+
+        public Builder setPlugins(ProtobufPluginsAndModules plugins) {
+            this.plugins = plugins;
+            return this;
+        }
+
+        public Builder setIngest(ProtobufIngestInfo ingest) {
+            this.ingest = ingest;
+            return this;
+        }
+
+        public Builder setAggsInfo(ProtobufAggregationInfo aggsInfo) {
+            this.aggsInfo = aggsInfo;
+            return this;
+        }
+
+        public Builder setTotalIndexingBuffer(ByteSizeValue totalIndexingBuffer) {
+            this.totalIndexingBuffer = totalIndexingBuffer;
+            return this;
+        }
+
+        public Builder setProtobufSearchPipelineInfo(ProtobufSearchPipelineInfo ProtobufSearchPipelineInfo) {
+            this.ProtobufSearchPipelineInfo = ProtobufSearchPipelineInfo;
+            return this;
+        }
+
+        public ProtobufNodeInfo build() {
+            return new ProtobufNodeInfo(
+                version,
+                build,
+                node,
+                settings,
+                os,
+                process,
+                jvm,
+                threadPool,
+                transport,
+                http,
+                plugins,
+                ingest,
+                aggsInfo,
+                totalIndexingBuffer,
+                ProtobufSearchPipelineInfo
+            );
+        }
+
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
new file mode 100644
index 0000000000000..04de76bb281fe
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
@@ -0,0 +1,165 @@
+/*
+ * 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.
+ */
+
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.action.admin.cluster.node.info;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.action.support.nodes.ProtobufBaseNodesRequest;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.StreamInput;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.stream.Collectors;
+
+/**
+ * A request to get node (cluster) level information.
+ *
+ * @opensearch.internal
+ */
+public class ProtobufNodesInfoRequest extends ProtobufBaseNodesRequest<ProtobufNodesInfoRequest> {
+
+    private Set<String> requestedMetrics = Metric.allMetrics();
+
+    /**
+     * Create a new NodeInfoRequest from a {@link StreamInput} object.
+     *
+     * @param in A stream input object.
+     * @throws IOException if the stream cannot be deserialized.
+     */
+    public ProtobufNodesInfoRequest(CodedInputStream in) throws IOException {
+        super(in);
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        requestedMetrics.clear();
+        requestedMetrics.addAll(Arrays.asList(protobufStreamInput.readStringArray(in)));
+    }
+
+    /**
+     * Get information from nodes based on the nodes ids specified. If none are passed, information
+     * for all nodes will be returned.
+     */
+    public ProtobufNodesInfoRequest(String... nodesIds) {
+        super(nodesIds);
+        all();
+    }
+
+    /**
+     * Clears all info flags.
+     */
+    public ProtobufNodesInfoRequest clear() {
+        requestedMetrics.clear();
+        return this;
+    }
+
+    /**
+     * Sets to return all the data.
+     */
+    public ProtobufNodesInfoRequest all() {
+        requestedMetrics.addAll(Metric.allMetrics());
+        return this;
+    }
+
+    /**
+     * Get the names of requested metrics
+     */
+    public Set<String> requestedMetrics() {
+        return new HashSet<>(requestedMetrics);
+    }
+
+    /**
+     * Add metric
+     */
+    public ProtobufNodesInfoRequest addMetric(String metric) {
+        if (Metric.allMetrics().contains(metric) == false) {
+            throw new IllegalStateException("Used an illegal metric: " + metric);
+        }
+        requestedMetrics.add(metric);
+        return this;
+    }
+
+    /**
+     * Add multiple metrics
+     */
+    public ProtobufNodesInfoRequest addMetrics(String... metrics) {
+        SortedSet<String> metricsSet = new TreeSet<>(Arrays.asList(metrics));
+        if (Metric.allMetrics().containsAll(metricsSet) == false) {
+            metricsSet.removeAll(Metric.allMetrics());
+            String plural = metricsSet.size() == 1 ? "" : "s";
+            throw new IllegalStateException("Used illegal metric" + plural + ": " + metricsSet);
+        }
+        requestedMetrics.addAll(metricsSet);
+        return this;
+    }
+
+    /**
+     * Remove metric
+     */
+    public ProtobufNodesInfoRequest removeMetric(String metric) {
+        if (Metric.allMetrics().contains(metric) == false) {
+            throw new IllegalStateException("Used an illegal metric: " + metric);
+        }
+        requestedMetrics.remove(metric);
+        return this;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        super.writeTo(out);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        protobufStreamOutput.writeStringArray(requestedMetrics.toArray(new String[0]), out);
+    }
+
+    /**
+     * An enumeration of the "core" sections of metrics that may be requested
+     * from the nodes information endpoint. Eventually this list list will be
+     * pluggable.
+     */
+    public enum Metric {
+        SETTINGS("settings"),
+        OS("os"),
+        PROCESS("process"),
+        JVM("jvm"),
+        THREAD_POOL("thread_pool"),
+        TRANSPORT("transport"),
+        HTTP("http"),
+        PLUGINS("plugins"),
+        INGEST("ingest"),
+        AGGREGATIONS("aggregations"),
+        INDICES("indices"),
+        SEARCH_PIPELINES("search_pipelines");
+
+        private String metricName;
+
+        Metric(String name) {
+            this.metricName = name;
+        }
+
+        public String metricName() {
+            return this.metricName;
+        }
+
+        boolean containedIn(Set<String> metricNames) {
+            return metricNames.contains(this.metricName());
+        }
+
+        public static Set<String> allMetrics() {
+            return Arrays.stream(values()).map(Metric::metricName).collect(Collectors.toSet());
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
new file mode 100644
index 0000000000000..a7d5274fcf09a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
@@ -0,0 +1,76 @@
+/*
+* 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.action.admin.cluster.node.info;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.action.ProtobufFailedNodeException;
+import org.opensearch.action.support.nodes.ProtobufBaseNodesResponse;
+import org.opensearch.cluster.ProtobufClusterName;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * Transport response for OpenSearch Node Information
+*
+* @opensearch.internal
+*/
+public class ProtobufNodesInfoResponse extends ProtobufBaseNodesResponse<ProtobufNodeInfo> {
+
+    public ProtobufNodesInfoResponse(CodedInputStream in) throws IOException {
+        super(in);
+    }
+
+    public ProtobufNodesInfoResponse(
+        ProtobufClusterName clusterName,
+        List<ProtobufNodeInfo> nodes,
+        List<ProtobufFailedNodeException> failures
+    ) {
+        super(clusterName, nodes, failures);
+    }
+
+    @Override
+    protected List<ProtobufNodeInfo> readNodesFrom(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        return protobufStreamInput.readList(ProtobufNodeInfo::new, in);
+    }
+
+    @Override
+    protected void writeNodesTo(CodedOutputStream out, List<ProtobufNodeInfo> nodes) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        protobufStreamOutput.writeCollection(nodes, (o, v) -> v.writeTo(o), out);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufPluginsAndModules.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufPluginsAndModules.java
new file mode 100644
index 0000000000000..1df8383a78736
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufPluginsAndModules.java
@@ -0,0 +1,77 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.admin.cluster.node.info;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.node.ProtobufReportingService;
+import org.opensearch.plugins.ProtobufPluginInfo;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * Information about plugins and modules
+*
+* @opensearch.internal
+*/
+public class ProtobufPluginsAndModules implements ProtobufReportingService.ProtobufInfo {
+    private final List<ProtobufPluginInfo> plugins;
+    private final List<ProtobufPluginInfo> modules;
+
+    public ProtobufPluginsAndModules(List<ProtobufPluginInfo> plugins, List<ProtobufPluginInfo> modules) {
+        this.plugins = Collections.unmodifiableList(plugins);
+        this.modules = Collections.unmodifiableList(modules);
+    }
+
+    public ProtobufPluginsAndModules(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        this.plugins = Collections.unmodifiableList(protobufStreamInput.readList(ProtobufPluginInfo::new, in));
+        this.modules = Collections.unmodifiableList(protobufStreamInput.readList(ProtobufPluginInfo::new, in));
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        protobufStreamOutput.writeCollection(plugins, (o, v) -> v.writeTo(o), out);
+        protobufStreamOutput.writeCollection(modules, (o, v) -> v.writeTo(o), out);
+    }
+
+    /**
+     * Returns an ordered list based on plugins name
+    */
+    public List<ProtobufPluginInfo> getPluginInfos() {
+        List<ProtobufPluginInfo> plugins = new ArrayList<>(this.plugins);
+        Collections.sort(plugins, Comparator.comparing(ProtobufPluginInfo::getName));
+        return plugins;
+    }
+
+    /**
+     * Returns an ordered list based on modules name
+    */
+    public List<ProtobufPluginInfo> getModuleInfos() {
+        List<ProtobufPluginInfo> modules = new ArrayList<>(this.modules);
+        Collections.sort(modules, Comparator.comparing(ProtobufPluginInfo::getName));
+        return modules;
+    }
+
+    public void addPlugin(ProtobufPluginInfo info) {
+        plugins.add(info);
+    }
+
+    public void addModule(ProtobufPluginInfo info) {
+        modules.add(info);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
new file mode 100644
index 0000000000000..d55b511eb0170
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
@@ -0,0 +1,202 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.admin.cluster.node.stats;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
+import org.opensearch.action.admin.indices.stats.ProtobufCommonStatsFlags;
+import org.opensearch.action.support.nodes.BaseNodesRequest;
+import org.opensearch.action.support.nodes.ProtobufBaseNodesRequest;
+import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.StreamOutput;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.stream.Collectors;
+
+/**
+ * A request to get node (cluster) level stats.
+*
+* @opensearch.internal
+*/
+public class ProtobufNodesStatsRequest extends ProtobufBaseNodesRequest<ProtobufNodesStatsRequest> {
+
+    private ProtobufCommonStatsFlags indices = new ProtobufCommonStatsFlags();
+    private final Set<String> requestedMetrics = new HashSet<>();
+
+    public ProtobufNodesStatsRequest() {
+        super((String[]) null);
+    }
+
+    public ProtobufNodesStatsRequest(CodedInputStream in) throws IOException {
+        super(in);
+
+        indices = new ProtobufCommonStatsFlags(in);
+        requestedMetrics.clear();
+        requestedMetrics.addAll(in.readStringList());
+    }
+
+    /**
+     * Get stats from nodes based on the nodes ids specified. If none are passed, stats
+    * for all nodes will be returned.
+    */
+    public ProtobufNodesStatsRequest(String... nodesIds) {
+        super(nodesIds);
+    }
+
+    /**
+     * Sets all the request flags.
+    */
+    public ProtobufNodesStatsRequest all() {
+        this.indices.all();
+        this.requestedMetrics.addAll(Metric.allMetrics());
+        return this;
+    }
+
+    /**
+     * Clears all the request flags.
+    */
+    public ProtobufNodesStatsRequest clear() {
+        this.indices.clear();
+        this.requestedMetrics.clear();
+        return this;
+    }
+
+    /**
+     * Get indices. Handles separately from other metrics because it may or
+    * may not have submetrics.
+    * @return flags indicating which indices stats to return
+    */
+    public ProtobufCommonStatsFlags indices() {
+        return indices;
+    }
+
+    /**
+     * Set indices. Handles separately from other metrics because it may or
+    * may not involve submetrics.
+    * @param indices flags indicating which indices stats to return
+    * @return This object, for request chaining.
+    */
+    public ProtobufNodesStatsRequest indices(ProtobufCommonStatsFlags indices) {
+        this.indices = indices;
+        return this;
+    }
+
+    /**
+     * Should indices stats be returned.
+    */
+    public ProtobufNodesStatsRequest indices(boolean indices) {
+        if (indices) {
+            this.indices.all();
+        } else {
+            this.indices.clear();
+        }
+        return this;
+    }
+
+    /**
+     * Get the names of requested metrics, excluding indices, which are
+    * handled separately.
+    */
+    public Set<String> requestedMetrics() {
+        return new HashSet<>(requestedMetrics);
+    }
+
+    /**
+     * Add metric
+    */
+    public ProtobufNodesStatsRequest addMetric(String metric) {
+        if (Metric.allMetrics().contains(metric) == false) {
+            throw new IllegalStateException("Used an illegal metric: " + metric);
+        }
+        requestedMetrics.add(metric);
+        return this;
+    }
+
+    /**
+     * Add an array of metric names
+    */
+    public ProtobufNodesStatsRequest addMetrics(String... metrics) {
+        // use sorted set for reliable ordering in error messages
+        SortedSet<String> metricsSet = new TreeSet<>(Arrays.asList(metrics));
+        if (Metric.allMetrics().containsAll(metricsSet) == false) {
+            metricsSet.removeAll(Metric.allMetrics());
+            String plural = metricsSet.size() == 1 ? "" : "s";
+            throw new IllegalStateException("Used illegal metric" + plural + ": " + metricsSet);
+        }
+        requestedMetrics.addAll(metricsSet);
+        return this;
+    }
+
+    /**
+     * Remove metric
+    */
+    public ProtobufNodesStatsRequest removeMetric(String metric) {
+        if (Metric.allMetrics().contains(metric) == false) {
+            throw new IllegalStateException("Used an illegal metric: " + metric);
+        }
+        requestedMetrics.remove(metric);
+        return this;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        super.writeTo(out);
+        indices.writeTo(out);
+        out.writeStringArray(requestedMetrics.toArray(new String[0]));
+    }
+
+    /**
+     * An enumeration of the "core" sections of metrics that may be requested
+    * from the nodes stats endpoint. Eventually this list will be pluggable.
+    */
+    public enum Metric {
+        OS("os"),
+        PROCESS("process"),
+        JVM("jvm"),
+        THREAD_POOL("thread_pool"),
+        FS("fs"),
+        TRANSPORT("transport"),
+        HTTP("http"),
+        BREAKER("breaker"),
+        SCRIPT("script"),
+        DISCOVERY("discovery"),
+        INGEST("ingest"),
+        ADAPTIVE_SELECTION("adaptive_selection"),
+        SCRIPT_CACHE("script_cache"),
+        INDEXING_PRESSURE("indexing_pressure"),
+        SHARD_INDEXING_PRESSURE("shard_indexing_pressure"),
+        SEARCH_BACKPRESSURE("search_backpressure"),
+        CLUSTER_MANAGER_THROTTLING("cluster_manager_throttling"),
+        WEIGHTED_ROUTING_STATS("weighted_routing"),
+        FILE_CACHE_STATS("file_cache");
+
+        private String metricName;
+
+        Metric(String name) {
+            this.metricName = name;
+        }
+
+        public String metricName() {
+            return this.metricName;
+        }
+
+        boolean containedIn(Set<String> metricNames) {
+            return metricNames.contains(this.metricName());
+        }
+
+        static Set<String> allMetrics() {
+            return Arrays.stream(values()).map(Metric::metricName).collect(Collectors.toSet());
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateAction.java
new file mode 100644
index 0000000000000..5ab9aa023a298
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateAction.java
@@ -0,0 +1,27 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.admin.cluster.state;
+
+import org.opensearch.action.ActionType;
+import org.opensearch.action.ProtobufActionType;
+
+/**
+ * Transport action for obtaining cluster state
+*
+* @opensearch.internal
+*/
+public class ProtobufClusterStateAction extends ProtobufActionType<ProtobufClusterStateResponse> {
+
+    public static final ProtobufClusterStateAction INSTANCE = new ProtobufClusterStateAction();
+    public static final String NAME = "cluster:monitor/state";
+
+    private ProtobufClusterStateAction() {
+        super(NAME, ProtobufClusterStateResponse::new);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
new file mode 100644
index 0000000000000..6798c3b8c46e5
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
@@ -0,0 +1,199 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.action.admin.cluster.state;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.action.IndicesRequest;
+import org.opensearch.action.support.IndicesOptions;
+import org.opensearch.action.support.clustermanager.ProtobufClusterManagerNodeReadRequest;
+import org.opensearch.common.Strings;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.unit.TimeValue;
+
+import java.io.IOException;
+
+/**
+ * Transport request for obtaining cluster state
+*
+* @opensearch.internal
+*/
+public class ProtobufClusterStateRequest extends ProtobufClusterManagerNodeReadRequest<ProtobufClusterStateRequest>
+    implements
+        IndicesRequest.Replaceable {
+
+    public static final TimeValue DEFAULT_WAIT_FOR_NODE_TIMEOUT = TimeValue.timeValueMinutes(1);
+
+    private boolean routingTable = true;
+    private boolean nodes = true;
+    private boolean metadata = true;
+    private boolean blocks = true;
+    private boolean customs = true;
+    private Long waitForMetadataVersion;
+    private TimeValue waitForTimeout = DEFAULT_WAIT_FOR_NODE_TIMEOUT;
+    private String[] indices = Strings.EMPTY_ARRAY;
+    private IndicesOptions indicesOptions = IndicesOptions.lenientExpandOpen();
+
+    public ProtobufClusterStateRequest() {}
+
+    public ProtobufClusterStateRequest(CodedInputStream in) throws IOException {
+        super(in);
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        routingTable = in.readBool();
+        nodes = in.readBool();
+        metadata = in.readBool();
+        blocks = in.readBool();
+        customs = in.readBool();
+        indices = protobufStreamInput.readStringArray(in);
+        indicesOptions = IndicesOptions.readIndicesOptionsProtobuf(in);
+        waitForTimeout = protobufStreamInput.readTimeValue(in);
+        waitForMetadataVersion = protobufStreamInput.readOptionalLong(in);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        super.writeTo(out);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        out.writeBoolNoTag(routingTable);
+        out.writeBoolNoTag(nodes);
+        out.writeBoolNoTag(metadata);
+        out.writeBoolNoTag(blocks);
+        out.writeBoolNoTag(customs);
+        protobufStreamOutput.writeStringArray(indices, out);
+        indicesOptions.writeIndicesOptionsProtobuf(out);
+        protobufStreamOutput.writeTimeValue(waitForTimeout, out);
+        protobufStreamOutput.writeOptionalLong(waitForMetadataVersion, out);
+    }
+
+    @Override
+    public ActionRequestValidationException validate() {
+        return null;
+    }
+
+    public ProtobufClusterStateRequest all() {
+        routingTable = true;
+        nodes = true;
+        metadata = true;
+        blocks = true;
+        customs = true;
+        indices = Strings.EMPTY_ARRAY;
+        return this;
+    }
+
+    public ProtobufClusterStateRequest clear() {
+        routingTable = false;
+        nodes = false;
+        metadata = false;
+        blocks = false;
+        customs = false;
+        indices = Strings.EMPTY_ARRAY;
+        return this;
+    }
+
+    public boolean routingTable() {
+        return routingTable;
+    }
+
+    public ProtobufClusterStateRequest routingTable(boolean routingTable) {
+        this.routingTable = routingTable;
+        return this;
+    }
+
+    public boolean nodes() {
+        return nodes;
+    }
+
+    public ProtobufClusterStateRequest nodes(boolean nodes) {
+        this.nodes = nodes;
+        return this;
+    }
+
+    public boolean metadata() {
+        return metadata;
+    }
+
+    public ProtobufClusterStateRequest metadata(boolean metadata) {
+        this.metadata = metadata;
+        return this;
+    }
+
+    public boolean blocks() {
+        return blocks;
+    }
+
+    public ProtobufClusterStateRequest blocks(boolean blocks) {
+        this.blocks = blocks;
+        return this;
+    }
+
+    @Override
+    public String[] indices() {
+        return indices;
+    }
+
+    @Override
+    public ProtobufClusterStateRequest indices(String... indices) {
+        this.indices = indices;
+        return this;
+    }
+
+    @Override
+    public IndicesOptions indicesOptions() {
+        return this.indicesOptions;
+    }
+
+    public final ProtobufClusterStateRequest indicesOptions(IndicesOptions indicesOptions) {
+        this.indicesOptions = indicesOptions;
+        return this;
+    }
+
+    @Override
+    public boolean includeDataStreams() {
+        return true;
+    }
+
+    public ProtobufClusterStateRequest customs(boolean customs) {
+        this.customs = customs;
+        return this;
+    }
+
+    public boolean customs() {
+        return customs;
+    }
+
+    public TimeValue waitForTimeout() {
+        return waitForTimeout;
+    }
+
+    public ProtobufClusterStateRequest waitForTimeout(TimeValue waitForTimeout) {
+        this.waitForTimeout = waitForTimeout;
+        return this;
+    }
+
+    public Long waitForMetadataVersion() {
+        return waitForMetadataVersion;
+    }
+
+    public ProtobufClusterStateRequest waitForMetadataVersion(long waitForMetadataVersion) {
+        if (waitForMetadataVersion < 1) {
+            throw new IllegalArgumentException(
+                "provided waitForMetadataVersion should be >= 1, but instead is [" + waitForMetadataVersion + "]"
+            );
+        }
+        this.waitForMetadataVersion = waitForMetadataVersion;
+        return this;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequestBuilder.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequestBuilder.java
new file mode 100644
index 0000000000000..6255d47b9bd66
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequestBuilder.java
@@ -0,0 +1,119 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.admin.cluster.state;
+
+import org.opensearch.action.support.IndicesOptions;
+import org.opensearch.action.support.clustermanager.ClusterManagerNodeReadOperationRequestBuilder;
+import org.opensearch.action.support.clustermanager.ProtobufClusterManagerNodeReadOperationRequestBuilder;
+import org.opensearch.client.OpenSearchClient;
+import org.opensearch.client.ProtobufOpenSearchClient;
+import org.opensearch.common.unit.TimeValue;
+
+/**
+ * Transport request builder for obtaining cluster state
+*
+* @opensearch.internal
+*/
+public class ProtobufClusterStateRequestBuilder extends ProtobufClusterManagerNodeReadOperationRequestBuilder<
+    ProtobufClusterStateRequest,
+    ProtobufClusterStateResponse,
+    ProtobufClusterStateRequestBuilder> {
+
+    public ProtobufClusterStateRequestBuilder(ProtobufOpenSearchClient client, ProtobufClusterStateAction action) {
+        super(client, action, new ProtobufClusterStateRequest());
+    }
+
+    /**
+     * Include all data
+    */
+    public ProtobufClusterStateRequestBuilder all() {
+        request.all();
+        return this;
+    }
+
+    /**
+     * Do not include any data
+    */
+    public ProtobufClusterStateRequestBuilder clear() {
+        request.clear();
+        return this;
+    }
+
+    public ProtobufClusterStateRequestBuilder setBlocks(boolean filter) {
+        request.blocks(filter);
+        return this;
+    }
+
+    /**
+     * Should the cluster state result include the {@link org.opensearch.cluster.metadata.Metadata}. Defaults
+    * to {@code true}.
+    */
+    public ProtobufClusterStateRequestBuilder setMetadata(boolean filter) {
+        request.metadata(filter);
+        return this;
+    }
+
+    /**
+     * Should the cluster state result include the {@link org.opensearch.cluster.node.DiscoveryNodes}. Defaults
+    * to {@code true}.
+    */
+    public ProtobufClusterStateRequestBuilder setNodes(boolean filter) {
+        request.nodes(filter);
+        return this;
+    }
+
+    /**
+     * Should the cluster state result include the {@link org.opensearch.cluster.ClusterState.Custom}. Defaults
+    * to {@code true}.
+    */
+    public ProtobufClusterStateRequestBuilder setCustoms(boolean filter) {
+        request.customs(filter);
+        return this;
+    }
+
+    /**
+     * Should the cluster state result include the {@link org.opensearch.cluster.routing.RoutingTable}. Defaults
+    * to {@code true}.
+    */
+    public ProtobufClusterStateRequestBuilder setRoutingTable(boolean filter) {
+        request.routingTable(filter);
+        return this;
+    }
+
+    /**
+     * When {@link #setMetadata(boolean)} is set, which indices to return the {@link org.opensearch.cluster.metadata.IndexMetadata}
+    * for. Defaults to all indices.
+    */
+    public ProtobufClusterStateRequestBuilder setIndices(String... indices) {
+        request.indices(indices);
+        return this;
+    }
+
+    public ProtobufClusterStateRequestBuilder setIndicesOptions(IndicesOptions indicesOptions) {
+        request.indicesOptions(indicesOptions);
+        return this;
+    }
+
+    /**
+     * Causes the request to wait for the metadata version to advance to at least the given version.
+    * @param waitForMetadataVersion The metadata version for which to wait
+    */
+    public ProtobufClusterStateRequestBuilder setWaitForMetadataVersion(long waitForMetadataVersion) {
+        request.waitForMetadataVersion(waitForMetadataVersion);
+        return this;
+    }
+
+    /**
+     * If {@link ProtobufClusterStateRequest#waitForMetadataVersion()} is set then this determines how long to wait
+    */
+    public ProtobufClusterStateRequestBuilder setWaitForTimeOut(TimeValue waitForTimeout) {
+        request.waitForTimeout(waitForTimeout);
+        return this;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
new file mode 100644
index 0000000000000..a88e42d78c66a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
@@ -0,0 +1,85 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.action.admin.cluster.state;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.action.ProtobufActionResponse;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.ProtobufClusterName;
+import org.opensearch.cluster.ProtobufClusterState;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+
+import java.io.IOException;
+
+/**
+ * The response for getting the cluster state.
+*
+* @opensearch.internal
+*/
+public class ProtobufClusterStateResponse extends ProtobufActionResponse {
+
+    private ProtobufClusterName clusterName;
+    private ProtobufClusterState clusterState;
+    private boolean waitForTimedOut = false;
+
+    private final ProtobufStreamInput protobufStreamInput;
+
+    public ProtobufClusterStateResponse(CodedInputStream in) throws IOException {
+        super(in);
+        protobufStreamInput = new ProtobufStreamInput();
+        clusterName = new ProtobufClusterName(in);
+        clusterState = protobufStreamInput.readOptionalWriteable(innerIn -> ProtobufClusterState.readFrom(innerIn, null), in);
+        waitForTimedOut = in.readBool();
+    }
+
+    public ProtobufClusterStateResponse(ProtobufClusterName clusterName, ProtobufClusterState clusterState, boolean waitForTimedOut) {
+        this.clusterName = clusterName;
+        this.clusterState = clusterState;
+        this.waitForTimedOut = waitForTimedOut;
+        protobufStreamInput = new ProtobufStreamInput();
+    }
+
+    /**
+     * The requested cluster state.  Only the parts of the cluster state that were
+    * requested are included in the returned {@link ClusterState} instance.
+    */
+    public ProtobufClusterState getState() {
+        return this.clusterState;
+    }
+
+    /**
+     * The name of the cluster.
+    */
+    public ProtobufClusterName getClusterName() {
+        return this.clusterName;
+    }
+
+    /**
+     * Returns whether the request timed out waiting for a cluster state with a metadata version equal or
+    * higher than the specified metadata.
+    */
+    public boolean isWaitForTimedOut() {
+        return waitForTimedOut;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        clusterName.writeTo(out);
+        protobufStreamOutput.writeOptionalWriteable(clusterState, out);
+        out.writeBoolNoTag(waitForTimedOut);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStatsFlags.java b/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStatsFlags.java
new file mode 100644
index 0000000000000..82df111cceda4
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStatsFlags.java
@@ -0,0 +1,279 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.admin.indices.stats;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.Version;
+import org.opensearch.common.Strings;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.StreamOutput;
+import org.opensearch.common.io.stream.Writeable;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.EnumSet;
+
+/**
+ * Common Stats Flags for OpenSearch
+*
+* @opensearch.internal
+*/
+public class ProtobufCommonStatsFlags implements ProtobufWriteable, Cloneable {
+
+    public static final CommonStatsFlags ALL = new CommonStatsFlags().all();
+    public static final CommonStatsFlags NONE = new CommonStatsFlags().clear();
+
+    private EnumSet<Flag> flags = EnumSet.allOf(Flag.class);
+    private String[] groups = null;
+    private String[] fieldDataFields = null;
+    private String[] completionDataFields = null;
+    private boolean includeSegmentFileSizes = false;
+    private boolean includeUnloadedSegments = false;
+    private boolean includeAllShardIndexingPressureTrackers = false;
+    private boolean includeOnlyTopIndexingPressureMetrics = false;
+
+    /**
+     * @param flags flags to set. If no flags are supplied, default flags will be set.
+    */
+    public ProtobufCommonStatsFlags(Flag... flags) {
+        if (flags.length > 0) {
+            clear();
+            Collections.addAll(this.flags, flags);
+        }
+    }
+
+    public ProtobufCommonStatsFlags(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        final long longFlags = in.readLong();
+        flags.clear();
+        for (Flag flag : Flag.values()) {
+            if ((longFlags & (1 << flag.getIndex())) != 0) {
+                flags.add(flag);
+            }
+        }
+        if (protobufStreamInput.getVersion().before(Version.V_2_0_0)) {
+            protobufStreamInput.readStringArray(in);
+        }
+        groups = protobufStreamInput.readStringArray(in);
+        fieldDataFields = protobufStreamInput.readStringArray(in);
+        completionDataFields = protobufStreamInput.readStringArray(in);
+        includeSegmentFileSizes = in.readBool();
+        includeUnloadedSegments = in.readBool();
+        includeAllShardIndexingPressureTrackers = in.readBool();
+        includeOnlyTopIndexingPressureMetrics = in.readBool();
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        long longFlags = 0;
+        for (Flag flag : flags) {
+            longFlags |= (1 << flag.getIndex());
+        }
+        out.writeInt64NoTag(longFlags);
+
+        if (protobufStreamOutput.getVersion().before(Version.V_2_0_0)) {
+            protobufStreamOutput.writeStringArrayNullable(Strings.EMPTY_ARRAY, out);
+        }
+        protobufStreamOutput.writeStringArrayNullable(groups, out);
+        protobufStreamOutput.writeStringArrayNullable(fieldDataFields, out);
+        protobufStreamOutput.writeStringArrayNullable(completionDataFields, out);
+        out.writeBoolNoTag(includeSegmentFileSizes);
+        out.writeBoolNoTag(includeUnloadedSegments);
+        out.writeBoolNoTag(includeAllShardIndexingPressureTrackers);
+        out.writeBoolNoTag(includeOnlyTopIndexingPressureMetrics);
+    }
+
+    /**
+     * Sets all flags to return all stats.
+    */
+    public ProtobufCommonStatsFlags all() {
+        flags = EnumSet.allOf(Flag.class);
+        groups = null;
+        fieldDataFields = null;
+        completionDataFields = null;
+        includeSegmentFileSizes = false;
+        includeUnloadedSegments = false;
+        includeAllShardIndexingPressureTrackers = false;
+        includeOnlyTopIndexingPressureMetrics = false;
+        return this;
+    }
+
+    /**
+     * Clears all stats.
+    */
+    public ProtobufCommonStatsFlags clear() {
+        flags = EnumSet.noneOf(Flag.class);
+        groups = null;
+        fieldDataFields = null;
+        completionDataFields = null;
+        includeSegmentFileSizes = false;
+        includeUnloadedSegments = false;
+        includeAllShardIndexingPressureTrackers = false;
+        includeOnlyTopIndexingPressureMetrics = false;
+        return this;
+    }
+
+    public boolean anySet() {
+        return !flags.isEmpty();
+    }
+
+    public Flag[] getFlags() {
+        return flags.toArray(new Flag[0]);
+    }
+
+    /**
+     * Sets specific search group stats to retrieve the stats for. Mainly affects search
+    * when enabled.
+    */
+    public ProtobufCommonStatsFlags groups(String... groups) {
+        this.groups = groups;
+        return this;
+    }
+
+    public String[] groups() {
+        return this.groups;
+    }
+
+    /**
+     * Sets specific search group stats to retrieve the stats for. Mainly affects search
+    * when enabled.
+    */
+    public ProtobufCommonStatsFlags fieldDataFields(String... fieldDataFields) {
+        this.fieldDataFields = fieldDataFields;
+        return this;
+    }
+
+    public String[] fieldDataFields() {
+        return this.fieldDataFields;
+    }
+
+    public ProtobufCommonStatsFlags completionDataFields(String... completionDataFields) {
+        this.completionDataFields = completionDataFields;
+        return this;
+    }
+
+    public String[] completionDataFields() {
+        return this.completionDataFields;
+    }
+
+    public ProtobufCommonStatsFlags includeSegmentFileSizes(boolean includeSegmentFileSizes) {
+        this.includeSegmentFileSizes = includeSegmentFileSizes;
+        return this;
+    }
+
+    public ProtobufCommonStatsFlags includeUnloadedSegments(boolean includeUnloadedSegments) {
+        this.includeUnloadedSegments = includeUnloadedSegments;
+        return this;
+    }
+
+    public ProtobufCommonStatsFlags includeAllShardIndexingPressureTrackers(boolean includeAllShardPressureTrackers) {
+        this.includeAllShardIndexingPressureTrackers = includeAllShardPressureTrackers;
+        return this;
+    }
+
+    public ProtobufCommonStatsFlags includeOnlyTopIndexingPressureMetrics(boolean includeOnlyTopIndexingPressureMetrics) {
+        this.includeOnlyTopIndexingPressureMetrics = includeOnlyTopIndexingPressureMetrics;
+        return this;
+    }
+
+    public boolean includeUnloadedSegments() {
+        return this.includeUnloadedSegments;
+    }
+
+    public boolean includeAllShardIndexingPressureTrackers() {
+        return this.includeAllShardIndexingPressureTrackers;
+    }
+
+    public boolean includeOnlyTopIndexingPressureMetrics() {
+        return this.includeOnlyTopIndexingPressureMetrics;
+    }
+
+    public boolean includeSegmentFileSizes() {
+        return this.includeSegmentFileSizes;
+    }
+
+    public boolean isSet(Flag flag) {
+        return flags.contains(flag);
+    }
+
+    boolean unSet(Flag flag) {
+        return flags.remove(flag);
+    }
+
+    void set(Flag flag) {
+        flags.add(flag);
+    }
+
+    public ProtobufCommonStatsFlags set(Flag flag, boolean add) {
+        if (add) {
+            set(flag);
+        } else {
+            unSet(flag);
+        }
+        return this;
+    }
+
+    @Override
+    public ProtobufCommonStatsFlags clone() {
+        try {
+            ProtobufCommonStatsFlags cloned = (ProtobufCommonStatsFlags) super.clone();
+            cloned.flags = flags.clone();
+            return cloned;
+        } catch (CloneNotSupportedException e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    /**
+     * The flags.
+    *
+    * @opensearch.internal
+    */
+    public enum Flag {
+        Store("store", 0),
+        Indexing("indexing", 1),
+        Get("get", 2),
+        Search("search", 3),
+        Merge("merge", 4),
+        Flush("flush", 5),
+        Refresh("refresh", 6),
+        QueryCache("query_cache", 7),
+        FieldData("fielddata", 8),
+        Docs("docs", 9),
+        Warmer("warmer", 10),
+        Completion("completion", 11),
+        Segments("segments", 12),
+        Translog("translog", 13),
+        // 14 was previously used for Suggest
+        RequestCache("request_cache", 15),
+        Recovery("recovery", 16);
+
+        private final String restName;
+        private final int index;
+
+        Flag(final String restName, final int index) {
+            this.restName = restName;
+            this.index = index;
+        }
+
+        public String getRestName() {
+            return restName;
+        }
+
+        private int getIndex() {
+            return index;
+        }
+
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/support/IndicesOptions.java b/server/src/main/java/org/opensearch/action/support/IndicesOptions.java
index d30ee7e11bdfa..32da5e6002f55 100644
--- a/server/src/main/java/org/opensearch/action/support/IndicesOptions.java
+++ b/server/src/main/java/org/opensearch/action/support/IndicesOptions.java
@@ -31,8 +31,12 @@
 
 package org.opensearch.action.support;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
 import org.opensearch.OpenSearchParseException;
 import org.opensearch.core.ParseField;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.xcontent.ToXContent;
@@ -278,12 +282,26 @@ public void writeIndicesOptions(StreamOutput out) throws IOException {
         out.writeEnumSet(expandWildcards);
     }
 
+    public void writeIndicesOptionsProtobuf(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        EnumSet<Option> options = this.options;
+        protobufStreamOutput.writeEnumSet(options, out);
+        protobufStreamOutput.writeEnumSet(expandWildcards, out);
+    }
+
     public static IndicesOptions readIndicesOptions(StreamInput in) throws IOException {
         EnumSet<Option> options = in.readEnumSet(Option.class);
         EnumSet<WildcardStates> states = in.readEnumSet(WildcardStates.class);
         return new IndicesOptions(options, states);
     }
 
+    public static IndicesOptions readIndicesOptionsProtobuf(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        EnumSet<Option> options = protobufStreamInput.readEnumSet(Option.class, in);
+        EnumSet<WildcardStates> states = protobufStreamInput.readEnumSet(WildcardStates.class, in);
+        return new IndicesOptions(options, states);
+    }
+
     public static IndicesOptions fromOptions(
         boolean ignoreUnavailable,
         boolean allowNoIndices,
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufActionFilter.java b/server/src/main/java/org/opensearch/action/support/ProtobufActionFilter.java
new file mode 100644
index 0000000000000..45cad3065d607
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufActionFilter.java
@@ -0,0 +1,67 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.support;
+
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.ActionRequest;
+import org.opensearch.action.ActionResponse;
+import org.opensearch.action.ProtobufActionRequest;
+import org.opensearch.action.ProtobufActionResponse;
+import org.opensearch.tasks.Task;
+
+/**
+ * A filter allowing to filter transport actions
+*
+* @opensearch.internal
+*/
+public interface ProtobufActionFilter {
+
+    /**
+     * The position of the filter in the chain. Execution is done from lowest order to highest.
+    */
+    int order();
+
+    /**
+     * Enables filtering the execution of an action on the request side, either by sending a response through the
+    * {@link ActionListener} or by continuing the execution through the given {@link ActionFilterChain chain}
+    */
+    <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> void apply(
+        Task task,
+        String action,
+        Request request,
+        ActionListener<Response> listener,
+        ProtobufActionFilterChain<Request, Response> chain
+    );
+
+    /**
+     * A simple base class for injectable action filters that spares the implementation from handling the
+    * filter chain. This base class should serve any action filter implementations that doesn't require
+    * to apply async filtering logic.
+    */
+    abstract class Simple implements ProtobufActionFilter {
+        @Override
+        public final <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> void apply(
+            Task task,
+            String action,
+            Request request,
+            ActionListener<Response> listener,
+            ProtobufActionFilterChain<Request, Response> chain
+        ) {
+            if (apply(action, request, listener)) {
+                chain.proceed(task, action, request, listener);
+            }
+        }
+
+        /**
+         * Applies this filter and returns {@code true} if the execution chain should proceed, or {@code false}
+        * if it should be aborted since the filter already handled the request and called the given listener.
+        */
+        protected abstract boolean apply(String action, ProtobufActionRequest request, ActionListener<?> listener);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufActionFilterChain.java b/server/src/main/java/org/opensearch/action/support/ProtobufActionFilterChain.java
new file mode 100644
index 0000000000000..54de493efede3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufActionFilterChain.java
@@ -0,0 +1,30 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.support;
+
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.ActionRequest;
+import org.opensearch.action.ActionResponse;
+import org.opensearch.action.ProtobufActionRequest;
+import org.opensearch.action.ProtobufActionResponse;
+import org.opensearch.tasks.Task;
+
+/**
+ * A filter chain allowing to continue and process the transport action request
+*
+* @opensearch.internal
+*/
+public interface ProtobufActionFilterChain<Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> {
+
+    /**
+     * Continue processing the request. Should only be called if a response has not been sent through
+    * the given {@link ActionListener listener}
+    */
+    void proceed(Task task, String action, Request request, ActionListener<Response> listener);
+}
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufActionFilters.java b/server/src/main/java/org/opensearch/action/support/ProtobufActionFilters.java
new file mode 100644
index 0000000000000..a1395cbf73150
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufActionFilters.java
@@ -0,0 +1,40 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.support;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Set;
+
+/**
+ * Holds the action filters injected through plugins, properly sorted by {@link org.opensearch.action.support.ProtobufActionFilter#order()}
+*
+* @opensearch.internal
+*/
+public class ProtobufActionFilters {
+
+    private final ProtobufActionFilter[] filters;
+
+    public ProtobufActionFilters(Set<ProtobufActionFilter> actionFilters) {
+        this.filters = actionFilters.toArray(new ProtobufActionFilter[0]);
+        Arrays.sort(filters, new Comparator<ProtobufActionFilter>() {
+            @Override
+            public int compare(ProtobufActionFilter o1, ProtobufActionFilter o2) {
+                return Integer.compare(o1.order(), o2.order());
+            }
+        });
+    }
+
+    /**
+     * Returns the action filters that have been injected
+    */
+    public ProtobufActionFilter[] filters() {
+        return filters;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java b/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
new file mode 100644
index 0000000000000..1225fbd403b04
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
@@ -0,0 +1,245 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.support;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.ActionRequest;
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.action.ActionResponse;
+import org.opensearch.action.ProtobufActionRequest;
+import org.opensearch.action.ProtobufActionResponse;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.lease.Releasables;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.tasks.ProtobufTask;
+import org.opensearch.tasks.ProtobufTaskId;
+import org.opensearch.tasks.Task;
+import org.opensearch.tasks.TaskCancelledException;
+import org.opensearch.tasks.TaskId;
+import org.opensearch.tasks.TaskListener;
+import org.opensearch.tasks.TaskManager;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Base class for a transport action
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufTransportAction<Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> {
+
+    public final String actionName;
+    private final ProtobufActionFilter[] filters;
+    protected final TaskManager taskManager;
+    /**
+     * @deprecated declare your own logger.
+    */
+    @Deprecated
+    protected Logger logger = LogManager.getLogger(getClass());
+
+    protected ProtobufTransportAction(String actionName, ProtobufActionFilters actionFilters, TaskManager taskManager) {
+        this.actionName = actionName;
+        this.filters = actionFilters.filters();
+        this.taskManager = taskManager;
+    }
+
+    private Releasable registerChildNode(ProtobufTaskId parentTask) {
+        if (parentTask.isSet()) {
+            return taskManager.registerChildNode(parentTask.getId(), taskManager.localNode());
+        } else {
+            return () -> {};
+        }
+    }
+
+    /**
+     * Use this method when the transport action call should result in creation of a new task associated with the call.
+    *
+    * This is a typical behavior.
+    */
+    public final ProtobufTask execute(Request request, ActionListener<Response> listener) {
+        /*
+        * While this version of execute could delegate to the TaskListener
+        * version of execute that'd add yet another layer of wrapping on the
+        * listener and prevent us from using the listener bare if there isn't a
+        * task. That just seems like too many objects. Thus the two versions of
+        * this method.
+        */
+        final Releasable unregisterChildNode = registerChildNode(request.getParentTask());
+        final ProtobufTask task;
+
+        try {
+            task = taskManager.register("transport", actionName, request);
+        } catch (TaskCancelledException e) {
+            unregisterChildNode.close();
+            throw e;
+        }
+
+        ThreadContext.StoredContext storedContext = taskManager.taskExecutionStarted(task);
+        try {
+            execute(task, request, new ActionListener<Response>() {
+                @Override
+                public void onResponse(Response response) {
+                    try {
+                        Releasables.close(unregisterChildNode, () -> taskManager.unregister(task));
+                    } finally {
+                        listener.onResponse(response);
+                    }
+                }
+
+                @Override
+                public void onFailure(Exception e) {
+                    try {
+                        Releasables.close(unregisterChildNode, () -> taskManager.unregister(task));
+                    } finally {
+                        listener.onFailure(e);
+                    }
+                }
+            });
+        } finally {
+            storedContext.close();
+        }
+
+        return task;
+    }
+
+    /**
+     * Execute the transport action on the local node, returning the {@link Task} used to track its execution and accepting a
+    * {@link TaskListener} which listens for the completion of the action.
+    */
+    public final Task execute(Request request, TaskListener<Response> listener) {
+        final Releasable unregisterChildNode = registerChildNode(request.getParentTask());
+        final Task task;
+        try {
+            task = taskManager.register("transport", actionName, request);
+        } catch (TaskCancelledException e) {
+            unregisterChildNode.close();
+            throw e;
+        }
+        ThreadContext.StoredContext storedContext = taskManager.taskExecutionStarted(task);
+        try {
+            execute(task, request, new ActionListener<Response>() {
+                @Override
+                public void onResponse(Response response) {
+                    try {
+                        Releasables.close(unregisterChildNode, () -> taskManager.unregister(task));
+                    } finally {
+                        listener.onResponse(task, response);
+                    }
+                }
+
+                @Override
+                public void onFailure(Exception e) {
+                    try {
+                        Releasables.close(unregisterChildNode, () -> taskManager.unregister(task));
+                    } finally {
+                        listener.onFailure(task, e);
+                    }
+                }
+            });
+        } finally {
+            storedContext.close();
+        }
+        return task;
+    }
+
+    /**
+     * Use this method when the transport action should continue to run in the context of the current task
+    */
+    public final void execute(Task task, Request request, ActionListener<Response> listener) {
+        ActionRequestValidationException validationException = request.validate();
+        if (validationException != null) {
+            listener.onFailure(validationException);
+            return;
+        }
+
+        if (task != null && request.getShouldStoreResult()) {
+            listener = new TaskResultStoringActionListener<>(taskManager, task, listener);
+        }
+
+        RequestFilterChain<Request, Response> requestFilterChain = new RequestFilterChain<>(this, logger);
+        requestFilterChain.proceed(task, actionName, request, listener);
+    }
+
+    protected abstract void doExecute(Task task, Request request, ActionListener<Response> listener);
+
+    /**
+     * A request filter chain
+    *
+    * @opensearch.internal
+    */
+    private static class RequestFilterChain<Request extends ActionRequest, Response extends ActionResponse>
+        implements
+            ActionFilterChain<Request, Response> {
+
+        private final TransportAction<Request, Response> action;
+        private final AtomicInteger index = new AtomicInteger();
+        private final Logger logger;
+
+        private RequestFilterChain(TransportAction<Request, Response> action, Logger logger) {
+            this.action = action;
+            this.logger = logger;
+        }
+
+        @Override
+        public void proceed(Task task, String actionName, Request request, ActionListener<Response> listener) {
+            int i = index.getAndIncrement();
+            try {
+                if (i < this.action.filters.length) {
+                    this.action.filters[i].apply(task, actionName, request, listener, this);
+                } else if (i == this.action.filters.length) {
+                    this.action.doExecute(task, request, listener);
+                } else {
+                    listener.onFailure(new IllegalStateException("proceed was called too many times"));
+                }
+            } catch (Exception e) {
+                logger.trace("Error during transport action execution.", e);
+                listener.onFailure(e);
+            }
+        }
+
+    }
+
+    /**
+     * Wrapper for an action listener that stores the result at the end of the execution
+    *
+    * @opensearch.internal
+    */
+    private static class TaskResultStoringActionListener<Response extends ActionResponse> implements ActionListener<Response> {
+        private final ActionListener<Response> delegate;
+        private final Task task;
+        private final TaskManager taskManager;
+
+        private TaskResultStoringActionListener(TaskManager taskManager, Task task, ActionListener<Response> delegate) {
+            this.taskManager = taskManager;
+            this.task = task;
+            this.delegate = delegate;
+        }
+
+        @Override
+        public void onResponse(Response response) {
+            try {
+                taskManager.storeResult(task, response, delegate);
+            } catch (Exception e) {
+                delegate.onFailure(e);
+            }
+        }
+
+        @Override
+        public void onFailure(Exception e) {
+            try {
+                taskManager.storeResult(task, e, delegate);
+            } catch (Exception inner) {
+                inner.addSuppressed(e);
+                delegate.onFailure(inner);
+            }
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeOperationRequestBuilder.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeOperationRequestBuilder.java
new file mode 100644
index 0000000000000..570d21cdc32f8
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeOperationRequestBuilder.java
@@ -0,0 +1,76 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.support.clustermanager;
+
+import org.opensearch.action.ActionType;
+import org.opensearch.action.ProtobufActionRequestBuilder;
+import org.opensearch.action.ProtobufActionResponse;
+import org.opensearch.action.ProtobufActionType;
+import org.opensearch.action.ActionRequestBuilder;
+import org.opensearch.action.ActionResponse;
+import org.opensearch.client.OpenSearchClient;
+import org.opensearch.client.ProtobufOpenSearchClient;
+import org.opensearch.common.unit.TimeValue;
+
+/**
+ * Base request builder for cluster-manager node operations
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufClusterManagerNodeOperationRequestBuilder<
+    Request extends ProtobufClusterManagerNodeRequest<Request>,
+    Response extends ProtobufActionResponse,
+    RequestBuilder extends ProtobufClusterManagerNodeOperationRequestBuilder<Request, Response, RequestBuilder>> extends ProtobufActionRequestBuilder<
+        Request,
+        Response> {
+
+    protected ProtobufClusterManagerNodeOperationRequestBuilder(ProtobufOpenSearchClient client, ProtobufActionType<Response> action, Request request) {
+        super(client, action, request);
+    }
+
+    /**
+     * Sets the cluster-manager node timeout in case the cluster-manager has not yet been discovered.
+    */
+    @SuppressWarnings("unchecked")
+    public final RequestBuilder setClusterManagerNodeTimeout(TimeValue timeout) {
+        request.clusterManagerNodeTimeout(timeout);
+        return (RequestBuilder) this;
+    }
+
+    /**
+     * Sets the cluster-manager node timeout in case the cluster-manager has not yet been discovered.
+    *
+    * @deprecated As of 2.1, because supporting inclusive language, replaced by {@link #setClusterManagerNodeTimeout(TimeValue)}
+    */
+    @SuppressWarnings("unchecked")
+    @Deprecated
+    public final RequestBuilder setMasterNodeTimeout(TimeValue timeout) {
+        return setClusterManagerNodeTimeout(timeout);
+    }
+
+    /**
+     * Sets the cluster-manager node timeout in case the cluster-manager has not yet been discovered.
+    */
+    @SuppressWarnings("unchecked")
+    public final RequestBuilder setClusterManagerNodeTimeout(String timeout) {
+        request.clusterManagerNodeTimeout(timeout);
+        return (RequestBuilder) this;
+    }
+
+    /**
+     * Sets the cluster-manager node timeout in case the cluster-manager has not yet been discovered.
+    *
+    * @deprecated As of 2.1, because supporting inclusive language, replaced by {@link #setClusterManagerNodeTimeout(String)}
+    */
+    @SuppressWarnings("unchecked")
+    @Deprecated
+    public final RequestBuilder setMasterNodeTimeout(String timeout) {
+        return setClusterManagerNodeTimeout(timeout);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadOperationRequestBuilder.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadOperationRequestBuilder.java
new file mode 100644
index 0000000000000..d98b95451352e
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadOperationRequestBuilder.java
@@ -0,0 +1,39 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.support.clustermanager;
+
+import org.opensearch.action.ProtobufActionResponse;
+import org.opensearch.action.ProtobufActionType;
+import org.opensearch.client.OpenSearchClient;
+import org.opensearch.client.ProtobufOpenSearchClient;
+
+/**
+ * Base request builder for cluster-manager node read operations that can be executed on the local node as well
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufClusterManagerNodeReadOperationRequestBuilder<
+    Request extends ProtobufClusterManagerNodeReadRequest<Request>,
+    Response extends ProtobufActionResponse,
+    RequestBuilder extends ProtobufClusterManagerNodeReadOperationRequestBuilder<Request, Response, RequestBuilder>> extends
+    ProtobufClusterManagerNodeOperationRequestBuilder<Request, Response, RequestBuilder> {
+
+    protected ProtobufClusterManagerNodeReadOperationRequestBuilder(ProtobufOpenSearchClient client, ProtobufActionType<Response> action, Request request) {
+        super(client, action, request);
+    }
+
+    /**
+     * Specifies if the request should be executed on local node rather than on master
+    */
+    @SuppressWarnings("unchecked")
+    public final RequestBuilder setLocal(boolean local) {
+        request.local(local);
+        return (RequestBuilder) this;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadRequest.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadRequest.java
new file mode 100644
index 0000000000000..76021b40b7fb1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadRequest.java
@@ -0,0 +1,58 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.action.support.clustermanager;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
+import java.io.IOException;
+
+/**
+ * Base request for cluster-manager based read operations that allows to read the cluster state from the local node if needed
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufClusterManagerNodeReadRequest<Request extends ProtobufClusterManagerNodeReadRequest<Request>> extends
+    ProtobufClusterManagerNodeRequest<Request> {
+
+    protected boolean local = false;
+
+    protected ProtobufClusterManagerNodeReadRequest() {}
+
+    protected ProtobufClusterManagerNodeReadRequest(CodedInputStream in) throws IOException {
+        super(in);
+        local = in.readBool();
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        super.writeTo(out);
+        out.writeBoolNoTag(local);
+    }
+
+    @SuppressWarnings("unchecked")
+    public final Request local(boolean local) {
+        this.local = local;
+        return (Request) this;
+    }
+
+    /**
+     * Return local information, do not retrieve the state from cluster-manager node (default: false).
+    * @return <code>true</code> if local information is to be returned;
+    * <code>false</code> if information is to be retrieved from cluster-manager node (default).
+    */
+    public final boolean local() {
+        return local;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeRequest.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeRequest.java
new file mode 100644
index 0000000000000..83c04c161cb15
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeRequest.java
@@ -0,0 +1,108 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.action.support.clustermanager;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.action.ProtobufActionRequest;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.unit.TimeValue;
+
+import java.io.IOException;
+
+/**
+ * A protobuf request for cluster-manager based operation.
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufClusterManagerNodeRequest<Request extends ProtobufClusterManagerNodeRequest<Request>> extends
+    ProtobufActionRequest {
+
+    public static final TimeValue DEFAULT_CLUSTER_MANAGER_NODE_TIMEOUT = TimeValue.timeValueSeconds(30);
+
+    /** @deprecated As of 2.1, because supporting inclusive language, replaced by {@link #DEFAULT_CLUSTER_MANAGER_NODE_TIMEOUT} */
+    @Deprecated
+    public static final TimeValue DEFAULT_MASTER_NODE_TIMEOUT = DEFAULT_CLUSTER_MANAGER_NODE_TIMEOUT;
+
+    protected TimeValue clusterManagerNodeTimeout = DEFAULT_CLUSTER_MANAGER_NODE_TIMEOUT;
+
+    /** @deprecated As of 2.1, because supporting inclusive language, replaced by {@link #clusterManagerNodeTimeout} */
+    @Deprecated
+    protected TimeValue masterNodeTimeout = clusterManagerNodeTimeout;
+
+    protected ProtobufClusterManagerNodeRequest() {}
+
+    protected ProtobufClusterManagerNodeRequest(CodedInputStream in) throws IOException {
+        super(in);
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        clusterManagerNodeTimeout = protobufStreamInput.readTimeValue(in);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        super.writeTo(out);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        protobufStreamOutput.writeTimeValue(clusterManagerNodeTimeout, out);
+    }
+
+    /**
+     * A timeout value in case the cluster-manager has not been discovered yet or disconnected.
+    */
+    @SuppressWarnings("unchecked")
+    public final Request clusterManagerNodeTimeout(TimeValue timeout) {
+        this.clusterManagerNodeTimeout = timeout;
+        return (Request) this;
+    }
+
+    /**
+     * A timeout value in case the cluster-manager has not been discovered yet or disconnected.
+    *
+    * @deprecated As of 2.1, because supporting inclusive language, replaced by {@link #clusterManagerNodeTimeout(TimeValue)}
+    */
+    @SuppressWarnings("unchecked")
+    @Deprecated
+    public final Request masterNodeTimeout(TimeValue timeout) {
+        return clusterManagerNodeTimeout(timeout);
+    }
+
+    /**
+     * A timeout value in case the cluster-manager has not been discovered yet or disconnected.
+    */
+    public final Request clusterManagerNodeTimeout(String timeout) {
+        return clusterManagerNodeTimeout(
+            TimeValue.parseTimeValue(timeout, null, getClass().getSimpleName() + ".clusterManagerNodeTimeout")
+        );
+    }
+
+    /**
+     * A timeout value in case the cluster-manager has not been discovered yet or disconnected.
+    *
+    * @deprecated As of 2.1, because supporting inclusive language, replaced by {@link #clusterManagerNodeTimeout(String)}
+    */
+    @Deprecated
+    public final Request masterNodeTimeout(String timeout) {
+        return clusterManagerNodeTimeout(timeout);
+    }
+
+    public final TimeValue clusterManagerNodeTimeout() {
+        return this.clusterManagerNodeTimeout;
+    }
+
+    /** @deprecated As of 2.1, because supporting inclusive language, replaced by {@link #clusterManagerNodeTimeout()} */
+    @Deprecated
+    public final TimeValue masterNodeTimeout() {
+        return clusterManagerNodeTimeout();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
new file mode 100644
index 0000000000000..5b8f96cbcd083
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
@@ -0,0 +1,53 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.action.support.nodes;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.transport.ProtobufTransportResponse;
+
+import java.io.IOException;
+
+/**
+ * A base class for node level operations.
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufBaseNodeResponse extends ProtobufTransportResponse {
+
+    private ProtobufDiscoveryNode node;
+
+    protected ProtobufBaseNodeResponse(CodedInputStream in) throws IOException {
+        super(in);
+        node = new ProtobufDiscoveryNode(in);
+    }
+
+    protected ProtobufBaseNodeResponse(ProtobufDiscoveryNode node) {
+        assert node != null;
+        this.node = node;
+    }
+
+    /**
+     * The node this information relates to.
+    */
+    public ProtobufDiscoveryNode getNode() {
+        return node;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        node.writeTo(out);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
new file mode 100644
index 0000000000000..283b792fc26e2
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
@@ -0,0 +1,119 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.action.support.nodes;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.action.ProtobufActionRequest;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.unit.TimeValue;
+
+import java.io.IOException;
+
+/**
+ * Base class for requests targeting a list of nodes
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufBaseNodesRequest<Request extends ProtobufBaseNodesRequest<Request>> extends ProtobufActionRequest {
+
+    /**
+     * the list of nodesIds that will be used to resolve this request and {@link #concreteNodes}
+    * will be populated. Note that if {@link #concreteNodes} is not null, it will be used and nodeIds
+    * will be ignored.
+    *
+    * See {@link DiscoveryNodes#resolveNodes} for a full description of the options.
+    *
+    * TODO: get rid of this and resolve it to concrete nodes in the rest layer
+    **/
+    private String[] nodesIds;
+
+    /**
+     * once {@link #nodesIds} are resolved this will contain the concrete nodes that are part of this request. If set, {@link #nodesIds}
+    * will be ignored and this will be used.
+    * */
+    private ProtobufDiscoveryNode[] concreteNodes;
+    private final TimeValue DEFAULT_TIMEOUT_SECS = TimeValue.timeValueSeconds(30);
+
+    private TimeValue timeout;
+
+    protected ProtobufBaseNodesRequest(CodedInputStream in) throws IOException {
+        super(in);
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        nodesIds = protobufStreamInput.readStringArray(in);
+        concreteNodes = protobufStreamInput.readOptionalArray(ProtobufDiscoveryNode::new, ProtobufDiscoveryNode[]::new, in);
+        timeout = protobufStreamInput.readOptionalTimeValue(in);
+    }
+
+    protected ProtobufBaseNodesRequest(String... nodesIds) {
+        this.nodesIds = nodesIds;
+    }
+
+    protected ProtobufBaseNodesRequest(ProtobufDiscoveryNode... concreteNodes) {
+        this.nodesIds = null;
+        this.concreteNodes = concreteNodes;
+    }
+
+    public final String[] nodesIds() {
+        return nodesIds;
+    }
+
+    @SuppressWarnings("unchecked")
+    public final Request nodesIds(String... nodesIds) {
+        this.nodesIds = nodesIds;
+        return (Request) this;
+    }
+
+    public TimeValue timeout() {
+        return this.timeout;
+    }
+
+    @SuppressWarnings("unchecked")
+    public final Request timeout(TimeValue timeout) {
+        this.timeout = timeout;
+        return (Request) this;
+    }
+
+    @SuppressWarnings("unchecked")
+    public final Request timeout(String timeout) {
+        this.timeout = TimeValue.parseTimeValue(timeout, DEFAULT_TIMEOUT_SECS, getClass().getSimpleName() + ".timeout");
+        return (Request) this;
+    }
+
+    public ProtobufDiscoveryNode[] concreteNodes() {
+        return concreteNodes;
+    }
+
+    public void setConcreteNodes(ProtobufDiscoveryNode[] concreteNodes) {
+        this.concreteNodes = concreteNodes;
+    }
+
+    @Override
+    public ActionRequestValidationException validate() {
+        return null;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream output) throws IOException {
+        super.writeTo(output);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        protobufStreamOutput.writeStringArrayNullable(nodesIds, output);
+        protobufStreamOutput.writeOptionalArray((out, value) -> value.writeTo(out), concreteNodes, output);
+        protobufStreamOutput.writeOptionalTimeValue(timeout, output);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java
new file mode 100644
index 0000000000000..7a9ae34aa4ed6
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java
@@ -0,0 +1,133 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.action.support.nodes;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.action.ProtobufActionResponse;
+import org.opensearch.action.ProtobufFailedNodeException;
+import org.opensearch.cluster.ProtobufClusterName;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Transport response for nodes requests
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufBaseNodesResponse<TNodeResponse extends ProtobufBaseNodeResponse> extends ProtobufActionResponse {
+
+    private ProtobufClusterName clusterName;
+    private List<ProtobufFailedNodeException> failures;
+    private List<TNodeResponse> nodes;
+    private Map<String, TNodeResponse> nodesMap;
+
+    protected ProtobufBaseNodesResponse(CodedInputStream in) throws IOException {
+        super(in);
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        clusterName = new ProtobufClusterName(in);
+        nodes = readNodesFrom(in);
+        failures = protobufStreamInput.readList(ProtobufFailedNodeException::new, in);
+    }
+
+    protected ProtobufBaseNodesResponse(
+        ProtobufClusterName clusterName,
+        List<TNodeResponse> nodes,
+        List<ProtobufFailedNodeException> failures
+    ) {
+        this.clusterName = Objects.requireNonNull(clusterName);
+        this.failures = Objects.requireNonNull(failures);
+        this.nodes = Objects.requireNonNull(nodes);
+    }
+
+    /**
+     * Get the {@link ProtobufClusterName} associated with all of the nodes.
+    *
+    * @return Never {@code null}.
+    */
+    public ProtobufClusterName getClusterName() {
+        return clusterName;
+    }
+
+    /**
+     * Get the failed node exceptions.
+    *
+    * @return Never {@code null}. Can be empty.
+    */
+    public List<ProtobufFailedNodeException> failures() {
+        return failures;
+    }
+
+    /**
+     * Determine if there are any node failures in {@link #failures}.
+    *
+    * @return {@code true} if {@link #failures} contains at least 1 {@link ProtobufFailedNodeException}.
+    */
+    public boolean hasFailures() {
+        return failures.isEmpty() == false;
+    }
+
+    /**
+     * Get the <em>successful</em> node responses.
+    *
+    * @return Never {@code null}. Can be empty.
+    * @see #hasFailures()
+    */
+    public List<TNodeResponse> getNodes() {
+        return nodes;
+    }
+
+    /**
+     * Lazily build and get a map of Node ID to node response.
+    *
+    * @return Never {@code null}. Can be empty.
+    * @see #getNodes()
+    */
+    public Map<String, TNodeResponse> getNodesMap() {
+        if (nodesMap == null) {
+            nodesMap = new HashMap<>();
+            for (TNodeResponse nodeResponse : nodes) {
+                nodesMap.put(nodeResponse.getNode().getId(), nodeResponse);
+            }
+        }
+        return nodesMap;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        clusterName.writeTo(out);
+        writeNodesTo(out, nodes);
+        protobufStreamOutput.writeCollection(failures, (o, v) -> v.writeTo(o), out);
+    }
+
+    /**
+     * Read the {@link #nodes} from the stream.
+    *
+    * @return Never {@code null}.
+    */
+    protected abstract List<TNodeResponse> readNodesFrom(CodedInputStream in) throws IOException;
+
+    /**
+     * Write the {@link #nodes} to the stream.
+    */
+    protected abstract void writeNodesTo(CodedOutputStream out, List<TNodeResponse> nodes) throws IOException;
+
+}
diff --git a/server/src/main/java/org/opensearch/client/ClusterAdminClient.java b/server/src/main/java/org/opensearch/client/ClusterAdminClient.java
index f3c04b23dfd54..13fb74dbb265e 100644
--- a/server/src/main/java/org/opensearch/client/ClusterAdminClient.java
+++ b/server/src/main/java/org/opensearch/client/ClusterAdminClient.java
@@ -55,6 +55,8 @@
 import org.opensearch.action.admin.cluster.node.info.NodesInfoRequest;
 import org.opensearch.action.admin.cluster.node.info.NodesInfoRequestBuilder;
 import org.opensearch.action.admin.cluster.node.info.NodesInfoResponse;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequest;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoResponse;
 import org.opensearch.action.admin.cluster.node.reload.NodesReloadSecureSettingsRequestBuilder;
 import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
 import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequestBuilder;
@@ -126,6 +128,8 @@
 import org.opensearch.action.admin.cluster.state.ClusterStateRequest;
 import org.opensearch.action.admin.cluster.state.ClusterStateRequestBuilder;
 import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
 import org.opensearch.action.admin.cluster.stats.ClusterStatsRequest;
 import org.opensearch.action.admin.cluster.stats.ClusterStatsRequestBuilder;
 import org.opensearch.action.admin.cluster.stats.ClusterStatsResponse;
diff --git a/server/src/main/java/org/opensearch/client/ProtobufAdminClient.java b/server/src/main/java/org/opensearch/client/ProtobufAdminClient.java
new file mode 100644
index 0000000000000..81cda3c4bc3b9
--- /dev/null
+++ b/server/src/main/java/org/opensearch/client/ProtobufAdminClient.java
@@ -0,0 +1,48 @@
+/*
+* 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.client;
+
+/**
+ * Administrative actions/operations against the cluster or the indices.
+*
+* @see org.opensearch.client.Client#admin()
+*
+* @opensearch.internal
+*/
+public interface ProtobufAdminClient {
+
+    /**
+     * A client allowing to perform actions/operations against the cluster.
+    */
+    ProtobufClusterAdminClient cluster();
+}
diff --git a/server/src/main/java/org/opensearch/client/ProtobufClient.java b/server/src/main/java/org/opensearch/client/ProtobufClient.java
new file mode 100644
index 0000000000000..4b34b3460385c
--- /dev/null
+++ b/server/src/main/java/org/opensearch/client/ProtobufClient.java
@@ -0,0 +1,32 @@
+/*
+* 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.
+*/
+
+package org.opensearch.client;
+
+import org.opensearch.action.ActionListener;
+
+/**
+ * A client provides a one stop interface for performing actions/operations against the cluster.
+* <p>
+* All operations performed are asynchronous by nature. Each action/operation has two flavors, the first
+* simply returns an {@link org.opensearch.action.ActionFuture}, while the second accepts an
+* {@link ActionListener}.
+* <p>
+* A client can be retrieved from a started {@link org.opensearch.node.Node}.
+*
+* @see org.opensearch.node.Node#client()
+*
+* @opensearch.internal
+*/
+public interface ProtobufClient extends ProtobufOpenSearchClient {
+
+    /**
+     * The admin client that can be used to perform administrative operations.
+    */
+    ProtobufAdminClient admin();
+}
diff --git a/server/src/main/java/org/opensearch/client/ProtobufClusterAdminClient.java b/server/src/main/java/org/opensearch/client/ProtobufClusterAdminClient.java
new file mode 100644
index 0000000000000..dfc638cc2a65c
--- /dev/null
+++ b/server/src/main/java/org/opensearch/client/ProtobufClusterAdminClient.java
@@ -0,0 +1,220 @@
+/*
+* 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.
+*/
+
+package org.opensearch.client;
+
+import org.opensearch.action.ActionFuture;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.admin.cluster.allocation.ClusterAllocationExplainRequest;
+import org.opensearch.action.admin.cluster.allocation.ClusterAllocationExplainRequestBuilder;
+import org.opensearch.action.admin.cluster.allocation.ClusterAllocationExplainResponse;
+import org.opensearch.action.admin.cluster.decommission.awareness.delete.DeleteDecommissionStateRequest;
+import org.opensearch.action.admin.cluster.decommission.awareness.delete.DeleteDecommissionStateRequestBuilder;
+import org.opensearch.action.admin.cluster.decommission.awareness.delete.DeleteDecommissionStateResponse;
+import org.opensearch.action.admin.cluster.decommission.awareness.get.GetDecommissionStateRequest;
+import org.opensearch.action.admin.cluster.decommission.awareness.get.GetDecommissionStateRequestBuilder;
+import org.opensearch.action.admin.cluster.decommission.awareness.get.GetDecommissionStateResponse;
+import org.opensearch.action.admin.cluster.decommission.awareness.put.DecommissionRequest;
+import org.opensearch.action.admin.cluster.decommission.awareness.put.DecommissionRequestBuilder;
+import org.opensearch.action.admin.cluster.decommission.awareness.put.DecommissionResponse;
+import org.opensearch.action.admin.cluster.health.ClusterHealthRequest;
+import org.opensearch.action.admin.cluster.health.ClusterHealthRequestBuilder;
+import org.opensearch.action.admin.cluster.health.ClusterHealthResponse;
+import org.opensearch.action.admin.cluster.node.hotthreads.NodesHotThreadsRequest;
+import org.opensearch.action.admin.cluster.node.hotthreads.NodesHotThreadsRequestBuilder;
+import org.opensearch.action.admin.cluster.node.hotthreads.NodesHotThreadsResponse;
+import org.opensearch.action.admin.cluster.node.info.NodesInfoRequest;
+import org.opensearch.action.admin.cluster.node.info.NodesInfoRequestBuilder;
+import org.opensearch.action.admin.cluster.node.info.NodesInfoResponse;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequest;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoResponse;
+import org.opensearch.action.admin.cluster.node.reload.NodesReloadSecureSettingsRequestBuilder;
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequestBuilder;
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsResponse;
+import org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksRequest;
+import org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksRequestBuilder;
+import org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksResponse;
+import org.opensearch.action.admin.cluster.node.tasks.get.GetTaskRequest;
+import org.opensearch.action.admin.cluster.node.tasks.get.GetTaskRequestBuilder;
+import org.opensearch.action.admin.cluster.node.tasks.get.GetTaskResponse;
+import org.opensearch.action.admin.cluster.node.tasks.list.ListTasksRequest;
+import org.opensearch.action.admin.cluster.node.tasks.list.ListTasksRequestBuilder;
+import org.opensearch.action.admin.cluster.node.tasks.list.ListTasksResponse;
+import org.opensearch.action.admin.cluster.node.usage.NodesUsageRequest;
+import org.opensearch.action.admin.cluster.node.usage.NodesUsageRequestBuilder;
+import org.opensearch.action.admin.cluster.node.usage.NodesUsageResponse;
+import org.opensearch.action.admin.cluster.remotestore.restore.RestoreRemoteStoreRequest;
+import org.opensearch.action.admin.cluster.remotestore.restore.RestoreRemoteStoreResponse;
+import org.opensearch.action.admin.cluster.repositories.cleanup.CleanupRepositoryRequest;
+import org.opensearch.action.admin.cluster.repositories.cleanup.CleanupRepositoryRequestBuilder;
+import org.opensearch.action.admin.cluster.repositories.cleanup.CleanupRepositoryResponse;
+import org.opensearch.action.admin.cluster.repositories.delete.DeleteRepositoryRequest;
+import org.opensearch.action.admin.cluster.repositories.delete.DeleteRepositoryRequestBuilder;
+import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesRequest;
+import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesRequestBuilder;
+import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesResponse;
+import org.opensearch.action.admin.cluster.repositories.put.PutRepositoryRequest;
+import org.opensearch.action.admin.cluster.repositories.put.PutRepositoryRequestBuilder;
+import org.opensearch.action.admin.cluster.repositories.verify.VerifyRepositoryRequest;
+import org.opensearch.action.admin.cluster.repositories.verify.VerifyRepositoryRequestBuilder;
+import org.opensearch.action.admin.cluster.repositories.verify.VerifyRepositoryResponse;
+import org.opensearch.action.admin.cluster.reroute.ClusterRerouteRequest;
+import org.opensearch.action.admin.cluster.reroute.ClusterRerouteRequestBuilder;
+import org.opensearch.action.admin.cluster.reroute.ClusterRerouteResponse;
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequestBuilder;
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsResponse;
+import org.opensearch.action.admin.cluster.shards.ClusterSearchShardsRequest;
+import org.opensearch.action.admin.cluster.shards.ClusterSearchShardsRequestBuilder;
+import org.opensearch.action.admin.cluster.shards.ClusterSearchShardsResponse;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.delete.ClusterDeleteWeightedRoutingRequest;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.delete.ClusterDeleteWeightedRoutingRequestBuilder;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.delete.ClusterDeleteWeightedRoutingResponse;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.get.ClusterGetWeightedRoutingRequest;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.get.ClusterGetWeightedRoutingRequestBuilder;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.get.ClusterGetWeightedRoutingResponse;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.put.ClusterPutWeightedRoutingRequest;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.put.ClusterPutWeightedRoutingRequestBuilder;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.put.ClusterPutWeightedRoutingResponse;
+import org.opensearch.action.admin.cluster.snapshots.clone.CloneSnapshotRequest;
+import org.opensearch.action.admin.cluster.snapshots.clone.CloneSnapshotRequestBuilder;
+import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotRequest;
+import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotRequestBuilder;
+import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotResponse;
+import org.opensearch.action.admin.cluster.snapshots.delete.DeleteSnapshotRequest;
+import org.opensearch.action.admin.cluster.snapshots.delete.DeleteSnapshotRequestBuilder;
+import org.opensearch.action.admin.cluster.snapshots.get.GetSnapshotsRequest;
+import org.opensearch.action.admin.cluster.snapshots.get.GetSnapshotsRequestBuilder;
+import org.opensearch.action.admin.cluster.snapshots.get.GetSnapshotsResponse;
+import org.opensearch.action.admin.cluster.snapshots.restore.RestoreSnapshotRequest;
+import org.opensearch.action.admin.cluster.snapshots.restore.RestoreSnapshotRequestBuilder;
+import org.opensearch.action.admin.cluster.snapshots.restore.RestoreSnapshotResponse;
+import org.opensearch.action.admin.cluster.snapshots.status.SnapshotsStatusRequest;
+import org.opensearch.action.admin.cluster.snapshots.status.SnapshotsStatusRequestBuilder;
+import org.opensearch.action.admin.cluster.snapshots.status.SnapshotsStatusResponse;
+import org.opensearch.action.admin.cluster.state.ClusterStateRequest;
+import org.opensearch.action.admin.cluster.state.ClusterStateRequestBuilder;
+import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequestBuilder;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
+import org.opensearch.action.admin.cluster.stats.ClusterStatsRequest;
+import org.opensearch.action.admin.cluster.stats.ClusterStatsRequestBuilder;
+import org.opensearch.action.admin.cluster.stats.ClusterStatsResponse;
+import org.opensearch.action.admin.cluster.storedscripts.DeleteStoredScriptRequest;
+import org.opensearch.action.admin.cluster.storedscripts.DeleteStoredScriptRequestBuilder;
+import org.opensearch.action.admin.cluster.storedscripts.GetStoredScriptRequest;
+import org.opensearch.action.admin.cluster.storedscripts.GetStoredScriptRequestBuilder;
+import org.opensearch.action.admin.cluster.storedscripts.GetStoredScriptResponse;
+import org.opensearch.action.admin.cluster.storedscripts.PutStoredScriptRequest;
+import org.opensearch.action.admin.cluster.storedscripts.PutStoredScriptRequestBuilder;
+import org.opensearch.action.admin.cluster.tasks.PendingClusterTasksRequest;
+import org.opensearch.action.admin.cluster.tasks.PendingClusterTasksRequestBuilder;
+import org.opensearch.action.admin.cluster.tasks.PendingClusterTasksResponse;
+import org.opensearch.action.admin.indices.dangling.delete.DeleteDanglingIndexRequest;
+import org.opensearch.action.admin.indices.dangling.import_index.ImportDanglingIndexRequest;
+import org.opensearch.action.admin.indices.dangling.list.ListDanglingIndicesRequest;
+import org.opensearch.action.admin.indices.dangling.list.ListDanglingIndicesResponse;
+import org.opensearch.action.ingest.DeletePipelineRequest;
+import org.opensearch.action.ingest.DeletePipelineRequestBuilder;
+import org.opensearch.action.ingest.GetPipelineRequest;
+import org.opensearch.action.ingest.GetPipelineRequestBuilder;
+import org.opensearch.action.ingest.GetPipelineResponse;
+import org.opensearch.action.ingest.PutPipelineRequest;
+import org.opensearch.action.ingest.PutPipelineRequestBuilder;
+import org.opensearch.action.ingest.SimulatePipelineRequest;
+import org.opensearch.action.ingest.SimulatePipelineRequestBuilder;
+import org.opensearch.action.ingest.SimulatePipelineResponse;
+import org.opensearch.action.search.DeleteSearchPipelineRequest;
+import org.opensearch.action.search.GetSearchPipelineRequest;
+import org.opensearch.action.search.GetSearchPipelineResponse;
+import org.opensearch.action.search.PutSearchPipelineRequest;
+import org.opensearch.action.support.master.AcknowledgedResponse;
+import org.opensearch.common.bytes.BytesReference;
+import org.opensearch.common.xcontent.XContentType;
+import org.opensearch.tasks.TaskId;
+
+/**
+ * Administrative actions/operations against indices.
+*
+* @see AdminClient#cluster()
+*
+* @opensearch.internal
+*/
+public interface ProtobufClusterAdminClient extends ProtobufOpenSearchClient {
+
+    /**
+     * The state of the cluster.
+    *
+    * @param request The cluster state request.
+    * @return The result future
+    * @see Requests#clusterStateRequest()
+    */
+    ActionFuture<ProtobufClusterStateResponse> state(ProtobufClusterStateRequest request);
+
+    /**
+     * The state of the cluster.
+    *
+    * @param request  The cluster state request.
+    * @param listener A listener to be notified with a result
+    * @see Requests#clusterStateRequest()
+    */
+    void state(ProtobufClusterStateRequest request, ActionListener<ProtobufClusterStateResponse> listener);
+
+    /**
+     * The state of the cluster.
+    */
+    ProtobufClusterStateRequestBuilder prepareState();
+
+    /**
+     * Nodes info of the cluster.
+    *
+    * @param request The nodes info request
+    * @return The result future
+    * @see org.opensearch.client.Requests#nodesInfoRequest(String...)
+    */
+    ActionFuture<ProtobufNodesInfoResponse> nodesInfo(ProtobufNodesInfoRequest request);
+
+    /**
+     * Nodes info of the cluster.
+    *
+    * @param request  The nodes info request
+    * @param listener A listener to be notified with a result
+    * @see org.opensearch.client.Requests#nodesInfoRequest(String...)
+    */
+    void nodesInfo(ProtobufNodesInfoRequest request, ActionListener<ProtobufNodesInfoResponse> listener);
+
+    /**
+     * Nodes info of the cluster.
+    */
+    NodesInfoRequestBuilder prepareNodesInfo(String... nodesIds);
+
+    // /**
+    //  * Nodes stats of the cluster.
+    // *
+    // * @param request The nodes stats request
+    // * @return The result future
+    // * @see org.opensearch.client.Requests#nodesStatsRequest(String...)
+    // */
+    // ActionFuture<NodesStatsResponse> nodesStats(NodesStatsRequest request);
+
+    // /**
+    //  * Nodes stats of the cluster.
+    // *
+    // * @param request  The nodes info request
+    // * @param listener A listener to be notified with a result
+    // * @see org.opensearch.client.Requests#nodesStatsRequest(String...)
+    // */
+    // void nodesStats(NodesStatsRequest request, ActionListener<NodesStatsResponse> listener);
+
+    // /**
+    //  * Nodes stats of the cluster.
+    // */
+    // NodesStatsRequestBuilder prepareNodesStats(String... nodesIds);
+}
diff --git a/server/src/main/java/org/opensearch/client/ProtobufOpenSearchClient.java b/server/src/main/java/org/opensearch/client/ProtobufOpenSearchClient.java
new file mode 100644
index 0000000000000..a8db169724efb
--- /dev/null
+++ b/server/src/main/java/org/opensearch/client/ProtobufOpenSearchClient.java
@@ -0,0 +1,63 @@
+/*
+* 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.
+*/
+
+package org.opensearch.client;
+
+import org.opensearch.action.ActionType;
+import org.opensearch.action.ProtobufActionRequest;
+import org.opensearch.action.ProtobufActionResponse;
+import org.opensearch.action.ProtobufActionType;
+import org.opensearch.action.ActionFuture;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.ActionRequest;
+import org.opensearch.action.ActionResponse;
+import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+
+/**
+ * Interface for an OpenSearch client implementation
+*
+* @opensearch.internal
+*/
+public interface ProtobufOpenSearchClient {
+
+    /**
+     * Executes a generic action, denoted by an {@link ProtobufActionType}.
+    *
+    * @param action           The action type to execute.
+    * @param request          The action request.
+    * @param <Request>        The request type.
+    * @param <Response>       the response type.
+    * @return A future allowing to get back the response.
+    */
+    <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> ActionFuture<Response> execute(
+        ProtobufActionType<Response> action,
+        Request request
+    );
+
+    /**
+     * Executes a generic action, denoted by an {@link ProtobufActionType}.
+    *
+    * @param action           The action type to execute.
+    * @param request          The action request.
+    * @param listener         The listener to receive the response back.
+    * @param <Request>        The request type.
+    * @param <Response>       The response type.
+    */
+    <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> void execute(
+        ProtobufActionType<Response> action,
+        Request request,
+        ActionListener<Response> listener
+    );
+
+    /**
+     * Returns the threadpool used to execute requests on this client
+    */
+    ProtobufThreadPool threadPool();
+
+}
diff --git a/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java b/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java
new file mode 100644
index 0000000000000..2368b98e2b5e0
--- /dev/null
+++ b/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java
@@ -0,0 +1,139 @@
+/*
+* 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.
+*/
+
+package org.opensearch.client.node;
+
+import org.opensearch.action.ActionType;
+import org.opensearch.action.ProtobufActionRequest;
+import org.opensearch.action.ProtobufActionResponse;
+import org.opensearch.action.ProtobufActionType;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.ActionModule.DynamicActionRegistry;
+import org.opensearch.action.ActionRequest;
+import org.opensearch.action.ActionResponse;
+import org.opensearch.action.support.TransportAction;
+import org.opensearch.client.Client;
+import org.opensearch.client.support.AbstractClient;
+import org.opensearch.client.support.ProtobufAbstractClient;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.tasks.Task;
+import org.opensearch.tasks.TaskListener;
+import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.RemoteClusterService;
+
+import java.util.function.Supplier;
+
+/**
+ * Client that executes actions on the local node.
+*
+* @opensearch.internal
+*/
+public class ProtobufNodeClient extends ProtobufAbstractClient {
+
+    private DynamicActionRegistry actionRegistry;
+    /**
+     * The id of the local {@link DiscoveryNode}. Useful for generating task ids from tasks returned by
+    * {@link #executeLocally(ActionType, ActionRequest, TaskListener)}.
+    */
+    private Supplier<String> localNodeId;
+    private RemoteClusterService remoteClusterService;
+    private NamedWriteableRegistry namedWriteableRegistry;
+
+    public ProtobufNodeClient(Settings settings, ProtobufThreadPool threadPool) {
+        super(settings, threadPool);
+    }
+
+    public void initialize(
+        DynamicActionRegistry actionRegistry,
+        Supplier<String> localNodeId,
+        RemoteClusterService remoteClusterService,
+        NamedWriteableRegistry namedWriteableRegistry
+    ) {
+        this.actionRegistry = actionRegistry;
+        this.localNodeId = localNodeId;
+        this.remoteClusterService = remoteClusterService;
+        this.namedWriteableRegistry = namedWriteableRegistry;
+    }
+
+    @Override
+    public void close() {
+        // nothing really to do
+    }
+
+    @Override
+    public <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> void doExecute(
+        ProtobufActionType<Response> action,
+        Request request,
+        ActionListener<Response> listener
+    ) {
+        // Discard the task because the Client interface doesn't use it.
+        executeLocally(action, request, listener);
+    }
+
+    /**
+     * Execute an {@link ActionType} locally, returning that {@link Task} used to track it, and linking an {@link ActionListener}.
+    * Prefer this method if you don't need access to the task when listening for the response. This is the method used to implement
+    * the {@link Client} interface.
+    */
+    public <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> Task executeLocally(
+        ProtobufActionType<Response> action,
+        Request request,
+        ActionListener<Response> listener
+    ) {
+        return transportAction(action).execute(request, listener);
+    }
+
+    /**
+     * Execute an {@link ActionType} locally, returning that {@link Task} used to track it, and linking an {@link TaskListener}. Prefer this
+    * method if you need access to the task when listening for the response.
+    */
+    public <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> Task executeLocally(
+        ProtobufActionType<Response> action,
+        Request request,
+        TaskListener<Response> listener
+    ) {
+        return transportAction(action).execute(request, listener);
+    }
+
+    /**
+     * The id of the local {@link DiscoveryNode}. Useful for generating task ids from tasks returned by
+    * {@link #executeLocally(ProtobufActionType, ProtobufActionRequest, TaskListener)}.
+    */
+    public String getLocalNodeId() {
+        return localNodeId.get();
+    }
+
+    /**
+     * Get the {@link TransportAction} for an {@link ActionType}, throwing exceptions if the action isn't available.
+    */
+    @SuppressWarnings("unchecked")
+    private <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> TransportAction<Request, Response> transportAction(
+        ProtobufActionType<Response> action
+    ) {
+        if (actionRegistry == null) {
+            throw new IllegalStateException("NodeClient has not been initialized");
+        }
+        TransportAction<Request, Response> transportAction = (TransportAction<Request, Response>) actionRegistry.get(action);
+        if (transportAction == null) {
+            throw new IllegalStateException("failed to find action [" + action + "] to execute");
+        }
+        return transportAction;
+    }
+
+    @Override
+    public Client getRemoteClusterClient(String clusterAlias) {
+        return remoteClusterService.getRemoteClusterClient(threadPool(), clusterAlias);
+    }
+
+    public NamedWriteableRegistry getNamedWriteableRegistry() {
+        return namedWriteableRegistry;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/client/support/AbstractClient.java b/server/src/main/java/org/opensearch/client/support/AbstractClient.java
index 40489e29ed9b5..e43f96eeddc7c 100644
--- a/server/src/main/java/org/opensearch/client/support/AbstractClient.java
+++ b/server/src/main/java/org/opensearch/client/support/AbstractClient.java
@@ -67,6 +67,8 @@
 import org.opensearch.action.admin.cluster.node.info.NodesInfoRequest;
 import org.opensearch.action.admin.cluster.node.info.NodesInfoRequestBuilder;
 import org.opensearch.action.admin.cluster.node.info.NodesInfoResponse;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequest;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoResponse;
 import org.opensearch.action.admin.cluster.node.reload.NodesReloadSecureSettingsAction;
 import org.opensearch.action.admin.cluster.node.reload.NodesReloadSecureSettingsRequestBuilder;
 import org.opensearch.action.admin.cluster.node.stats.NodesStatsAction;
@@ -164,6 +166,8 @@
 import org.opensearch.action.admin.cluster.state.ClusterStateRequest;
 import org.opensearch.action.admin.cluster.state.ClusterStateRequestBuilder;
 import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
 import org.opensearch.action.admin.cluster.stats.ClusterStatsAction;
 import org.opensearch.action.admin.cluster.stats.ClusterStatsRequest;
 import org.opensearch.action.admin.cluster.stats.ClusterStatsRequestBuilder;
@@ -876,6 +880,21 @@ public NodesInfoRequestBuilder prepareNodesInfo(String... nodesIds) {
             return new NodesInfoRequestBuilder(this, NodesInfoAction.INSTANCE).setNodesIds(nodesIds);
         }
 
+        @Override
+        public ActionFuture<ProtobufNodesInfoResponse> nodesInfo(final ProtobufNodesInfoRequest request) {
+            return execute(NodesInfoAction.INSTANCE, request);
+        }
+
+        @Override
+        public void nodesInfo(final NodesInfoRequest request, final ActionListener<NodesInfoResponse> listener) {
+            execute(NodesInfoAction.INSTANCE, request, listener);
+        }
+
+        @Override
+        public NodesInfoRequestBuilder prepareNodesInfo(String... nodesIds) {
+            return new NodesInfoRequestBuilder(this, NodesInfoAction.INSTANCE).setNodesIds(nodesIds);
+        }
+
         @Override
         public ActionFuture<NodesStatsResponse> nodesStats(final NodesStatsRequest request) {
             return execute(NodesStatsAction.INSTANCE, request);
diff --git a/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java b/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
new file mode 100644
index 0000000000000..d069c0edb0077
--- /dev/null
+++ b/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
@@ -0,0 +1,581 @@
+/*
+* 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.
+*/
+
+package org.opensearch.client.support;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.action.ActionFuture;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.ActionRequest;
+import org.opensearch.action.ActionResponse;
+import org.opensearch.action.ActionType;
+import org.opensearch.action.ProtobufActionRequest;
+import org.opensearch.action.ProtobufActionResponse;
+import org.opensearch.action.ProtobufActionType;
+import org.opensearch.action.admin.cluster.allocation.ClusterAllocationExplainAction;
+import org.opensearch.action.admin.cluster.allocation.ClusterAllocationExplainRequest;
+import org.opensearch.action.admin.cluster.allocation.ClusterAllocationExplainRequestBuilder;
+import org.opensearch.action.admin.cluster.allocation.ClusterAllocationExplainResponse;
+import org.opensearch.action.admin.cluster.decommission.awareness.delete.DeleteDecommissionStateAction;
+import org.opensearch.action.admin.cluster.decommission.awareness.delete.DeleteDecommissionStateRequest;
+import org.opensearch.action.admin.cluster.decommission.awareness.delete.DeleteDecommissionStateRequestBuilder;
+import org.opensearch.action.admin.cluster.decommission.awareness.delete.DeleteDecommissionStateResponse;
+import org.opensearch.action.admin.cluster.decommission.awareness.get.GetDecommissionStateAction;
+import org.opensearch.action.admin.cluster.decommission.awareness.get.GetDecommissionStateRequest;
+import org.opensearch.action.admin.cluster.decommission.awareness.get.GetDecommissionStateRequestBuilder;
+import org.opensearch.action.admin.cluster.decommission.awareness.get.GetDecommissionStateResponse;
+import org.opensearch.action.admin.cluster.decommission.awareness.put.DecommissionAction;
+import org.opensearch.action.admin.cluster.decommission.awareness.put.DecommissionRequest;
+import org.opensearch.action.admin.cluster.decommission.awareness.put.DecommissionRequestBuilder;
+import org.opensearch.action.admin.cluster.decommission.awareness.put.DecommissionResponse;
+import org.opensearch.action.admin.cluster.health.ClusterHealthAction;
+import org.opensearch.action.admin.cluster.health.ClusterHealthRequest;
+import org.opensearch.action.admin.cluster.health.ClusterHealthRequestBuilder;
+import org.opensearch.action.admin.cluster.health.ClusterHealthResponse;
+import org.opensearch.action.admin.cluster.node.hotthreads.NodesHotThreadsAction;
+import org.opensearch.action.admin.cluster.node.hotthreads.NodesHotThreadsRequest;
+import org.opensearch.action.admin.cluster.node.hotthreads.NodesHotThreadsRequestBuilder;
+import org.opensearch.action.admin.cluster.node.hotthreads.NodesHotThreadsResponse;
+import org.opensearch.action.admin.cluster.node.info.NodesInfoAction;
+import org.opensearch.action.admin.cluster.node.info.NodesInfoRequest;
+import org.opensearch.action.admin.cluster.node.info.NodesInfoRequestBuilder;
+import org.opensearch.action.admin.cluster.node.info.NodesInfoResponse;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequest;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoResponse;
+import org.opensearch.action.admin.cluster.node.reload.NodesReloadSecureSettingsAction;
+import org.opensearch.action.admin.cluster.node.reload.NodesReloadSecureSettingsRequestBuilder;
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsAction;
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequestBuilder;
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsResponse;
+import org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksAction;
+import org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksRequest;
+import org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksRequestBuilder;
+import org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksResponse;
+import org.opensearch.action.admin.cluster.node.tasks.get.GetTaskAction;
+import org.opensearch.action.admin.cluster.node.tasks.get.GetTaskRequest;
+import org.opensearch.action.admin.cluster.node.tasks.get.GetTaskRequestBuilder;
+import org.opensearch.action.admin.cluster.node.tasks.get.GetTaskResponse;
+import org.opensearch.action.admin.cluster.node.tasks.list.ListTasksAction;
+import org.opensearch.action.admin.cluster.node.tasks.list.ListTasksRequest;
+import org.opensearch.action.admin.cluster.node.tasks.list.ListTasksRequestBuilder;
+import org.opensearch.action.admin.cluster.node.tasks.list.ListTasksResponse;
+import org.opensearch.action.admin.cluster.node.usage.NodesUsageAction;
+import org.opensearch.action.admin.cluster.node.usage.NodesUsageRequest;
+import org.opensearch.action.admin.cluster.node.usage.NodesUsageRequestBuilder;
+import org.opensearch.action.admin.cluster.node.usage.NodesUsageResponse;
+import org.opensearch.action.admin.cluster.remotestore.restore.RestoreRemoteStoreAction;
+import org.opensearch.action.admin.cluster.remotestore.restore.RestoreRemoteStoreRequest;
+import org.opensearch.action.admin.cluster.remotestore.restore.RestoreRemoteStoreResponse;
+import org.opensearch.action.admin.cluster.repositories.cleanup.CleanupRepositoryAction;
+import org.opensearch.action.admin.cluster.repositories.cleanup.CleanupRepositoryRequest;
+import org.opensearch.action.admin.cluster.repositories.cleanup.CleanupRepositoryRequestBuilder;
+import org.opensearch.action.admin.cluster.repositories.cleanup.CleanupRepositoryResponse;
+import org.opensearch.action.admin.cluster.repositories.delete.DeleteRepositoryAction;
+import org.opensearch.action.admin.cluster.repositories.delete.DeleteRepositoryRequest;
+import org.opensearch.action.admin.cluster.repositories.delete.DeleteRepositoryRequestBuilder;
+import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesAction;
+import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesRequest;
+import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesRequestBuilder;
+import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesResponse;
+import org.opensearch.action.admin.cluster.repositories.put.PutRepositoryAction;
+import org.opensearch.action.admin.cluster.repositories.put.PutRepositoryRequest;
+import org.opensearch.action.admin.cluster.repositories.put.PutRepositoryRequestBuilder;
+import org.opensearch.action.admin.cluster.repositories.verify.VerifyRepositoryAction;
+import org.opensearch.action.admin.cluster.repositories.verify.VerifyRepositoryRequest;
+import org.opensearch.action.admin.cluster.repositories.verify.VerifyRepositoryRequestBuilder;
+import org.opensearch.action.admin.cluster.repositories.verify.VerifyRepositoryResponse;
+import org.opensearch.action.admin.cluster.reroute.ClusterRerouteAction;
+import org.opensearch.action.admin.cluster.reroute.ClusterRerouteRequest;
+import org.opensearch.action.admin.cluster.reroute.ClusterRerouteRequestBuilder;
+import org.opensearch.action.admin.cluster.reroute.ClusterRerouteResponse;
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsAction;
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequestBuilder;
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsResponse;
+import org.opensearch.action.admin.cluster.shards.ClusterSearchShardsAction;
+import org.opensearch.action.admin.cluster.shards.ClusterSearchShardsRequest;
+import org.opensearch.action.admin.cluster.shards.ClusterSearchShardsRequestBuilder;
+import org.opensearch.action.admin.cluster.shards.ClusterSearchShardsResponse;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.delete.ClusterDeleteWeightedRoutingAction;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.delete.ClusterDeleteWeightedRoutingRequest;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.delete.ClusterDeleteWeightedRoutingRequestBuilder;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.delete.ClusterDeleteWeightedRoutingResponse;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.get.ClusterGetWeightedRoutingAction;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.get.ClusterGetWeightedRoutingRequest;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.get.ClusterGetWeightedRoutingRequestBuilder;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.get.ClusterGetWeightedRoutingResponse;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.put.ClusterAddWeightedRoutingAction;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.put.ClusterPutWeightedRoutingRequest;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.put.ClusterPutWeightedRoutingRequestBuilder;
+import org.opensearch.action.admin.cluster.shards.routing.weighted.put.ClusterPutWeightedRoutingResponse;
+import org.opensearch.action.admin.cluster.snapshots.clone.CloneSnapshotAction;
+import org.opensearch.action.admin.cluster.snapshots.clone.CloneSnapshotRequest;
+import org.opensearch.action.admin.cluster.snapshots.clone.CloneSnapshotRequestBuilder;
+import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotAction;
+import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotRequest;
+import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotRequestBuilder;
+import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotResponse;
+import org.opensearch.action.admin.cluster.snapshots.delete.DeleteSnapshotAction;
+import org.opensearch.action.admin.cluster.snapshots.delete.DeleteSnapshotRequest;
+import org.opensearch.action.admin.cluster.snapshots.delete.DeleteSnapshotRequestBuilder;
+import org.opensearch.action.admin.cluster.snapshots.get.GetSnapshotsAction;
+import org.opensearch.action.admin.cluster.snapshots.get.GetSnapshotsRequest;
+import org.opensearch.action.admin.cluster.snapshots.get.GetSnapshotsRequestBuilder;
+import org.opensearch.action.admin.cluster.snapshots.get.GetSnapshotsResponse;
+import org.opensearch.action.admin.cluster.snapshots.restore.RestoreSnapshotAction;
+import org.opensearch.action.admin.cluster.snapshots.restore.RestoreSnapshotRequest;
+import org.opensearch.action.admin.cluster.snapshots.restore.RestoreSnapshotRequestBuilder;
+import org.opensearch.action.admin.cluster.snapshots.restore.RestoreSnapshotResponse;
+import org.opensearch.action.admin.cluster.snapshots.status.SnapshotsStatusAction;
+import org.opensearch.action.admin.cluster.snapshots.status.SnapshotsStatusRequest;
+import org.opensearch.action.admin.cluster.snapshots.status.SnapshotsStatusRequestBuilder;
+import org.opensearch.action.admin.cluster.snapshots.status.SnapshotsStatusResponse;
+import org.opensearch.action.admin.cluster.state.ClusterStateAction;
+import org.opensearch.action.admin.cluster.state.ClusterStateRequest;
+import org.opensearch.action.admin.cluster.state.ClusterStateRequestBuilder;
+import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateAction;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
+import org.opensearch.action.admin.cluster.stats.ClusterStatsAction;
+import org.opensearch.action.admin.cluster.stats.ClusterStatsRequest;
+import org.opensearch.action.admin.cluster.stats.ClusterStatsRequestBuilder;
+import org.opensearch.action.admin.cluster.stats.ClusterStatsResponse;
+import org.opensearch.action.admin.cluster.storedscripts.DeleteStoredScriptAction;
+import org.opensearch.action.admin.cluster.storedscripts.DeleteStoredScriptRequest;
+import org.opensearch.action.admin.cluster.storedscripts.DeleteStoredScriptRequestBuilder;
+import org.opensearch.action.admin.cluster.storedscripts.GetStoredScriptAction;
+import org.opensearch.action.admin.cluster.storedscripts.GetStoredScriptRequest;
+import org.opensearch.action.admin.cluster.storedscripts.GetStoredScriptRequestBuilder;
+import org.opensearch.action.admin.cluster.storedscripts.GetStoredScriptResponse;
+import org.opensearch.action.admin.cluster.storedscripts.PutStoredScriptAction;
+import org.opensearch.action.admin.cluster.storedscripts.PutStoredScriptRequest;
+import org.opensearch.action.admin.cluster.storedscripts.PutStoredScriptRequestBuilder;
+import org.opensearch.action.admin.cluster.tasks.PendingClusterTasksAction;
+import org.opensearch.action.admin.cluster.tasks.PendingClusterTasksRequest;
+import org.opensearch.action.admin.cluster.tasks.PendingClusterTasksRequestBuilder;
+import org.opensearch.action.admin.cluster.tasks.PendingClusterTasksResponse;
+import org.opensearch.action.admin.indices.alias.IndicesAliasesAction;
+import org.opensearch.action.admin.indices.alias.IndicesAliasesRequest;
+import org.opensearch.action.admin.indices.alias.IndicesAliasesRequestBuilder;
+import org.opensearch.action.admin.indices.alias.get.GetAliasesAction;
+import org.opensearch.action.admin.indices.alias.get.GetAliasesRequest;
+import org.opensearch.action.admin.indices.alias.get.GetAliasesRequestBuilder;
+import org.opensearch.action.admin.indices.alias.get.GetAliasesResponse;
+import org.opensearch.action.admin.indices.analyze.AnalyzeAction;
+import org.opensearch.action.admin.indices.analyze.AnalyzeRequestBuilder;
+import org.opensearch.action.admin.indices.cache.clear.ClearIndicesCacheAction;
+import org.opensearch.action.admin.indices.cache.clear.ClearIndicesCacheRequest;
+import org.opensearch.action.admin.indices.cache.clear.ClearIndicesCacheRequestBuilder;
+import org.opensearch.action.admin.indices.cache.clear.ClearIndicesCacheResponse;
+import org.opensearch.action.admin.indices.close.CloseIndexAction;
+import org.opensearch.action.admin.indices.close.CloseIndexRequest;
+import org.opensearch.action.admin.indices.close.CloseIndexRequestBuilder;
+import org.opensearch.action.admin.indices.close.CloseIndexResponse;
+import org.opensearch.action.admin.indices.create.CreateIndexAction;
+import org.opensearch.action.admin.indices.create.CreateIndexRequest;
+import org.opensearch.action.admin.indices.create.CreateIndexRequestBuilder;
+import org.opensearch.action.admin.indices.create.CreateIndexResponse;
+import org.opensearch.action.admin.indices.dangling.delete.DeleteDanglingIndexAction;
+import org.opensearch.action.admin.indices.dangling.delete.DeleteDanglingIndexRequest;
+import org.opensearch.action.admin.indices.dangling.import_index.ImportDanglingIndexAction;
+import org.opensearch.action.admin.indices.dangling.import_index.ImportDanglingIndexRequest;
+import org.opensearch.action.admin.indices.dangling.list.ListDanglingIndicesAction;
+import org.opensearch.action.admin.indices.dangling.list.ListDanglingIndicesRequest;
+import org.opensearch.action.admin.indices.dangling.list.ListDanglingIndicesResponse;
+import org.opensearch.action.admin.indices.datastream.CreateDataStreamAction;
+import org.opensearch.action.admin.indices.datastream.DeleteDataStreamAction;
+import org.opensearch.action.admin.indices.datastream.GetDataStreamAction;
+import org.opensearch.action.admin.indices.delete.DeleteIndexAction;
+import org.opensearch.action.admin.indices.delete.DeleteIndexRequest;
+import org.opensearch.action.admin.indices.delete.DeleteIndexRequestBuilder;
+import org.opensearch.action.admin.indices.exists.indices.IndicesExistsAction;
+import org.opensearch.action.admin.indices.exists.indices.IndicesExistsRequest;
+import org.opensearch.action.admin.indices.exists.indices.IndicesExistsRequestBuilder;
+import org.opensearch.action.admin.indices.exists.indices.IndicesExistsResponse;
+import org.opensearch.action.admin.indices.flush.FlushAction;
+import org.opensearch.action.admin.indices.flush.FlushRequest;
+import org.opensearch.action.admin.indices.flush.FlushRequestBuilder;
+import org.opensearch.action.admin.indices.flush.FlushResponse;
+import org.opensearch.action.admin.indices.forcemerge.ForceMergeAction;
+import org.opensearch.action.admin.indices.forcemerge.ForceMergeRequest;
+import org.opensearch.action.admin.indices.forcemerge.ForceMergeRequestBuilder;
+import org.opensearch.action.admin.indices.forcemerge.ForceMergeResponse;
+import org.opensearch.action.admin.indices.get.GetIndexAction;
+import org.opensearch.action.admin.indices.get.GetIndexRequest;
+import org.opensearch.action.admin.indices.get.GetIndexRequestBuilder;
+import org.opensearch.action.admin.indices.get.GetIndexResponse;
+import org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsAction;
+import org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsRequest;
+import org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsRequestBuilder;
+import org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsResponse;
+import org.opensearch.action.admin.indices.mapping.get.GetMappingsAction;
+import org.opensearch.action.admin.indices.mapping.get.GetMappingsRequest;
+import org.opensearch.action.admin.indices.mapping.get.GetMappingsRequestBuilder;
+import org.opensearch.action.admin.indices.mapping.get.GetMappingsResponse;
+import org.opensearch.action.admin.indices.mapping.put.PutMappingAction;
+import org.opensearch.action.admin.indices.mapping.put.PutMappingRequest;
+import org.opensearch.action.admin.indices.mapping.put.PutMappingRequestBuilder;
+import org.opensearch.action.admin.indices.open.OpenIndexAction;
+import org.opensearch.action.admin.indices.open.OpenIndexRequest;
+import org.opensearch.action.admin.indices.open.OpenIndexRequestBuilder;
+import org.opensearch.action.admin.indices.open.OpenIndexResponse;
+import org.opensearch.action.admin.indices.readonly.AddIndexBlockAction;
+import org.opensearch.action.admin.indices.readonly.AddIndexBlockRequest;
+import org.opensearch.action.admin.indices.readonly.AddIndexBlockRequestBuilder;
+import org.opensearch.action.admin.indices.readonly.AddIndexBlockResponse;
+import org.opensearch.action.admin.indices.recovery.RecoveryAction;
+import org.opensearch.action.admin.indices.recovery.RecoveryRequest;
+import org.opensearch.action.admin.indices.recovery.RecoveryRequestBuilder;
+import org.opensearch.action.admin.indices.recovery.RecoveryResponse;
+import org.opensearch.action.admin.indices.refresh.RefreshAction;
+import org.opensearch.action.admin.indices.refresh.RefreshRequest;
+import org.opensearch.action.admin.indices.refresh.RefreshRequestBuilder;
+import org.opensearch.action.admin.indices.refresh.RefreshResponse;
+import org.opensearch.action.admin.indices.resolve.ResolveIndexAction;
+import org.opensearch.action.admin.indices.rollover.RolloverAction;
+import org.opensearch.action.admin.indices.rollover.RolloverRequest;
+import org.opensearch.action.admin.indices.rollover.RolloverRequestBuilder;
+import org.opensearch.action.admin.indices.rollover.RolloverResponse;
+import org.opensearch.action.admin.indices.replication.SegmentReplicationStatsAction;
+import org.opensearch.action.admin.indices.replication.SegmentReplicationStatsRequest;
+import org.opensearch.action.admin.indices.replication.SegmentReplicationStatsRequestBuilder;
+import org.opensearch.action.admin.indices.replication.SegmentReplicationStatsResponse;
+import org.opensearch.action.admin.indices.segments.IndicesSegmentResponse;
+import org.opensearch.action.admin.indices.segments.IndicesSegmentsAction;
+import org.opensearch.action.admin.indices.segments.IndicesSegmentsRequest;
+import org.opensearch.action.admin.indices.segments.IndicesSegmentsRequestBuilder;
+import org.opensearch.action.admin.indices.segments.PitSegmentsAction;
+import org.opensearch.action.admin.indices.segments.PitSegmentsRequest;
+import org.opensearch.action.admin.indices.settings.get.GetSettingsAction;
+import org.opensearch.action.admin.indices.settings.get.GetSettingsRequest;
+import org.opensearch.action.admin.indices.settings.get.GetSettingsRequestBuilder;
+import org.opensearch.action.admin.indices.settings.get.GetSettingsResponse;
+import org.opensearch.action.admin.indices.settings.put.UpdateSettingsAction;
+import org.opensearch.action.admin.indices.settings.put.UpdateSettingsRequest;
+import org.opensearch.action.admin.indices.settings.put.UpdateSettingsRequestBuilder;
+import org.opensearch.action.admin.indices.shards.IndicesShardStoreRequestBuilder;
+import org.opensearch.action.admin.indices.shards.IndicesShardStoresAction;
+import org.opensearch.action.admin.indices.shards.IndicesShardStoresRequest;
+import org.opensearch.action.admin.indices.shards.IndicesShardStoresResponse;
+import org.opensearch.action.admin.indices.shrink.ResizeAction;
+import org.opensearch.action.admin.indices.shrink.ResizeRequest;
+import org.opensearch.action.admin.indices.shrink.ResizeRequestBuilder;
+import org.opensearch.action.admin.indices.shrink.ResizeResponse;
+import org.opensearch.action.admin.indices.stats.IndicesStatsAction;
+import org.opensearch.action.admin.indices.stats.IndicesStatsRequest;
+import org.opensearch.action.admin.indices.stats.IndicesStatsRequestBuilder;
+import org.opensearch.action.admin.indices.stats.IndicesStatsResponse;
+import org.opensearch.action.admin.indices.template.delete.DeleteIndexTemplateAction;
+import org.opensearch.action.admin.indices.template.delete.DeleteIndexTemplateRequest;
+import org.opensearch.action.admin.indices.template.delete.DeleteIndexTemplateRequestBuilder;
+import org.opensearch.action.admin.indices.template.get.GetIndexTemplatesAction;
+import org.opensearch.action.admin.indices.template.get.GetIndexTemplatesRequest;
+import org.opensearch.action.admin.indices.template.get.GetIndexTemplatesRequestBuilder;
+import org.opensearch.action.admin.indices.template.get.GetIndexTemplatesResponse;
+import org.opensearch.action.admin.indices.template.put.PutIndexTemplateAction;
+import org.opensearch.action.admin.indices.template.put.PutIndexTemplateRequest;
+import org.opensearch.action.admin.indices.template.put.PutIndexTemplateRequestBuilder;
+import org.opensearch.action.admin.indices.upgrade.get.UpgradeStatusAction;
+import org.opensearch.action.admin.indices.upgrade.get.UpgradeStatusRequest;
+import org.opensearch.action.admin.indices.upgrade.get.UpgradeStatusRequestBuilder;
+import org.opensearch.action.admin.indices.upgrade.get.UpgradeStatusResponse;
+import org.opensearch.action.admin.indices.upgrade.post.UpgradeAction;
+import org.opensearch.action.admin.indices.upgrade.post.UpgradeRequest;
+import org.opensearch.action.admin.indices.upgrade.post.UpgradeRequestBuilder;
+import org.opensearch.action.admin.indices.upgrade.post.UpgradeResponse;
+import org.opensearch.action.admin.indices.validate.query.ValidateQueryAction;
+import org.opensearch.action.admin.indices.validate.query.ValidateQueryRequest;
+import org.opensearch.action.admin.indices.validate.query.ValidateQueryRequestBuilder;
+import org.opensearch.action.admin.indices.validate.query.ValidateQueryResponse;
+import org.opensearch.action.bulk.BulkAction;
+import org.opensearch.action.bulk.BulkRequest;
+import org.opensearch.action.bulk.BulkRequestBuilder;
+import org.opensearch.action.bulk.BulkResponse;
+import org.opensearch.action.delete.DeleteAction;
+import org.opensearch.action.delete.DeleteRequest;
+import org.opensearch.action.delete.DeleteRequestBuilder;
+import org.opensearch.action.delete.DeleteResponse;
+import org.opensearch.action.explain.ExplainAction;
+import org.opensearch.action.explain.ExplainRequest;
+import org.opensearch.action.explain.ExplainRequestBuilder;
+import org.opensearch.action.explain.ExplainResponse;
+import org.opensearch.action.fieldcaps.FieldCapabilitiesAction;
+import org.opensearch.action.fieldcaps.FieldCapabilitiesRequest;
+import org.opensearch.action.fieldcaps.FieldCapabilitiesRequestBuilder;
+import org.opensearch.action.fieldcaps.FieldCapabilitiesResponse;
+import org.opensearch.action.get.GetAction;
+import org.opensearch.action.get.GetRequest;
+import org.opensearch.action.get.GetRequestBuilder;
+import org.opensearch.action.get.GetResponse;
+import org.opensearch.action.get.MultiGetAction;
+import org.opensearch.action.get.MultiGetRequest;
+import org.opensearch.action.get.MultiGetRequestBuilder;
+import org.opensearch.action.get.MultiGetResponse;
+import org.opensearch.action.index.IndexAction;
+import org.opensearch.action.index.IndexRequest;
+import org.opensearch.action.index.IndexRequestBuilder;
+import org.opensearch.action.index.IndexResponse;
+import org.opensearch.action.ingest.DeletePipelineAction;
+import org.opensearch.action.ingest.DeletePipelineRequest;
+import org.opensearch.action.ingest.DeletePipelineRequestBuilder;
+import org.opensearch.action.ingest.GetPipelineAction;
+import org.opensearch.action.ingest.GetPipelineRequest;
+import org.opensearch.action.ingest.GetPipelineRequestBuilder;
+import org.opensearch.action.ingest.GetPipelineResponse;
+import org.opensearch.action.ingest.PutPipelineAction;
+import org.opensearch.action.ingest.PutPipelineRequest;
+import org.opensearch.action.ingest.PutPipelineRequestBuilder;
+import org.opensearch.action.ingest.SimulatePipelineAction;
+import org.opensearch.action.ingest.SimulatePipelineRequest;
+import org.opensearch.action.ingest.SimulatePipelineRequestBuilder;
+import org.opensearch.action.ingest.SimulatePipelineResponse;
+import org.opensearch.action.search.ClearScrollAction;
+import org.opensearch.action.search.ClearScrollRequest;
+import org.opensearch.action.search.ClearScrollRequestBuilder;
+import org.opensearch.action.search.ClearScrollResponse;
+import org.opensearch.action.search.CreatePitAction;
+import org.opensearch.action.search.CreatePitRequest;
+import org.opensearch.action.search.CreatePitResponse;
+import org.opensearch.action.search.DeletePitAction;
+import org.opensearch.action.search.DeletePitRequest;
+import org.opensearch.action.search.DeletePitResponse;
+import org.opensearch.action.search.DeleteSearchPipelineAction;
+import org.opensearch.action.search.DeleteSearchPipelineRequest;
+import org.opensearch.action.search.GetAllPitNodesRequest;
+import org.opensearch.action.search.GetAllPitNodesResponse;
+import org.opensearch.action.search.GetSearchPipelineAction;
+import org.opensearch.action.search.GetSearchPipelineRequest;
+import org.opensearch.action.search.GetSearchPipelineResponse;
+import org.opensearch.action.search.MultiSearchAction;
+import org.opensearch.action.search.MultiSearchRequest;
+import org.opensearch.action.search.MultiSearchRequestBuilder;
+import org.opensearch.action.search.MultiSearchResponse;
+import org.opensearch.action.search.GetAllPitsAction;
+import org.opensearch.action.search.PutSearchPipelineAction;
+import org.opensearch.action.search.PutSearchPipelineRequest;
+import org.opensearch.action.search.SearchAction;
+import org.opensearch.action.search.SearchRequest;
+import org.opensearch.action.search.SearchRequestBuilder;
+import org.opensearch.action.search.SearchResponse;
+import org.opensearch.action.search.SearchScrollAction;
+import org.opensearch.action.search.SearchScrollRequest;
+import org.opensearch.action.search.SearchScrollRequestBuilder;
+import org.opensearch.action.support.PlainActionFuture;
+import org.opensearch.action.support.master.AcknowledgedResponse;
+import org.opensearch.action.termvectors.MultiTermVectorsAction;
+import org.opensearch.action.termvectors.MultiTermVectorsRequest;
+import org.opensearch.action.termvectors.MultiTermVectorsRequestBuilder;
+import org.opensearch.action.termvectors.MultiTermVectorsResponse;
+import org.opensearch.action.termvectors.TermVectorsAction;
+import org.opensearch.action.termvectors.TermVectorsRequest;
+import org.opensearch.action.termvectors.TermVectorsRequestBuilder;
+import org.opensearch.action.termvectors.TermVectorsResponse;
+import org.opensearch.action.update.UpdateAction;
+import org.opensearch.action.update.UpdateRequest;
+import org.opensearch.action.update.UpdateRequestBuilder;
+import org.opensearch.action.update.UpdateResponse;
+import org.opensearch.client.AdminClient;
+import org.opensearch.client.Client;
+import org.opensearch.client.ClusterAdminClient;
+import org.opensearch.client.FilterClient;
+import org.opensearch.client.IndicesAdminClient;
+import org.opensearch.client.OpenSearchClient;
+import org.opensearch.client.ProtobufAdminClient;
+import org.opensearch.client.ProtobufClient;
+import org.opensearch.client.ProtobufClusterAdminClient;
+import org.opensearch.client.ProtobufOpenSearchClient;
+import org.opensearch.cluster.metadata.IndexMetadata.APIBlock;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.bytes.BytesReference;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.xcontent.XContentType;
+import org.opensearch.tasks.TaskId;
+import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.util.Map;
+
+/**
+ * Base client used to create concrete client implementations
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufAbstractClient implements ProtobufClient {
+
+    protected final Logger logger;
+
+    protected final Settings settings;
+    private final ProtobufThreadPool threadPool;
+    private final Admin admin;
+
+    public ProtobufAbstractClient(Settings settings, ProtobufThreadPool threadPool) {
+        this.settings = settings;
+        this.threadPool = threadPool;
+        this.admin = new Admin(this);
+        this.logger = LogManager.getLogger(this.getClass());
+    }
+
+    @Override
+    public final Settings settings() {
+        return this.settings;
+    }
+
+    @Override
+    public final ProtobufThreadPool threadPool() {
+        return this.threadPool;
+    }
+
+    @Override
+    public final ProtobufAdminClient admin() {
+        return admin;
+    }
+
+    @Override
+    public final <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> ActionFuture<Response> execute(
+        ProtobufActionType<Response> action,
+        Request request
+    ) {
+        PlainActionFuture<Response> actionFuture = PlainActionFuture.newFuture();
+        execute(action, request, actionFuture);
+        return actionFuture;
+    }
+
+    /**
+     * This is the single execution point of *all* clients.
+    */
+    @Override
+    public final <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> void execute(
+        ProtobufActionType<Response> action,
+        Request request,
+        ActionListener<Response> listener
+    ) {
+        doExecute(action, request, listener);
+    }
+
+    protected abstract <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> void doExecute(
+        ProtobufActionType<Response> action,
+        Request request,
+        ActionListener<Response> listener
+    );
+
+    static class Admin implements ProtobufAdminClient {
+
+        private final ClusterAdmin clusterAdmin;
+
+        Admin(ProtobufOpenSearchClient client) {
+            this.clusterAdmin = new ClusterAdmin(client);
+        }
+
+        @Override
+        public ProtobufClusterAdminClient cluster() {
+            return clusterAdmin;
+        }
+    }
+
+    static class ClusterAdmin implements ProtobufClusterAdminClient {
+
+        private final ProtobufOpenSearchClient client;
+
+        ClusterAdmin(ProtobufOpenSearchClient client) {
+            this.client = client;
+        }
+
+        @Override
+        public <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> ActionFuture<Response> execute(
+            ProtobufActionType<Response> action,
+            Request request
+        ) {
+            return client.execute(action, request);
+        }
+
+        @Override
+        public <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> void execute(
+            ProtobufActionType<Response> action,
+            Request request,
+            ActionListener<Response> listener
+        ) {
+            client.execute(action, request, listener);
+        }
+
+        @Override
+        public ActionFuture<ProtobufClusterStateResponse> state(final ProtobufClusterStateRequest request) {
+            return execute(ProtobufClusterStateAction.INSTANCE, request);
+        }
+
+        @Override
+        public void state(final ProtobufClusterStateRequest request, final ActionListener<ProtobufClusterStateResponse> listener) {
+            execute(ProtobufClusterStateAction.INSTANCE, request, listener);
+        }
+
+        @Override
+        public ActionFuture<ProtobufNodesInfoResponse> nodesInfo(final ProtobufNodesInfoRequest request) {
+            return execute(NodesInfoAction.INSTANCE, request);
+        }
+
+        @Override
+        public void nodesInfo(final ProtobufNodesInfoRequest request, final ActionListener<ProtobufNodesInfoResponse> listener) {
+            execute(NodesInfoAction.INSTANCE, request, listener);
+        }
+
+        @Override
+        public NodesInfoRequestBuilder prepareNodesInfo(String... nodesIds) {
+            return new NodesInfoRequestBuilder(this, NodesInfoAction.INSTANCE).setNodesIds(nodesIds);
+        }
+
+        @Override
+        public ActionFuture<ProtobufNodesInfoResponse> nodesInfo(final ProtobufNodesInfoRequest request) {
+            return execute(NodesInfoAction.INSTANCE, request);
+        }
+
+        @Override
+        public void nodesInfo(final ProtobufNodesInfoRequest request, final ActionListener<ProtobufNodesInfoResponse> listener) {
+            execute(NodesInfoAction.INSTANCE, request, listener);
+        }
+
+        @Override
+        public NodesInfoRequestBuilder prepareNodesInfo(String... nodesIds) {
+            return new NodesInfoRequestBuilder(this, NodesInfoAction.INSTANCE).setNodesIds(nodesIds);
+        }
+
+        // @Override
+        // public ActionFuture<NodesStatsResponse> nodesStats(final NodesStatsRequest request) {
+        //     return execute(NodesStatsAction.INSTANCE, request);
+        // }
+
+        // @Override
+        // public void nodesStats(final NodesStatsRequest request, final ActionListener<NodesStatsResponse> listener) {
+        //     execute(NodesStatsAction.INSTANCE, request, listener);
+        // }
+
+        // @Override
+        // public NodesStatsRequestBuilder prepareNodesStats(String... nodesIds) {
+        //     return new NodesStatsRequestBuilder(this, NodesStatsAction.INSTANCE).setNodesIds(nodesIds);
+        // }
+    }
+
+    @Override
+    public Client filterWithHeader(Map<String, String> headers) {
+        return new FilterClient(this) {
+            @Override
+            protected <Request extends ActionRequest, Response extends ActionResponse> void doExecute(
+                ActionType<Response> action,
+                Request request,
+                ActionListener<Response> listener
+            ) {
+                ThreadContext threadContext = threadPool().getThreadContext();
+                try (ThreadContext.StoredContext ctx = threadContext.stashAndMergeHeaders(headers)) {
+                    super.doExecute(action, request, listener);
+                }
+            }
+        };
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterChangedEvent.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterChangedEvent.java
new file mode 100644
index 0000000000000..59f6f7bfeb29e
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufClusterChangedEvent.java
@@ -0,0 +1,307 @@
+/*
+* 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.
+*/
+
+package org.opensearch.cluster;
+
+import org.opensearch.cluster.metadata.IndexGraveyard;
+import org.opensearch.cluster.metadata.IndexGraveyard.IndexGraveyardDiff;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
+import org.opensearch.gateway.GatewayService;
+import org.opensearch.index.Index;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * An event received by the local node, signaling that the cluster state has changed.
+*
+* @opensearch.internal
+*/
+public class ProtobufClusterChangedEvent {
+
+    private final String source;
+
+    private final ProtobufClusterState previousState;
+
+    private final ProtobufClusterState state;
+
+    private final ProtobufDiscoveryNodes.Delta nodesDelta;
+
+    public ProtobufClusterChangedEvent(String source, ProtobufClusterState state, ProtobufClusterState previousState) {
+        Objects.requireNonNull(source, "source must not be null");
+        Objects.requireNonNull(state, "state must not be null");
+        Objects.requireNonNull(previousState, "previousState must not be null");
+        this.source = source;
+        this.state = state;
+        this.previousState = previousState;
+        this.nodesDelta = state.nodes().delta(previousState.nodes());
+    }
+
+    /**
+     * The source that caused this cluster event to be raised.
+    */
+    public String source() {
+        return this.source;
+    }
+
+    /**
+     * The new cluster state that caused this change event.
+    */
+    public ProtobufClusterState state() {
+        return this.state;
+    }
+
+    /**
+     * The previous cluster state for this change event.
+    */
+    public ProtobufClusterState previousState() {
+        return this.previousState;
+    }
+
+    /**
+     * Returns <code>true</code> iff the routing tables (for all indices) have
+    * changed between the previous cluster state and the current cluster state.
+    * Note that this is an object reference equality test, not an equals test.
+    */
+    public boolean routingTableChanged() {
+        return state.routingTable() != previousState.routingTable();
+    }
+
+    /**
+     * Returns <code>true</code> iff the routing table has changed for the given index.
+    * Note that this is an object reference equality test, not an equals test.
+    */
+    public boolean indexRoutingTableChanged(String index) {
+        Objects.requireNonNull(index, "index must not be null");
+        if (!state.routingTable().hasIndex(index) && !previousState.routingTable().hasIndex(index)) {
+            return false;
+        }
+        if (state.routingTable().hasIndex(index) && previousState.routingTable().hasIndex(index)) {
+            return state.routingTable().index(index) != previousState.routingTable().index(index);
+        }
+        return true;
+    }
+
+    /**
+     * Returns the indices created in this event
+    */
+    public List<String> indicesCreated() {
+        if (!metadataChanged()) {
+            return Collections.emptyList();
+        }
+        List<String> created = null;
+        for (final String index : state.metadata().indices().keySet()) {
+            if (!previousState.metadata().hasIndex(index)) {
+                if (created == null) {
+                    created = new ArrayList<>();
+                }
+                created.add(index);
+            }
+        }
+        return created == null ? Collections.<String>emptyList() : created;
+    }
+
+    /**
+     * Returns the indices deleted in this event
+    */
+    public List<Index> indicesDeleted() {
+        if (previousState.blocks().hasGlobalBlock(GatewayService.STATE_NOT_RECOVERED_BLOCK)) {
+            // working off of a non-initialized previous state, so use the tombstones for index deletions
+            return indicesDeletedFromTombstones();
+        } else {
+            // examine the diffs in index metadata between the previous and new cluster states to get the deleted indices
+            return indicesDeletedFromClusterState();
+        }
+    }
+
+    /**
+     * Returns <code>true</code> iff the metadata for the cluster has changed between
+    * the previous cluster state and the new cluster state. Note that this is an object
+    * reference equality test, not an equals test.
+    */
+    public boolean metadataChanged() {
+        return state.metadata() != previousState.metadata();
+    }
+
+    /**
+     * Returns a set of custom meta data types when any custom metadata for the cluster has changed
+    * between the previous cluster state and the new cluster state. custom meta data types are
+    * returned iff they have been added, updated or removed between the previous and the current state
+    */
+    public Set<String> changedCustomMetadataSet() {
+        Set<String> result = new HashSet<>();
+        Map<String, Metadata.Custom> currentCustoms = state.metadata().customs();
+        Map<String, Metadata.Custom> previousCustoms = previousState.metadata().customs();
+        if (currentCustoms.equals(previousCustoms) == false) {
+            for (Map.Entry<String, Metadata.Custom> currentCustomMetadata : currentCustoms.entrySet()) {
+                // new custom md added or existing custom md changed
+                if (previousCustoms.containsKey(currentCustomMetadata.getKey()) == false
+                    || currentCustomMetadata.getValue().equals(previousCustoms.get(currentCustomMetadata.getKey())) == false) {
+                    result.add(currentCustomMetadata.getKey());
+                }
+            }
+            // existing custom md deleted
+            for (Map.Entry<String, Metadata.Custom> previousCustomMetadata : previousCustoms.entrySet()) {
+                if (currentCustoms.containsKey(previousCustomMetadata.getKey()) == false) {
+                    result.add(previousCustomMetadata.getKey());
+                }
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Returns <code>true</code> iff the {@link IndexMetadata} for a given index
+    * has changed between the previous cluster state and the new cluster state.
+    * Note that this is an object reference equality test, not an equals test.
+    */
+    public static boolean indexMetadataChanged(IndexMetadata metadata1, IndexMetadata metadata2) {
+        assert metadata1 != null && metadata2 != null;
+        // no need to check on version, since disco modules will make sure to use the
+        // same instance if its a version match
+        return metadata1 != metadata2;
+    }
+
+    /**
+     * Returns <code>true</code> iff the cluster level blocks have changed between cluster states.
+    * Note that this is an object reference equality test, not an equals test.
+    */
+    public boolean blocksChanged() {
+        return state.blocks() != previousState.blocks();
+    }
+
+    /**
+     * Returns <code>true</code> iff the local node is the mater node of the cluster.
+    */
+    public boolean localNodeClusterManager() {
+        return state.nodes().isLocalNodeElectedClusterManager();
+    }
+
+    /**
+     * Returns <code>true</code> iff the local node is the mater node of the cluster.
+    *
+    * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #localNodeClusterManager()}
+    */
+    @Deprecated
+    public boolean localNodeMaster() {
+        return localNodeClusterManager();
+    }
+
+    /**
+     * Returns the {@link org.opensearch.cluster.node.ProtobufDiscoveryNodes.Delta} between
+    * the previous cluster state and the new cluster state.
+    */
+    public ProtobufDiscoveryNodes.Delta nodesDelta() {
+        return this.nodesDelta;
+    }
+
+    /**
+     * Returns <code>true</code> iff nodes have been removed from the cluster since the last cluster state.
+    */
+    public boolean nodesRemoved() {
+        return nodesDelta.removed();
+    }
+
+    /**
+     * Returns <code>true</code> iff nodes have been added from the cluster since the last cluster state.
+    */
+    public boolean nodesAdded() {
+        return nodesDelta.added();
+    }
+
+    /**
+     * Returns <code>true</code> iff nodes have been changed (added or removed) from the cluster since the last cluster state.
+    */
+    public boolean nodesChanged() {
+        return nodesRemoved() || nodesAdded();
+    }
+
+    /**
+     * Determines whether or not the current cluster state represents an entirely
+    * new cluster, either when a node joins a cluster for the first time or when
+    * the node receives a cluster state update from a brand new cluster (different
+    * UUID from the previous cluster), which will happen when a cluster-manager node is
+    * elected that has never been part of the cluster before.
+    */
+    public boolean isNewCluster() {
+        final String prevClusterUUID = previousState.metadata().clusterUUID();
+        final String currClusterUUID = state.metadata().clusterUUID();
+        return prevClusterUUID.equals(currClusterUUID) == false;
+    }
+
+    // Get the deleted indices by comparing the index metadatas in the previous and new cluster states.
+    // If an index exists in the previous cluster state, but not in the new cluster state, it must have been deleted.
+    private List<Index> indicesDeletedFromClusterState() {
+        // If the new cluster state has a new cluster UUID, the likely scenario is that a node was elected cluster-manager
+        // that has had its data directory wiped out, in which case we don't want to delete the indices and lose data;
+        // rather we want to import them as dangling indices instead. So we check here if the cluster UUID differs from the previous
+        // cluster UUID, in which case, we don't want to delete indices that the cluster-manager erroneously believes shouldn't exist.
+        // See test DiscoveryWithServiceDisruptionsIT.testIndicesDeleted()
+        // See discussion on https://github.com/elastic/elasticsearch/pull/9952 and
+        // https://github.com/elastic/elasticsearch/issues/11665
+        if (metadataChanged() == false || isNewCluster()) {
+            return Collections.emptyList();
+        }
+        Set<Index> deleted = null;
+        final Metadata previousMetadata = previousState.metadata();
+        final Metadata currentMetadata = state.metadata();
+
+        for (final IndexMetadata index : previousMetadata.indices().values()) {
+            IndexMetadata current = currentMetadata.index(index.getIndex());
+            if (current == null) {
+                if (deleted == null) {
+                    deleted = new HashSet<>();
+                }
+                deleted.add(index.getIndex());
+            }
+        }
+
+        final IndexGraveyard currentGraveyard = currentMetadata.indexGraveyard();
+        final IndexGraveyard previousGraveyard = previousMetadata.indexGraveyard();
+
+        // Look for new entries in the index graveyard, where there's no corresponding index in the
+        // previous metadata. This indicates that a dangling index has been explicitly deleted, so
+        // each node should make sure to delete any related data.
+        if (currentGraveyard != previousGraveyard) {
+            final IndexGraveyardDiff indexGraveyardDiff = (IndexGraveyardDiff) currentGraveyard.diff(previousGraveyard);
+
+            final List<IndexGraveyard.Tombstone> added = indexGraveyardDiff.getAdded();
+
+            if (added.isEmpty() == false) {
+                if (deleted == null) {
+                    deleted = new HashSet<>();
+                }
+                for (IndexGraveyard.Tombstone tombstone : added) {
+                    deleted.add(tombstone.getIndex());
+                }
+            }
+        }
+
+        return deleted == null ? Collections.<Index>emptyList() : new ArrayList<>(deleted);
+    }
+
+    private List<Index> indicesDeletedFromTombstones() {
+        // We look at the full tombstones list to see which indices need to be deleted. In the case of
+        // a valid previous cluster state, indicesDeletedFromClusterState() will be used to get the deleted
+        // list, so a diff doesn't make sense here. When a node (re)joins the cluster, its possible for it
+        // to re-process the same deletes or process deletes about indices it never knew about. This is not
+        // an issue because there are safeguards in place in the delete store operation in case the index
+        // folder doesn't exist on the file system.
+        List<IndexGraveyard.Tombstone> tombstones = state.metadata().indexGraveyard().getTombstones();
+        return tombstones.stream().map(IndexGraveyard.Tombstone::getIndex).collect(Collectors.toList());
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterName.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterName.java
new file mode 100644
index 0000000000000..a41eed231ef18
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufClusterName.java
@@ -0,0 +1,61 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.cluster;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+
+import java.io.IOException;
+
+/**
+ * Cluster Name
+*
+* @opensearch.internal
+*/
+public class ProtobufClusterName implements ProtobufWriteable {
+
+    public static final Setting<ProtobufClusterName> CLUSTER_NAME_SETTING = new Setting<>("cluster.name", "opensearch", (s) -> {
+        if (s.isEmpty()) {
+            throw new IllegalArgumentException("[cluster.name] must not be empty");
+        }
+        if (s.contains(":")) {
+            throw new IllegalArgumentException("[cluster.name] must not contain ':'");
+        }
+        return new ProtobufClusterName(s);
+    }, Setting.Property.NodeScope);
+
+    public static final ProtobufClusterName DEFAULT = CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY);
+
+    private final String value;
+
+    public ProtobufClusterName(CodedInputStream input) throws IOException {
+        this(input.readString());
+    }
+
+    public ProtobufClusterName(String value) {
+        this.value = value.intern();
+    }
+
+    public String value() {
+        return this.value;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeStringNoTag(value);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java
new file mode 100644
index 0000000000000..85adfd417936d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java
@@ -0,0 +1,803 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.cluster;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import com.carrotsearch.hppc.cursors.ObjectCursor;
+import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
+import org.opensearch.cluster.block.ClusterBlock;
+import org.opensearch.cluster.block.ClusterBlocks;
+import org.opensearch.cluster.coordination.CoordinationMetadata;
+import org.opensearch.cluster.coordination.CoordinationMetadata.VotingConfigExclusion;
+import org.opensearch.cluster.coordination.CoordinationMetadata.VotingConfiguration;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.IndexShardRoutingTable;
+import org.opensearch.cluster.routing.RoutingNode;
+import org.opensearch.cluster.routing.RoutingNodes;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.Strings;
+import org.opensearch.common.UUIDs;
+import org.opensearch.common.collect.ImmutableOpenMap;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufVersionedNamedWriteable;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.discovery.Discovery;
+
+import java.io.IOException;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.StreamSupport;
+
+import static org.opensearch.cluster.coordination.Coordinator.ZEN1_BWC_TERM;
+
+/**
+ * Represents the current state of the cluster.
+* <p>
+* The cluster state object is immutable with the exception of the {@link RoutingNodes} structure, which is
+* built on demand from the {@link RoutingTable}.
+* The cluster state can be updated only on the cluster-manager node. All updates are performed by on a
+* single thread and controlled by the {@link ClusterService}. After every update the
+* {@link Discovery#publish} method publishes a new version of the cluster state to all other nodes in the
+* cluster. The actual publishing mechanism is delegated to the {@link Discovery#publish} method and depends on
+* the type of discovery.
+* <p>
+* The cluster state implements the {@link Diffable} interface in order to support publishing of cluster state
+* differences instead of the entire state on each change. The publishing mechanism should only send differences
+* to a node if this node was present in the previous version of the cluster state. If a node was
+* not present in the previous version of the cluster state, this node is unlikely to have the previous cluster
+* state version and should be sent a complete version. In order to make sure that the differences are applied to the
+* correct version of the cluster state, each cluster state version update generates {@link #stateUUID} that uniquely
+* identifies this version of the state. This uuid is verified by the {@link ClusterStateDiff#apply} method to
+* make sure that the correct diffs are applied. If uuids don’t match, the {@link ClusterStateDiff#apply} method
+* throws the {@link IncompatibleClusterStateVersionException}, which causes the publishing mechanism to send
+* a full version of the cluster state to the node on which this exception was thrown.
+*
+* @opensearch.internal
+*/
+public class ProtobufClusterState implements ToXContentFragment, ProtobufDiffable<ProtobufClusterState> {
+
+    public static final ProtobufClusterState EMPTY_STATE = builder(ProtobufClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+        .build();
+
+    /**
+     * An interface that implementors use when a class requires a client to maybe have a feature.
+    *
+    * @opensearch.internal
+    */
+    public interface FeatureAware {
+
+        /**
+         * An optional feature that is required for the client to have.
+        *
+        * @return an empty optional if no feature is required otherwise a string representing the required feature
+        */
+        default Optional<String> getRequiredFeature() {
+            return Optional.empty();
+        }
+
+        /**
+         * Tests whether the custom should be serialized. The criterion is that
+        * the output stream must be at least the minimum supported version of the custom.
+        * <p>
+        * That is, we only serialize customs to clients than can understand the custom based on the version of the client.
+        *
+        * @param out    the output stream
+        * @param custom the custom to serialize
+        * @param <T>    the type of the custom
+        * @return true if the custom should be serialized and false otherwise
+        */
+        static <T extends ProtobufVersionedNamedWriteable & FeatureAware> boolean shouldSerialize(
+            final CodedOutputStream out,
+            final T custom
+        ) {
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+            return protobufStreamOutput.getVersion().onOrAfter(custom.getMinimalSupportedVersion());
+        }
+
+    }
+
+    /**
+     * Custom cluster state.
+    *
+    * @opensearch.internal
+    */
+    public interface Custom extends ProtobufNamedDiffable<Custom>, ToXContentFragment, FeatureAware {
+
+        /**
+         * Returns <code>true</code> iff this {@link Custom} is private to the cluster and should never be send to a client.
+        * The default is <code>false</code>;
+        */
+        default boolean isPrivate() {
+            return false;
+        }
+
+    }
+
+    private static final ProtobufNamedDiffableValueSerializer<Custom> CUSTOM_VALUE_SERIALIZER = new ProtobufNamedDiffableValueSerializer<>(
+        Custom.class
+    );
+
+    public static final String UNKNOWN_UUID = "_na_";
+
+    public static final long UNKNOWN_VERSION = -1;
+
+    private final long version;
+
+    private final String stateUUID;
+
+    private final RoutingTable routingTable;
+
+    private final ProtobufDiscoveryNodes nodes;
+
+    private final Metadata metadata;
+
+    private final ClusterBlocks blocks;
+
+    private final ImmutableOpenMap<String, Custom> customs;
+
+    private final ProtobufClusterName clusterName;
+
+    private final boolean wasReadFromDiff;
+
+    private final int minimumClusterManagerNodesOnPublishingClusterManager;
+
+    // built on demand
+    private volatile RoutingNodes routingNodes;
+
+    public ProtobufClusterState(long version, String stateUUID, ProtobufClusterState state) {
+        this(
+            state.clusterName,
+            version,
+            stateUUID,
+            state.metadata(),
+            state.routingTable(),
+            state.nodes(),
+            state.blocks(),
+            state.customs(),
+            -1,
+            false
+        );
+    }
+
+    public ProtobufClusterState(
+        ProtobufClusterName clusterName,
+        long version,
+        String stateUUID,
+        Metadata metadata,
+        RoutingTable routingTable,
+        ProtobufDiscoveryNodes nodes,
+        ClusterBlocks blocks,
+        ImmutableOpenMap<String, Custom> customs,
+        int minimumClusterManagerNodesOnPublishingClusterManager,
+        boolean wasReadFromDiff
+    ) {
+        this.version = version;
+        this.stateUUID = stateUUID;
+        this.clusterName = clusterName;
+        this.metadata = metadata;
+        this.routingTable = routingTable;
+        this.nodes = nodes;
+        this.blocks = blocks;
+        this.customs = customs;
+        this.minimumClusterManagerNodesOnPublishingClusterManager = minimumClusterManagerNodesOnPublishingClusterManager;
+        this.wasReadFromDiff = wasReadFromDiff;
+    }
+
+    public long term() {
+        return coordinationMetadata().term();
+    }
+
+    public long version() {
+        return this.version;
+    }
+
+    public long getVersion() {
+        return version();
+    }
+
+    public long getVersionOrMetadataVersion() {
+        // When following a Zen1 cluster-manager, the cluster state version is not guaranteed to increase,
+        // so instead it is preferable to use the metadata version to determine the freshest node.
+        // However when following a Zen2 cluster-manager the cluster state version should be used.
+        return term() == ZEN1_BWC_TERM ? metadata().version() : version();
+    }
+
+    /**
+     * This stateUUID is automatically generated for for each version of cluster state. It is used to make sure that
+    * we are applying diffs to the right previous state.
+    */
+    public String stateUUID() {
+        return this.stateUUID;
+    }
+
+    public ProtobufDiscoveryNodes nodes() {
+        return this.nodes;
+    }
+
+    public ProtobufDiscoveryNodes getNodes() {
+        return nodes();
+    }
+
+    public Metadata metadata() {
+        return this.metadata;
+    }
+
+    public Metadata getMetadata() {
+        return metadata();
+    }
+
+    public CoordinationMetadata coordinationMetadata() {
+        return metadata.coordinationMetadata();
+    }
+
+    public RoutingTable routingTable() {
+        return routingTable;
+    }
+
+    public RoutingTable getRoutingTable() {
+        return routingTable();
+    }
+
+    public ClusterBlocks blocks() {
+        return this.blocks;
+    }
+
+    public ClusterBlocks getBlocks() {
+        return blocks;
+    }
+
+    public ImmutableOpenMap<String, Custom> customs() {
+        return this.customs;
+    }
+
+    public ImmutableOpenMap<String, Custom> getCustoms() {
+        return this.customs;
+    }
+
+    public <T extends Custom> T custom(String type) {
+        return (T) customs.get(type);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T extends Custom> T custom(String type, T defaultValue) {
+        return (T) customs.getOrDefault(type, defaultValue);
+    }
+
+    public ProtobufClusterName getClusterName() {
+        return this.clusterName;
+    }
+
+    public VotingConfiguration getLastAcceptedConfiguration() {
+        return coordinationMetadata().getLastAcceptedConfiguration();
+    }
+
+    public VotingConfiguration getLastCommittedConfiguration() {
+        return coordinationMetadata().getLastCommittedConfiguration();
+    }
+
+    public Set<VotingConfigExclusion> getVotingConfigExclusions() {
+        return coordinationMetadata().getVotingConfigExclusions();
+    }
+
+    /**
+     * Returns a built (on demand) routing nodes view of the routing table.
+    */
+    public RoutingNodes getRoutingNodes() {
+        if (routingNodes != null) {
+            return routingNodes;
+        }
+        routingNodes = new RoutingNodes(this);
+        return routingNodes;
+    }
+
+    /**
+     * Metrics for cluster state.
+    *
+    * @opensearch.internal
+    */
+    public enum Metric {
+        VERSION("version"),
+
+        /**
+         * @deprecated As of 2.0, because promoting inclusive language, replaced by {@link #CLUSTER_MANAGER_NODE}
+        */
+        @Deprecated
+        MASTER_NODE("master_node"),
+        CLUSTER_MANAGER_NODE("cluster_manager_node"),
+        BLOCKS("blocks"),
+        NODES("nodes"),
+        METADATA("metadata"),
+        ROUTING_TABLE("routing_table"),
+        ROUTING_NODES("routing_nodes"),
+        CUSTOMS("customs");
+
+        private static Map<String, Metric> valueToEnum;
+
+        static {
+            valueToEnum = new HashMap<>();
+            for (Metric metric : Metric.values()) {
+                valueToEnum.put(metric.value, metric);
+            }
+        }
+
+        private final String value;
+
+        Metric(String value) {
+            this.value = value;
+        }
+
+        public static EnumSet<Metric> parseString(String param, boolean ignoreUnknown) {
+            String[] metrics = Strings.splitStringByCommaToArray(param);
+            EnumSet<Metric> result = EnumSet.noneOf(Metric.class);
+            for (String metric : metrics) {
+                if ("_all".equals(metric)) {
+                    result = EnumSet.allOf(Metric.class);
+                    break;
+                }
+                Metric m = valueToEnum.get(metric);
+                if (m == null) {
+                    if (!ignoreUnknown) {
+                        throw new IllegalArgumentException("Unknown metric [" + metric + "]");
+                    }
+                } else {
+                    result.add(m);
+                }
+            }
+            return result;
+        }
+
+        @Override
+        public String toString() {
+            return value;
+        }
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        EnumSet<Metric> metrics = Metric.parseString(params.param("metric", "_all"), true);
+
+        // always provide the cluster_uuid as part of the top-level response (also part of the metadata response)
+        builder.field("cluster_uuid", metadata().clusterUUID());
+
+        if (metrics.contains(Metric.VERSION)) {
+            builder.field("version", version);
+            builder.field("state_uuid", stateUUID);
+        }
+
+        if (metrics.contains(Metric.MASTER_NODE)) {
+            builder.field("master_node", nodes().getClusterManagerNodeId());
+        }
+
+        // Value of the field is identical with the above, and aims to replace the above field.
+        if (metrics.contains(Metric.CLUSTER_MANAGER_NODE)) {
+            builder.field("cluster_manager_node", nodes().getClusterManagerNodeId());
+        }
+
+        if (metrics.contains(Metric.BLOCKS)) {
+            builder.startObject("blocks");
+
+            if (!blocks().global().isEmpty()) {
+                builder.startObject("global");
+                for (ClusterBlock block : blocks().global()) {
+                    block.toXContent(builder, params);
+                }
+                builder.endObject();
+            }
+
+            if (!blocks().indices().isEmpty()) {
+                builder.startObject("indices");
+                for (ObjectObjectCursor<String, Set<ClusterBlock>> entry : blocks().indices()) {
+                    builder.startObject(entry.key);
+                    for (ClusterBlock block : entry.value) {
+                        block.toXContent(builder, params);
+                    }
+                    builder.endObject();
+                }
+                builder.endObject();
+            }
+
+            builder.endObject();
+        }
+
+        // nodes
+        if (metrics.contains(Metric.NODES)) {
+            builder.startObject("nodes");
+            for (DiscoveryNode node : nodes) {
+                node.toXContent(builder, params);
+            }
+            builder.endObject();
+        }
+
+        // meta data
+        if (metrics.contains(Metric.METADATA)) {
+            metadata.toXContent(builder, params);
+        }
+
+        // routing table
+        if (metrics.contains(Metric.ROUTING_TABLE)) {
+            builder.startObject("routing_table");
+            builder.startObject("indices");
+            for (IndexRoutingTable indexRoutingTable : routingTable()) {
+                builder.startObject(indexRoutingTable.getIndex().getName());
+                builder.startObject("shards");
+                for (IndexShardRoutingTable indexShardRoutingTable : indexRoutingTable) {
+                    builder.startArray(Integer.toString(indexShardRoutingTable.shardId().id()));
+                    for (ShardRouting shardRouting : indexShardRoutingTable) {
+                        shardRouting.toXContent(builder, params);
+                    }
+                    builder.endArray();
+                }
+                builder.endObject();
+                builder.endObject();
+            }
+            builder.endObject();
+            builder.endObject();
+        }
+
+        // routing nodes
+        if (metrics.contains(Metric.ROUTING_NODES)) {
+            builder.startObject("routing_nodes");
+            builder.startArray("unassigned");
+            for (ShardRouting shardRouting : getRoutingNodes().unassigned()) {
+                shardRouting.toXContent(builder, params);
+            }
+            builder.endArray();
+
+            builder.startObject("nodes");
+            for (RoutingNode routingNode : getRoutingNodes()) {
+                builder.startArray(routingNode.nodeId() == null ? "null" : routingNode.nodeId());
+                for (ShardRouting shardRouting : routingNode) {
+                    shardRouting.toXContent(builder, params);
+                }
+                builder.endArray();
+            }
+            builder.endObject();
+
+            builder.endObject();
+        }
+        if (metrics.contains(Metric.CUSTOMS)) {
+            for (ObjectObjectCursor<String, Custom> cursor : customs) {
+                builder.startObject(cursor.key);
+                cursor.value.toXContent(builder, params);
+                builder.endObject();
+            }
+        }
+
+        return builder;
+    }
+
+    public static Builder builder(ProtobufClusterName clusterName) {
+        return new Builder(clusterName);
+    }
+
+    public static Builder builder(ProtobufClusterState state) {
+        return new Builder(state);
+    }
+
+    /**
+     * Builder for cluster state.
+    *
+    * @opensearch.internal
+    */
+    public static class Builder {
+
+        private final ProtobufClusterName clusterName;
+        private long version = 0;
+        private String uuid = UNKNOWN_UUID;
+        private Metadata metadata = Metadata.EMPTY_METADATA;
+        private RoutingTable routingTable = RoutingTable.EMPTY_ROUTING_TABLE;
+        private ProtobufDiscoveryNodes nodes = ProtobufDiscoveryNodes.EMPTY_NODES;
+        private ClusterBlocks blocks = ClusterBlocks.EMPTY_CLUSTER_BLOCK;
+        private final ImmutableOpenMap.Builder<String, Custom> customs;
+        private boolean fromDiff;
+        private int minimumClusterManagerNodesOnPublishingClusterManager = -1;
+
+        public Builder(ProtobufClusterState state) {
+            this.clusterName = state.clusterName;
+            this.version = state.version();
+            this.uuid = state.stateUUID();
+            this.nodes = state.nodes();
+            this.routingTable = state.routingTable();
+            this.metadata = state.metadata();
+            this.blocks = state.blocks();
+            this.customs = ImmutableOpenMap.builder(state.customs());
+            this.minimumClusterManagerNodesOnPublishingClusterManager = state.minimumClusterManagerNodesOnPublishingClusterManager;
+            this.fromDiff = false;
+        }
+
+        public Builder(ProtobufClusterName clusterName) {
+            customs = ImmutableOpenMap.builder();
+            this.clusterName = clusterName;
+        }
+
+        public Builder nodes(ProtobufDiscoveryNodes.Builder nodesBuilder) {
+            return nodes(nodesBuilder.build());
+        }
+
+        public Builder nodes(ProtobufDiscoveryNodes nodes) {
+            this.nodes = nodes;
+            return this;
+        }
+
+        public ProtobufDiscoveryNodes nodes() {
+            return nodes;
+        }
+
+        public Builder routingTable(RoutingTable routingTable) {
+            this.routingTable = routingTable;
+            return this;
+        }
+
+        public Builder metadata(Metadata.Builder metadataBuilder) {
+            return metadata(metadataBuilder.build());
+        }
+
+        public Builder metadata(Metadata metadata) {
+            this.metadata = metadata;
+            return this;
+        }
+
+        public Builder blocks(ClusterBlocks.Builder blocksBuilder) {
+            return blocks(blocksBuilder.build());
+        }
+
+        public Builder blocks(ClusterBlocks blocks) {
+            this.blocks = blocks;
+            return this;
+        }
+
+        public Builder version(long version) {
+            this.version = version;
+            return this;
+        }
+
+        public Builder incrementVersion() {
+            this.version = version + 1;
+            this.uuid = UNKNOWN_UUID;
+            return this;
+        }
+
+        public Builder stateUUID(String uuid) {
+            this.uuid = uuid;
+            return this;
+        }
+
+        public Builder minimumClusterManagerNodesOnPublishingClusterManager(int minimumClusterManagerNodesOnPublishingClusterManager) {
+            this.minimumClusterManagerNodesOnPublishingClusterManager = minimumClusterManagerNodesOnPublishingClusterManager;
+            return this;
+        }
+
+        public Builder putCustom(String type, Custom custom) {
+            customs.put(type, Objects.requireNonNull(custom, type));
+            return this;
+        }
+
+        public Builder removeCustom(String type) {
+            customs.remove(type);
+            return this;
+        }
+
+        public Builder customs(ImmutableOpenMap<String, Custom> customs) {
+            StreamSupport.stream(customs.spliterator(), false).forEach(cursor -> Objects.requireNonNull(cursor.value, cursor.key));
+            this.customs.putAll(customs);
+            return this;
+        }
+
+        public Builder fromDiff(boolean fromDiff) {
+            this.fromDiff = fromDiff;
+            return this;
+        }
+
+        public ProtobufClusterState build() {
+            if (UNKNOWN_UUID.equals(uuid)) {
+                uuid = UUIDs.randomBase64UUID();
+            }
+            return new ProtobufClusterState(
+                clusterName,
+                version,
+                uuid,
+                metadata,
+                routingTable,
+                nodes,
+                blocks,
+                customs.build(),
+                minimumClusterManagerNodesOnPublishingClusterManager,
+                fromDiff
+            );
+        }
+
+        // public static byte[] toBytes(ProtobufClusterState state) throws IOException {
+        // BytesStreamOutput os = new BytesStreamOutput();
+        // state.writeTo(os);
+        // return BytesReference.toBytes(os.bytes());
+        // }
+
+        // /**
+        // * @param data input bytes
+        // * @param localNode used to set the local node in the cluster state.
+        // */
+        // public static ProtobufClusterState fromBytes(byte[] data, DiscoveryNode localNode, NamedWriteableRegistry registry) throws
+        // IOException {
+        // StreamInput in = new NamedWriteableAwareStreamInput(StreamInput.wrap(data), registry);
+        // return readFrom(in, localNode);
+
+        // }
+    }
+
+    @Override
+    public ProtobufDiff<ProtobufClusterState> diff(ProtobufClusterState previousState) {
+        return new ClusterStateDiff(previousState, this);
+    }
+
+    public static ProtobufDiff<ProtobufClusterState> readDiffFrom(CodedInputStream in, DiscoveryNode localNode) throws IOException {
+        return new ClusterStateDiff(in, localNode);
+    }
+
+    public static ProtobufClusterState readFrom(CodedInputStream in, DiscoveryNode localNode) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        ProtobufClusterName clusterName = new ProtobufClusterName(in);
+        Builder builder = new Builder(clusterName);
+        builder.version = in.readInt64();
+        builder.uuid = in.readString();
+        // builder.metadata = Metadata.readFrom(in);
+        // builder.routingTable = RoutingTable.readFrom(in);
+        // builder.nodes = ProtobufDiscoveryNodes.readFrom(in, localNode);
+        // builder.blocks = ClusterBlocks.readFrom(in);
+        int customSize = in.readInt32();
+        for (int i = 0; i < customSize; i++) {
+            Custom customIndexMetadata = protobufStreamInput.readNamedWriteable(Custom.class);
+            builder.putCustom(customIndexMetadata.getWriteableName(), customIndexMetadata);
+        }
+        builder.minimumClusterManagerNodesOnPublishingClusterManager = in.readInt32();
+        return builder.build();
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        clusterName.writeTo(out);
+        out.writeInt64NoTag(version);
+        out.writeStringNoTag(stateUUID);
+        // metadata.writeTo(out);
+        // routingTable.writeTo(out);
+        // nodes.writeTo(out);
+        // blocks.writeTo(out);
+        // filter out custom states not supported by the other node
+        int numberOfCustoms = 0;
+        for (final ObjectCursor<Custom> cursor : customs.values()) {
+            if (FeatureAware.shouldSerialize(out, cursor.value)) {
+                numberOfCustoms++;
+            }
+        }
+        out.writeInt32NoTag(numberOfCustoms);
+        for (final ObjectCursor<Custom> cursor : customs.values()) {
+            if (FeatureAware.shouldSerialize(out, cursor.value)) {
+                protobufStreamOutput.writeNamedWriteable(cursor.value, out);
+            }
+        }
+        out.writeInt32NoTag(minimumClusterManagerNodesOnPublishingClusterManager);
+    }
+
+    /**
+     * The cluster state diff.
+    *
+    * @opensearch.internal
+    */
+    private static class ClusterStateDiff implements ProtobufDiff<ProtobufClusterState> {
+
+        private final long toVersion;
+
+        private final String fromUuid;
+
+        private final String toUuid;
+
+        private final ProtobufClusterName clusterName;
+
+        private final ProtobufDiff<RoutingTable> routingTable;
+
+        private final ProtobufDiff<ProtobufDiscoveryNodes> nodes;
+
+        private final ProtobufDiff<Metadata> metadata;
+
+        private final ProtobufDiff<ClusterBlocks> blocks;
+
+        private final ProtobufDiff<ImmutableOpenMap<String, Custom>> customs;
+
+        private final int minimumClusterManagerNodesOnPublishingClusterManager;
+
+        ClusterStateDiff(ProtobufClusterState before, ProtobufClusterState after) {
+            fromUuid = before.stateUUID;
+            toUuid = after.stateUUID;
+            toVersion = after.version;
+            clusterName = after.clusterName;
+            routingTable = null;
+            nodes = null;
+            metadata = null;
+            blocks = null;
+            customs = ProtobufDiffableUtils.diff(
+                before.customs,
+                after.customs,
+                ProtobufDiffableUtils.getStringKeySerializer(),
+                CUSTOM_VALUE_SERIALIZER
+            );
+            minimumClusterManagerNodesOnPublishingClusterManager = after.minimumClusterManagerNodesOnPublishingClusterManager;
+        }
+
+        ClusterStateDiff(CodedInputStream in, DiscoveryNode localNode) throws IOException {
+            clusterName = new ProtobufClusterName(in);
+            fromUuid = in.readString();
+            toUuid = in.readString();
+            toVersion = in.readInt64();
+            routingTable = null;
+            nodes = null;
+            metadata = null;
+            blocks = null;
+            customs = ProtobufDiffableUtils.readImmutableOpenMapDiff(
+                in,
+                ProtobufDiffableUtils.getStringKeySerializer(),
+                CUSTOM_VALUE_SERIALIZER
+            );
+            minimumClusterManagerNodesOnPublishingClusterManager = in.readInt32();
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            clusterName.writeTo(out);
+            out.writeStringNoTag(fromUuid);
+            out.writeStringNoTag(toUuid);
+            out.writeInt64NoTag(toVersion);
+            // routingTable.writeTo(out);
+            // nodes.writeTo(out);
+            // metadata.writeTo(out);
+            // blocks.writeTo(out);
+            // customs.writeTo(out);
+            // out.writeVInt(minimumClusterManagerNodesOnPublishingClusterManager);
+        }
+
+        @Override
+        public ProtobufClusterState apply(ProtobufClusterState state) {
+            Builder builder = new Builder(clusterName);
+            if (toUuid.equals(state.stateUUID)) {
+                // no need to read the rest - cluster state didn't change
+                return state;
+            }
+            if (fromUuid.equals(state.stateUUID) == false) {
+                throw new IncompatibleClusterStateVersionException(state.version, state.stateUUID, toVersion, fromUuid);
+            }
+            builder.stateUUID(toUuid);
+            builder.version(toVersion);
+            builder.routingTable(routingTable.apply(state.routingTable));
+            builder.nodes(nodes.apply(state.nodes));
+            builder.metadata(metadata.apply(state.metadata));
+            builder.blocks(blocks.apply(state.blocks));
+            builder.customs(customs.apply(state.customs));
+            builder.minimumClusterManagerNodesOnPublishingClusterManager(minimumClusterManagerNodesOnPublishingClusterManager);
+            builder.fromDiff(true);
+            return builder.build();
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateApplier.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateApplier.java
new file mode 100644
index 0000000000000..3169688ba9b3e
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateApplier.java
@@ -0,0 +1,29 @@
+/*
+* 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.
+*/
+
+package org.opensearch.cluster;
+
+import org.opensearch.cluster.service.ClusterService;
+
+/**
+ * A component that is in charge of applying an incoming cluster state to the node internal data structures.
+* The single apply method is called before the cluster state becomes visible via {@link ClusterService#state()}.
+*
+* @opensearch.internal
+*/
+public interface ProtobufClusterStateApplier {
+
+    /**
+     * Called when a new cluster state ({@link ProtobufClusterChangedEvent#state()} needs to be applied. The cluster state to be applied is already
+    * committed when this method is called, so an applier must therefore be prepared to deal with any state it receives without throwing
+    * an exception. Throwing an exception from an applier is very bad because it will stop the application of this state before it has
+    * reached all the other appliers, and will likely result in another attempt to apply the same (or very similar) cluster state which
+    * might continue until this node is removed from the cluster.
+    */
+    void applyClusterState(ProtobufClusterChangedEvent event);
+}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufDiff.java b/server/src/main/java/org/opensearch/cluster/ProtobufDiff.java
new file mode 100644
index 0000000000000..9d281ff10be04
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufDiff.java
@@ -0,0 +1,29 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.cluster;
+
+import org.opensearch.common.io.stream.ProtobufWriteable;
+
+/**
+ * Represents difference between states of cluster state parts
+*
+* @opensearch.internal
+*/
+public interface ProtobufDiff<T> extends ProtobufWriteable {
+
+    /**
+     * Applies difference to the specified part and returns the resulted part
+    */
+    T apply(T part);
+}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java b/server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java
new file mode 100644
index 0000000000000..80adeb739fbec
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java
@@ -0,0 +1,30 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.cluster;
+
+import org.opensearch.common.io.stream.ProtobufWriteable;
+
+/**
+ * Cluster state part, changes in which can be serialized
+*
+* @opensearch.internal
+*/
+public interface ProtobufDiffable<T> extends ProtobufWriteable {
+
+    /**
+     * Returns serializable object representing differences between this and previousState
+    */
+    ProtobufDiff<T> diff(T previousState);
+
+}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufDiffableUtils.java b/server/src/main/java/org/opensearch/cluster/ProtobufDiffableUtils.java
new file mode 100644
index 0000000000000..52f4635c6f2e1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufDiffableUtils.java
@@ -0,0 +1,812 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.cluster;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import com.carrotsearch.hppc.cursors.IntCursor;
+import com.carrotsearch.hppc.cursors.IntObjectCursor;
+import com.carrotsearch.hppc.cursors.ObjectCursor;
+import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
+import org.opensearch.Version;
+import org.opensearch.common.collect.ImmutableOpenIntMap;
+import org.opensearch.common.collect.ImmutableOpenMap;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Utility class for a diffable
+*
+* @opensearch.internal
+*/
+public final class ProtobufDiffableUtils {
+    private ProtobufDiffableUtils() {}
+
+    /**
+     * Returns a map key serializer for String keys
+    */
+    public static KeySerializer<String> getStringKeySerializer() {
+        return StringKeySerializer.INSTANCE;
+    }
+
+    /**
+     * Returns a map key serializer for Integer keys. Encodes as Int.
+    */
+    public static KeySerializer<Integer> getIntKeySerializer() {
+        return IntKeySerializer.INSTANCE;
+    }
+
+    /**
+     * Returns a map key serializer for Integer keys. Encodes as VInt.
+    */
+    public static KeySerializer<Integer> getVIntKeySerializer() {
+        return VIntKeySerializer.INSTANCE;
+    }
+
+    /**
+     * Calculates diff between two ImmutableOpenMaps of Diffable objects
+    */
+    public static <K, T extends ProtobufDiffable<T>> MapDiff<K, T, ImmutableOpenMap<K, T>> diff(
+        ImmutableOpenMap<K, T> before,
+        ImmutableOpenMap<K, T> after,
+        KeySerializer<K> keySerializer
+    ) {
+        assert after != null && before != null;
+        return new ImmutableOpenMapDiff<>(before, after, keySerializer, DiffableValueSerializer.getWriteOnlyInstance());
+    }
+
+    /**
+     * Calculates diff between two ImmutableOpenMaps of non-diffable objects
+    */
+    public static <K, T> MapDiff<K, T, ImmutableOpenMap<K, T>> diff(
+        ImmutableOpenMap<K, T> before,
+        ImmutableOpenMap<K, T> after,
+        KeySerializer<K> keySerializer,
+        ValueSerializer<K, T> valueSerializer
+    ) {
+        assert after != null && before != null;
+        return new ImmutableOpenMapDiff<>(before, after, keySerializer, valueSerializer);
+    }
+
+    /**
+     * Calculates diff between two ImmutableOpenIntMaps of Diffable objects
+    */
+    public static <T extends ProtobufDiffable<T>> MapDiff<Integer, T, ImmutableOpenIntMap<T>> diff(
+        ImmutableOpenIntMap<T> before,
+        ImmutableOpenIntMap<T> after,
+        KeySerializer<Integer> keySerializer
+    ) {
+        assert after != null && before != null;
+        return new ImmutableOpenIntMapDiff<>(before, after, keySerializer, DiffableValueSerializer.getWriteOnlyInstance());
+    }
+
+    /**
+     * Calculates diff between two ImmutableOpenIntMaps of non-diffable objects
+    */
+    public static <T> MapDiff<Integer, T, ImmutableOpenIntMap<T>> diff(
+        ImmutableOpenIntMap<T> before,
+        ImmutableOpenIntMap<T> after,
+        KeySerializer<Integer> keySerializer,
+        ValueSerializer<Integer, T> valueSerializer
+    ) {
+        assert after != null && before != null;
+        return new ImmutableOpenIntMapDiff<>(before, after, keySerializer, valueSerializer);
+    }
+
+    /**
+     * Calculates diff between two Maps of Diffable objects.
+    */
+    public static <K, T extends ProtobufDiffable<T>> MapDiff<K, T, Map<K, T>> diff(
+        Map<K, T> before,
+        Map<K, T> after,
+        KeySerializer<K> keySerializer
+    ) {
+        assert after != null && before != null;
+        return new JdkMapDiff<>(before, after, keySerializer, DiffableValueSerializer.getWriteOnlyInstance());
+    }
+
+    /**
+     * Calculates diff between two Maps of non-diffable objects
+    */
+    public static <K, T> MapDiff<K, T, Map<K, T>> diff(
+        Map<K, T> before,
+        Map<K, T> after,
+        KeySerializer<K> keySerializer,
+        ValueSerializer<K, T> valueSerializer
+    ) {
+        assert after != null && before != null;
+        return new JdkMapDiff<>(before, after, keySerializer, valueSerializer);
+    }
+
+    /**
+     * Loads an object that represents difference between two ImmutableOpenMaps
+    */
+    public static <K, T> MapDiff<K, T, ImmutableOpenMap<K, T>> readImmutableOpenMapDiff(
+        CodedInputStream in,
+        KeySerializer<K> keySerializer,
+        ValueSerializer<K, T> valueSerializer
+    ) throws IOException {
+        return new ImmutableOpenMapDiff<>(in, keySerializer, valueSerializer);
+    }
+
+    /**
+     * Loads an object that represents difference between two ImmutableOpenMaps
+    */
+    public static <T> MapDiff<Integer, T, ImmutableOpenIntMap<T>> readImmutableOpenIntMapDiff(
+        CodedInputStream in,
+        KeySerializer<Integer> keySerializer,
+        ValueSerializer<Integer, T> valueSerializer
+    ) throws IOException {
+        return new ImmutableOpenIntMapDiff<>(in, keySerializer, valueSerializer);
+    }
+
+    /**
+     * Loads an object that represents difference between two Maps of Diffable objects
+    */
+    public static <K, T> MapDiff<K, T, Map<K, T>> readJdkMapDiff(
+        CodedInputStream in,
+        KeySerializer<K> keySerializer,
+        ValueSerializer<K, T> valueSerializer
+    ) throws IOException {
+        return new JdkMapDiff<>(in, keySerializer, valueSerializer);
+    }
+
+    /**
+     * Loads an object that represents difference between two ImmutableOpenMaps of Diffable objects using Diffable proto object
+    */
+    public static <K, T extends ProtobufDiffable<T>> MapDiff<K, T, ImmutableOpenMap<K, T>> readImmutableOpenMapDiff(
+        CodedInputStream in,
+        KeySerializer<K> keySerializer,
+        DiffableValueReader<K, T> diffableValueReader
+    ) throws IOException {
+        return new ImmutableOpenMapDiff<>(in, keySerializer, diffableValueReader);
+    }
+
+    /**
+     * Loads an object that represents difference between two ImmutableOpenIntMaps of Diffable objects using Diffable proto object
+    */
+    public static <T extends ProtobufDiffable<T>> MapDiff<Integer, T, ImmutableOpenIntMap<T>> readImmutableOpenIntMapDiff(
+        CodedInputStream in,
+        KeySerializer<Integer> keySerializer,
+        ProtobufWriteable.Reader<T> reader,
+        ProtobufWriteable.Reader<ProtobufDiff<T>> diffReader
+    ) throws IOException {
+        return new ImmutableOpenIntMapDiff<>(in, keySerializer, new DiffableValueReader<>(reader, diffReader));
+    }
+
+    /**
+     * Loads an object that represents difference between two Maps of Diffable objects using Diffable proto object
+    */
+    public static <K, T extends ProtobufDiffable<T>> MapDiff<K, T, Map<K, T>> readJdkMapDiff(
+        CodedInputStream in,
+        KeySerializer<K> keySerializer,
+        ProtobufWriteable.Reader<T> reader,
+        ProtobufWriteable.Reader<ProtobufDiff<T>> diffReader
+    ) throws IOException {
+        return new JdkMapDiff<>(in, keySerializer, new DiffableValueReader<>(reader, diffReader));
+    }
+
+    /**
+     * Represents differences between two Maps of (possibly diffable) objects.
+    *
+    * @param <T> the diffable object
+    *
+    * @opensearch.internal
+    */
+    private static class JdkMapDiff<K, T> extends MapDiff<K, T, Map<K, T>> {
+
+        protected JdkMapDiff(CodedInputStream in, KeySerializer<K> keySerializer, ValueSerializer<K, T> valueSerializer)
+            throws IOException {
+            super(in, keySerializer, valueSerializer);
+        }
+
+        JdkMapDiff(Map<K, T> before, Map<K, T> after, KeySerializer<K> keySerializer, ValueSerializer<K, T> valueSerializer) {
+            super(keySerializer, valueSerializer);
+            assert after != null && before != null;
+
+            for (K key : before.keySet()) {
+                if (!after.containsKey(key)) {
+                    deletes.add(key);
+                }
+            }
+
+            for (Map.Entry<K, T> partIter : after.entrySet()) {
+                T beforePart = before.get(partIter.getKey());
+                if (beforePart == null) {
+                    upserts.put(partIter.getKey(), partIter.getValue());
+                } else if (partIter.getValue().equals(beforePart) == false) {
+                    if (valueSerializer.supportsDiffableValues()) {
+                        diffs.put(partIter.getKey(), valueSerializer.diff(partIter.getValue(), beforePart));
+                    } else {
+                        upserts.put(partIter.getKey(), partIter.getValue());
+                    }
+                }
+            }
+        }
+
+        @Override
+        public Map<K, T> apply(Map<K, T> map) {
+            Map<K, T> builder = new HashMap<>(map);
+
+            for (K part : deletes) {
+                builder.remove(part);
+            }
+
+            for (Map.Entry<K, ProtobufDiff<T>> diff : diffs.entrySet()) {
+                builder.put(diff.getKey(), diff.getValue().apply(builder.get(diff.getKey())));
+            }
+
+            for (Map.Entry<K, T> upsert : upserts.entrySet()) {
+                builder.put(upsert.getKey(), upsert.getValue());
+            }
+            return builder;
+        }
+    }
+
+    /**
+     * Represents differences between two ImmutableOpenMap of (possibly diffable) objects
+    *
+    * @param <T> the object type
+    *
+    * @opensearch.internal
+    */
+    public static class ImmutableOpenMapDiff<K, T> extends MapDiff<K, T, ImmutableOpenMap<K, T>> {
+
+        protected ImmutableOpenMapDiff(CodedInputStream in, KeySerializer<K> keySerializer, ValueSerializer<K, T> valueSerializer)
+            throws IOException {
+            super(in, keySerializer, valueSerializer);
+        }
+
+        private ImmutableOpenMapDiff(
+            KeySerializer<K> keySerializer,
+            ValueSerializer<K, T> valueSerializer,
+            List<K> deletes,
+            Map<K, ProtobufDiff<T>> diffs,
+            Map<K, T> upserts
+        ) {
+            super(keySerializer, valueSerializer, deletes, diffs, upserts);
+        }
+
+        public ImmutableOpenMapDiff(
+            ImmutableOpenMap<K, T> before,
+            ImmutableOpenMap<K, T> after,
+            KeySerializer<K> keySerializer,
+            ValueSerializer<K, T> valueSerializer
+        ) {
+            super(keySerializer, valueSerializer);
+            assert after != null && before != null;
+
+            for (ObjectCursor<K> key : before.keys()) {
+                if (!after.containsKey(key.value)) {
+                    deletes.add(key.value);
+                }
+            }
+
+            for (ObjectObjectCursor<K, T> partIter : after) {
+                T beforePart = before.get(partIter.key);
+                if (beforePart == null) {
+                    upserts.put(partIter.key, partIter.value);
+                } else if (partIter.value.equals(beforePart) == false) {
+                    if (valueSerializer.supportsDiffableValues()) {
+                        diffs.put(partIter.key, valueSerializer.diff(partIter.value, beforePart));
+                    } else {
+                        upserts.put(partIter.key, partIter.value);
+                    }
+                }
+            }
+        }
+
+        /**
+         * Returns a new diff map with the given key removed, does not modify the invoking instance.
+        * If the key does not exist in the diff map, the same instance is returned.
+        */
+        public ImmutableOpenMapDiff<K, T> withKeyRemoved(K key) {
+            if (this.diffs.containsKey(key) == false && this.upserts.containsKey(key) == false) {
+                return this;
+            }
+            Map<K, ProtobufDiff<T>> newDiffs = new HashMap<>(this.diffs);
+            newDiffs.remove(key);
+            Map<K, T> newUpserts = new HashMap<>(this.upserts);
+            newUpserts.remove(key);
+            return new ImmutableOpenMapDiff<>(this.keySerializer, this.valueSerializer, this.deletes, newDiffs, newUpserts);
+        }
+
+        @Override
+        public ImmutableOpenMap<K, T> apply(ImmutableOpenMap<K, T> map) {
+            ImmutableOpenMap.Builder<K, T> builder = ImmutableOpenMap.builder();
+            builder.putAll(map);
+
+            for (K part : deletes) {
+                builder.remove(part);
+            }
+
+            for (Map.Entry<K, ProtobufDiff<T>> diff : diffs.entrySet()) {
+                builder.put(diff.getKey(), diff.getValue().apply(builder.get(diff.getKey())));
+            }
+
+            for (Map.Entry<K, T> upsert : upserts.entrySet()) {
+                builder.put(upsert.getKey(), upsert.getValue());
+            }
+            return builder.build();
+        }
+    }
+
+    /**
+     * Represents differences between two ImmutableOpenIntMap of (possibly diffable) objects
+    *
+    * @param <T> the object type
+    *
+    * @opensearch.internal
+    */
+    private static class ImmutableOpenIntMapDiff<T> extends MapDiff<Integer, T, ImmutableOpenIntMap<T>> {
+
+        protected ImmutableOpenIntMapDiff(
+            CodedInputStream in,
+            KeySerializer<Integer> keySerializer,
+            ValueSerializer<Integer, T> valueSerializer
+        ) throws IOException {
+            super(in, keySerializer, valueSerializer);
+        }
+
+        ImmutableOpenIntMapDiff(
+            ImmutableOpenIntMap<T> before,
+            ImmutableOpenIntMap<T> after,
+            KeySerializer<Integer> keySerializer,
+            ValueSerializer<Integer, T> valueSerializer
+        ) {
+            super(keySerializer, valueSerializer);
+            assert after != null && before != null;
+
+            for (IntCursor key : before.keys()) {
+                if (!after.containsKey(key.value)) {
+                    deletes.add(key.value);
+                }
+            }
+
+            for (IntObjectCursor<T> partIter : after) {
+                T beforePart = before.get(partIter.key);
+                if (beforePart == null) {
+                    upserts.put(partIter.key, partIter.value);
+                } else if (partIter.value.equals(beforePart) == false) {
+                    if (valueSerializer.supportsDiffableValues()) {
+                        diffs.put(partIter.key, valueSerializer.diff(partIter.value, beforePart));
+                    } else {
+                        upserts.put(partIter.key, partIter.value);
+                    }
+                }
+            }
+        }
+
+        @Override
+        public ImmutableOpenIntMap<T> apply(ImmutableOpenIntMap<T> map) {
+            ImmutableOpenIntMap.Builder<T> builder = ImmutableOpenIntMap.builder();
+            builder.putAll(map);
+
+            for (Integer part : deletes) {
+                builder.remove(part);
+            }
+
+            for (Map.Entry<Integer, ProtobufDiff<T>> diff : diffs.entrySet()) {
+                builder.put(diff.getKey(), diff.getValue().apply(builder.get(diff.getKey())));
+            }
+
+            for (Map.Entry<Integer, T> upsert : upserts.entrySet()) {
+                builder.put(upsert.getKey(), upsert.getValue());
+            }
+            return builder.build();
+        }
+    }
+
+    /**
+     * Represents differences between two maps of objects and is used as base class for different map implementations.
+    *
+    * Implements serialization. How differences are applied is left to subclasses.
+    *
+    * @param <K> the type of map keys
+    * @param <T> the type of map values
+    * @param <M> the map implementation type
+    *
+    * @opensearch.internal
+    */
+    public abstract static class MapDiff<K, T, M> implements ProtobufDiff<M> {
+
+        protected final List<K> deletes;
+        protected final Map<K, ProtobufDiff<T>> diffs; // incremental updates
+        protected final Map<K, T> upserts; // additions or full updates
+        protected final KeySerializer<K> keySerializer;
+        protected final ValueSerializer<K, T> valueSerializer;
+
+        protected MapDiff(KeySerializer<K> keySerializer, ValueSerializer<K, T> valueSerializer) {
+            this.keySerializer = keySerializer;
+            this.valueSerializer = valueSerializer;
+            deletes = new ArrayList<>();
+            diffs = new HashMap<>();
+            upserts = new HashMap<>();
+        }
+
+        protected MapDiff(
+            KeySerializer<K> keySerializer,
+            ValueSerializer<K, T> valueSerializer,
+            List<K> deletes,
+            Map<K, ProtobufDiff<T>> diffs,
+            Map<K, T> upserts
+        ) {
+            this.keySerializer = keySerializer;
+            this.valueSerializer = valueSerializer;
+            this.deletes = deletes;
+            this.diffs = diffs;
+            this.upserts = upserts;
+        }
+
+        protected MapDiff(CodedInputStream in, KeySerializer<K> keySerializer, ValueSerializer<K, T> valueSerializer) throws IOException {
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+            this.keySerializer = keySerializer;
+            this.valueSerializer = valueSerializer;
+            deletes = protobufStreamInput.readList(keySerializer::readKey, in);
+            int diffsCount = protobufStreamInput.readVInt(in);
+            diffs = diffsCount == 0 ? Collections.emptyMap() : new HashMap<>(diffsCount);
+            for (int i = 0; i < diffsCount; i++) {
+                K key = keySerializer.readKey(in);
+                ProtobufDiff<T> diff = valueSerializer.readDiff(in, key);
+                diffs.put(key, diff);
+            }
+            int upsertsCount = protobufStreamInput.readVInt(in);
+            upserts = upsertsCount == 0 ? Collections.emptyMap() : new HashMap<>(upsertsCount);
+            for (int i = 0; i < upsertsCount; i++) {
+                K key = keySerializer.readKey(in);
+                T newValue = valueSerializer.read(in, key);
+                upserts.put(key, newValue);
+            }
+        }
+
+        /**
+         * The keys that, when this diff is applied to a map, should be removed from the map.
+        *
+        * @return the list of keys that are deleted
+        */
+        public List<K> getDeletes() {
+            return deletes;
+        }
+
+        /**
+         * Map entries that, when this diff is applied to a map, should be
+        * incrementally updated. The incremental update is represented using
+        * the {@link Diff} interface.
+        *
+        * @return the map entries that are incrementally updated
+        */
+        public Map<K, ProtobufDiff<T>> getDiffs() {
+            return diffs;
+        }
+
+        /**
+         * Map entries that, when this diff is applied to a map, should be
+        * added to the map or fully replace the previous value.
+        *
+        * @return the map entries that are additions or full updates
+        */
+        public Map<K, T> getUpserts() {
+            return upserts;
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+            protobufStreamOutput.writeCollection(deletes, (o, v) -> keySerializer.writeKey(v, o), out);
+            Version version = protobufStreamOutput.getVersion();
+            // filter out custom states not supported by the other node
+            int diffCount = 0;
+            for (ProtobufDiff<T> diff : diffs.values()) {
+                if (valueSerializer.supportsVersion(diff, version)) {
+                    diffCount++;
+                }
+            }
+            out.writeInt32NoTag(diffCount);
+            for (Map.Entry<K, ProtobufDiff<T>> entry : diffs.entrySet()) {
+                if (valueSerializer.supportsVersion(entry.getValue(), version)) {
+                    keySerializer.writeKey(entry.getKey(), out);
+                    valueSerializer.writeDiff(entry.getValue(), out);
+                }
+            }
+            // filter out custom states not supported by the other node
+            int upsertsCount = 0;
+            for (T upsert : upserts.values()) {
+                if (valueSerializer.supportsVersion(upsert, version)) {
+                    upsertsCount++;
+                }
+            }
+            out.writeInt32NoTag(upsertsCount);
+            for (Map.Entry<K, T> entry : upserts.entrySet()) {
+                if (valueSerializer.supportsVersion(entry.getValue(), version)) {
+                    keySerializer.writeKey(entry.getKey(), out);
+                    valueSerializer.write(entry.getValue(), out);
+                }
+            }
+        }
+    }
+
+    /**
+     * Provides read and write operations to serialize keys of map
+    * @param <K> type of key
+    *
+    * @opensearch.internal
+    */
+    public interface KeySerializer<K> {
+        void writeKey(K key, CodedOutputStream out) throws IOException;
+
+        K readKey(CodedInputStream in) throws IOException;
+    }
+
+    /**
+     * Serializes String keys of a map
+    *
+    * @opensearch.internal
+    */
+    private static final class StringKeySerializer implements KeySerializer<String> {
+        private static final StringKeySerializer INSTANCE = new StringKeySerializer();
+
+        @Override
+        public void writeKey(String key, CodedOutputStream out) throws IOException {
+            out.writeStringNoTag(key);
+        }
+
+        @Override
+        public String readKey(CodedInputStream in) throws IOException {
+            return in.readString();
+        }
+    }
+
+    /**
+     * Serializes Integer keys of a map as an Int
+    *
+    * @opensearch.internal
+    */
+    private static final class IntKeySerializer implements KeySerializer<Integer> {
+        public static final IntKeySerializer INSTANCE = new IntKeySerializer();
+
+        @Override
+        public void writeKey(Integer key, CodedOutputStream out) throws IOException {
+            out.writeInt32NoTag(key);
+        }
+
+        @Override
+        public Integer readKey(CodedInputStream in) throws IOException {
+            return in.readInt32();
+        }
+    }
+
+    /**
+     * Serializes Integer keys of a map as a VInt. Requires keys to be positive.
+    *
+    * @opensearch.internal
+    */
+    private static final class VIntKeySerializer implements KeySerializer<Integer> {
+        public static final IntKeySerializer INSTANCE = new IntKeySerializer();
+
+        @Override
+        public void writeKey(Integer key, CodedOutputStream out) throws IOException {
+            if (key < 0) {
+                throw new IllegalArgumentException("Map key [" + key + "] must be positive");
+            }
+            out.writeInt32NoTag(key);
+        }
+
+        @Override
+        public Integer readKey(CodedInputStream in) throws IOException {
+            return in.readInt32();
+        }
+    }
+
+    /**
+     * Provides read and write operations to serialize map values.
+    * Reading of values can be made dependent on map key.
+    *
+    * Also provides operations to distinguish whether map values are diffable.
+    *
+    * Should not be directly implemented, instead implement either
+    * {@link DiffableValueSerializer} or {@link NonDiffableValueSerializer}.
+    *
+    * @param <K> key type of map
+    * @param <V> value type of map
+    *
+    * @opensearch.internal
+    */
+    public interface ValueSerializer<K, V> {
+
+        /**
+         * Writes value to stream
+        */
+        void write(V value, CodedOutputStream out) throws IOException;
+
+        /**
+         * Reads value from stream. Reading operation can be made dependent on map key.
+        */
+        V read(CodedInputStream in, K key) throws IOException;
+
+        /**
+         * Whether this serializer supports diffable values
+        */
+        boolean supportsDiffableValues();
+
+        /**
+         * Whether this serializer supports the version of the output stream
+        */
+        default boolean supportsVersion(ProtobufDiff<V> value, Version version) {
+            return true;
+        }
+
+        /**
+         * Whether this serializer supports the version of the output stream
+        */
+        default boolean supportsVersion(V value, Version version) {
+            return true;
+        }
+
+        /**
+         * Computes diff if this serializer supports diffable values
+        */
+        ProtobufDiff<V> diff(V value, V beforePart);
+
+        /**
+         * Writes value as diff to stream if this serializer supports diffable values
+        */
+        void writeDiff(ProtobufDiff<V> value, CodedOutputStream out) throws IOException;
+
+        /**
+         * Reads value as diff from stream if this serializer supports diffable values.
+        * Reading operation can be made dependent on map key.
+        */
+        ProtobufDiff<V> readDiff(CodedInputStream in, K key) throws IOException;
+    }
+
+    /**
+     * Serializer for Diffable map values. Needs to implement read and readDiff methods.
+    *
+    * @param <K> type of map keys
+    * @param <V> type of map values
+    *
+    * @opensearch.internal
+    */
+    public abstract static class DiffableValueSerializer<K, V extends ProtobufDiffable<V>> implements ValueSerializer<K, V> {
+        private static final DiffableValueSerializer WRITE_ONLY_INSTANCE = new DiffableValueSerializer() {
+            @Override
+            public Object read(CodedInputStream in, Object key) throws IOException {
+                throw new UnsupportedOperationException();
+            }
+
+            @Override
+            public ProtobufDiff<Object> readDiff(CodedInputStream in, Object key) throws IOException {
+                throw new UnsupportedOperationException();
+            }
+        };
+
+        private static <K, V extends ProtobufDiffable<V>> DiffableValueSerializer<K, V> getWriteOnlyInstance() {
+            return WRITE_ONLY_INSTANCE;
+        }
+
+        @Override
+        public boolean supportsDiffableValues() {
+            return true;
+        }
+
+        @Override
+        public ProtobufDiff<V> diff(V value, V beforePart) {
+            return value.diff(beforePart);
+        }
+
+        @Override
+        public void write(V value, CodedOutputStream out) throws IOException {
+            value.writeTo(out);
+        }
+
+        public void writeDiff(ProtobufDiff<V> value, CodedOutputStream out) throws IOException {
+            value.writeTo(out);
+        }
+    }
+
+    /**
+     * Serializer for non-diffable map values
+    *
+    * @param <K> type of map keys
+    * @param <V> type of map values
+    *
+    * @opensearch.internal
+    */
+    public abstract static class NonDiffableValueSerializer<K, V> implements ValueSerializer<K, V> {
+        @Override
+        public boolean supportsDiffableValues() {
+            return false;
+        }
+
+        @Override
+        public ProtobufDiff<V> diff(V value, V beforePart) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public void writeDiff(ProtobufDiff<V> value, CodedOutputStream out) throws IOException {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public ProtobufDiff<V> readDiff(CodedInputStream in, K key) throws IOException {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    /**
+     * Implementation of the ValueSerializer that wraps value and diff readers.
+    *
+    * Note: this implementation is ignoring the key.
+    *
+    * @opensearch.internal
+    */
+    public static class DiffableValueReader<K, V extends ProtobufDiffable<V>> extends DiffableValueSerializer<K, V> {
+        private final ProtobufWriteable.Reader<V> reader;
+        private final ProtobufWriteable.Reader<ProtobufDiff<V>> diffReader;
+
+        public DiffableValueReader(ProtobufWriteable.Reader<V> reader, ProtobufWriteable.Reader<ProtobufDiff<V>> diffReader) {
+            this.reader = reader;
+            this.diffReader = diffReader;
+        }
+
+        @Override
+        public V read(CodedInputStream in, K key) throws IOException {
+            return reader.read(in);
+        }
+
+        @Override
+        public ProtobufDiff<V> readDiff(CodedInputStream in, K key) throws IOException {
+            return diffReader.read(in);
+        }
+    }
+
+    /**
+     * Implementation of ValueSerializer that serializes immutable sets
+    *
+    * @param <K> type of map key
+    *
+    * @opensearch.internal
+    */
+    public static class StringSetValueSerializer<K> extends NonDiffableValueSerializer<K, Set<String>> {
+        private static final StringSetValueSerializer INSTANCE = new StringSetValueSerializer();
+
+        public static <K> StringSetValueSerializer<K> getInstance() {
+            return INSTANCE;
+        }
+
+        @Override
+        public void write(Set<String> value, CodedOutputStream out) throws IOException {
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+            protobufStreamOutput.writeCollection(value, CodedOutputStream::writeStringNoTag, out);
+        }
+
+        @Override
+        public Set<String> read(CodedInputStream in, K key) throws IOException {
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+            return Collections.unmodifiableSet(new HashSet<>(Arrays.asList(protobufStreamInput.readStringArray(in))));
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiff.java b/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiff.java
new file mode 100644
index 0000000000000..85f6e29d31458
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiff.java
@@ -0,0 +1,32 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.cluster;
+
+import org.opensearch.Version;
+import org.opensearch.common.io.stream.ProtobufNamedWriteable;
+
+/**
+ * Diff that also support NamedWriteable interface
+*
+* @opensearch.internal
+*/
+public interface ProtobufNamedDiff<T extends ProtobufDiffable<T>> extends ProtobufDiff<T>, ProtobufNamedWriteable {
+    /**
+     * The minimal version of the recipient this custom object can be sent to
+    */
+    default Version getMinimalSupportedVersion() {
+        return Version.CURRENT.minimumIndexCompatibilityVersion();
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffable.java b/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffable.java
new file mode 100644
index 0000000000000..4c1ff98666e5f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffable.java
@@ -0,0 +1,24 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.cluster;
+
+import org.opensearch.common.io.stream.ProtobufVersionedNamedWriteable;
+import org.opensearch.common.io.stream.VersionedNamedWriteable;
+
+/**
+ * Diff that also support {@link VersionedNamedWriteable} interface
+*
+* @opensearch.internal
+*/
+public interface ProtobufNamedDiffable<T> extends ProtobufDiffable<T>, ProtobufVersionedNamedWriteable {}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffableValueSerializer.java b/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffableValueSerializer.java
new file mode 100644
index 0000000000000..e7b3720256b09
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffableValueSerializer.java
@@ -0,0 +1,59 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.cluster;
+
+import com.google.protobuf.CodedInputStream;
+import org.opensearch.Version;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+
+import java.io.IOException;
+
+/**
+ * Value Serializer for named diffables
+*
+* @opensearch.internal
+*/
+public class ProtobufNamedDiffableValueSerializer<T extends ProtobufNamedDiffable<T>> extends ProtobufDiffableUtils.DiffableValueSerializer<
+    String,
+    T> {
+
+    private final Class<T> tClass;
+
+    public ProtobufNamedDiffableValueSerializer(Class<T> tClass) {
+        this.tClass = tClass;
+    }
+
+    @Override
+    public T read(CodedInputStream in, String key) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        return protobufStreamInput.readNamedWriteable(tClass, key);
+    }
+
+    @Override
+    public boolean supportsVersion(ProtobufDiff<T> value, Version version) {
+        return version.onOrAfter(((ProtobufNamedDiff<?>) value).getMinimalSupportedVersion());
+    }
+
+    @Override
+    public boolean supportsVersion(T value, Version version) {
+        return version.onOrAfter(value.getMinimalSupportedVersion());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public ProtobufDiff<T> readDiff(CodedInputStream in, String key) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        return protobufStreamInput.readNamedWriteable(ProtobufNamedDiff.class, key);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNode.java b/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNode.java
new file mode 100644
index 0000000000000..11b1762b05108
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNode.java
@@ -0,0 +1,518 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.cluster.node;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.Version;
+import org.opensearch.common.UUIDs;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.node.Node;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.opensearch.node.NodeRoleSettings.NODE_ROLES_SETTING;
+
+/**
+ * A discovery node represents a node that is part of the cluster.
+*
+* @opensearch.internal
+*/
+public class ProtobufDiscoveryNode implements ProtobufWriteable {
+
+    static final String COORDINATING_ONLY = "coordinating_only";
+
+    public static boolean nodeRequiresLocalStorage(Settings settings) {
+        boolean localStorageEnable = Node.NODE_LOCAL_STORAGE_SETTING.get(settings);
+        if (localStorageEnable == false && (isDataNode(settings) || isClusterManagerNode(settings))) {
+            // TODO: make this a proper setting validation logic, requiring multi-settings validation
+            throw new IllegalArgumentException("storage can not be disabled for cluster-manager and data nodes");
+        }
+        return localStorageEnable;
+    }
+
+    public static boolean hasRole(final Settings settings, final DiscoveryNodeRole role) {
+        /*
+        * This method can be called before the o.e.n.NodeRoleSettings.NODE_ROLES_SETTING is initialized. We do not want to trigger
+        * initialization prematurely because that will bake the default roles before plugins have had a chance to register them. Therefore,
+        * to avoid initializing this setting prematurely, we avoid using the actual node roles setting instance here.
+        */
+        if (settings.hasValue("node.roles")) {
+            return settings.getAsList("node.roles").contains(role.roleName());
+        } else if (role.legacySetting() != null && settings.hasValue(role.legacySetting().getKey())) {
+            return role.legacySetting().get(settings);
+        } else {
+            return role.isEnabledByDefault(settings);
+        }
+    }
+
+    public static boolean isClusterManagerNode(Settings settings) {
+        return hasRole(settings, DiscoveryNodeRole.MASTER_ROLE) || hasRole(settings, DiscoveryNodeRole.CLUSTER_MANAGER_ROLE);
+    }
+
+    /** @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #isClusterManagerNode(Settings)} */
+    @Deprecated
+    public static boolean isMasterNode(Settings settings) {
+        return isClusterManagerNode(settings);
+    }
+
+    /**
+     * Due to the way that plugins may not be available when settings are being initialized,
+    * not all roles may be available from a static/initializing context such as a {@link Setting}
+    * default value function. In that case, be warned that this may not include all plugin roles.
+    */
+    public static boolean isDataNode(final Settings settings) {
+        return getRolesFromSettings(settings).stream().anyMatch(DiscoveryNodeRole::canContainData);
+    }
+
+    public static boolean isIngestNode(Settings settings) {
+        return hasRole(settings, DiscoveryNodeRole.INGEST_ROLE);
+    }
+
+    public static boolean isRemoteClusterClient(final Settings settings) {
+        return hasRole(settings, DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE);
+    }
+
+    public static boolean isSearchNode(Settings settings) {
+        return hasRole(settings, DiscoveryNodeRole.SEARCH_ROLE);
+    }
+
+    private final String nodeName;
+    private final String nodeId;
+    private final String ephemeralId;
+    private final String hostName;
+    private final String hostAddress;
+    private final ProtobufTransportAddress address;
+    private final Map<String, String> attributes;
+    private final Version version;
+    private final SortedSet<DiscoveryNodeRole> roles;
+
+    /**
+     * Creates a new {@link ProtobufDiscoveryNode}
+    * <p>
+    * <b>Note:</b> if the version of the node is unknown {@link Version#minimumCompatibilityVersion()} should be used for the current
+    * version. it corresponds to the minimum version this opensearch version can communicate with. If a higher version is used
+    * the node might not be able to communicate with the remote node. After initial handshakes node versions will be discovered
+    * and updated.
+    * </p>
+    *
+    * @param id               the nodes unique (persistent) node id. This constructor will auto generate a random ephemeral id.
+    * @param address          the nodes transport address
+    * @param version          the version of the node
+    */
+    public ProtobufDiscoveryNode(final String id, ProtobufTransportAddress address, Version version) {
+        this(id, address, Collections.emptyMap(), DiscoveryNodeRole.BUILT_IN_ROLES, version);
+    }
+
+    /**
+     * Creates a new {@link ProtobufDiscoveryNode}
+    * <p>
+    * <b>Note:</b> if the version of the node is unknown {@link Version#minimumCompatibilityVersion()} should be used for the current
+    * version. it corresponds to the minimum version this opensearch version can communicate with. If a higher version is used
+    * the node might not be able to communicate with the remote node. After initial handshakes node versions will be discovered
+    * and updated.
+    * </p>
+    *
+    * @param id               the nodes unique (persistent) node id. This constructor will auto generate a random ephemeral id.
+    * @param address          the nodes transport address
+    * @param attributes       node attributes
+    * @param roles            node roles
+    * @param version          the version of the node
+    */
+    public ProtobufDiscoveryNode(
+        String id,
+        ProtobufTransportAddress address,
+        Map<String, String> attributes,
+        Set<DiscoveryNodeRole> roles,
+        Version version
+    ) {
+        this("", id, address, attributes, roles, version);
+    }
+
+    /**
+     * Creates a new {@link ProtobufDiscoveryNode}
+    * <p>
+    * <b>Note:</b> if the version of the node is unknown {@link Version#minimumCompatibilityVersion()} should be used for the current
+    * version. it corresponds to the minimum version this opensearch version can communicate with. If a higher version is used
+    * the node might not be able to communicate with the remote node. After initial handshakes node versions will be discovered
+    * and updated.
+    * </p>
+    *
+    * @param nodeName         the nodes name
+    * @param nodeId           the nodes unique persistent id. An ephemeral id will be auto generated.
+    * @param address          the nodes transport address
+    * @param attributes       node attributes
+    * @param roles            node roles
+    * @param version          the version of the node
+    */
+    public ProtobufDiscoveryNode(
+        String nodeName,
+        String nodeId,
+        ProtobufTransportAddress address,
+        Map<String, String> attributes,
+        Set<DiscoveryNodeRole> roles,
+        Version version
+    ) {
+        this(
+            nodeName,
+            nodeId,
+            UUIDs.randomBase64UUID(),
+            address.address().getHostString(),
+            address.getAddress(),
+            address,
+            attributes,
+            roles,
+            version
+        );
+    }
+
+    /**
+     * Creates a new {@link ProtobufDiscoveryNode}.
+    * <p>
+    * <b>Note:</b> if the version of the node is unknown {@link Version#minimumCompatibilityVersion()} should be used for the current
+    * version. it corresponds to the minimum version this opensearch version can communicate with. If a higher version is used
+    * the node might not be able to communicate with the remote node. After initial handshakes node versions will be discovered
+    * and updated.
+    * </p>
+    *
+    * @param nodeName         the nodes name
+    * @param nodeId           the nodes unique persistent id
+    * @param ephemeralId      the nodes unique ephemeral id
+    * @param hostAddress      the nodes host address
+    * @param address          the nodes transport address
+    * @param attributes       node attributes
+    * @param roles            node roles
+    * @param version          the version of the node
+    */
+    public ProtobufDiscoveryNode(
+        String nodeName,
+        String nodeId,
+        String ephemeralId,
+        String hostName,
+        String hostAddress,
+        ProtobufTransportAddress address,
+        Map<String, String> attributes,
+        Set<DiscoveryNodeRole> roles,
+        Version version
+    ) {
+        if (nodeName != null) {
+            this.nodeName = nodeName.intern();
+        } else {
+            this.nodeName = "";
+        }
+        this.nodeId = nodeId.intern();
+        this.ephemeralId = ephemeralId.intern();
+        this.hostName = hostName.intern();
+        this.hostAddress = hostAddress.intern();
+        this.address = address;
+        if (version == null) {
+            this.version = Version.CURRENT;
+        } else {
+            this.version = version;
+        }
+        this.attributes = Collections.unmodifiableMap(attributes);
+        // verify that no node roles are being provided as attributes
+        Predicate<Map<String, String>> predicate = (attrs) -> {
+            boolean success = true;
+            for (final DiscoveryNodeRole role : ProtobufDiscoveryNode.roleMap.values()) {
+                success &= attrs.containsKey(role.roleName()) == false;
+                assert success : role.roleName();
+            }
+            return success;
+        };
+        assert predicate.test(attributes) : attributes;
+        this.roles = Collections.unmodifiableSortedSet(new TreeSet<>(roles));
+    }
+
+    /** Creates a ProtobufDiscoveryNode representing the local node. */
+    public static ProtobufDiscoveryNode createLocal(Settings settings, ProtobufTransportAddress publishAddress, String nodeId) {
+        Map<String, String> attributes = Node.NODE_ATTRIBUTES.getAsMap(settings);
+        Set<DiscoveryNodeRole> roles = getRolesFromSettings(settings);
+        return new ProtobufDiscoveryNode(Node.NODE_NAME_SETTING.get(settings), nodeId, publishAddress, attributes, roles, Version.CURRENT);
+    }
+
+    /** extract node roles from the given settings */
+    public static Set<DiscoveryNodeRole> getRolesFromSettings(final Settings settings) {
+        if (NODE_ROLES_SETTING.exists(settings)) {
+            validateLegacySettings(settings, roleMap);
+            return Collections.unmodifiableSet(new HashSet<>(NODE_ROLES_SETTING.get(settings)));
+        } else {
+            return roleMap.values().stream().filter(s -> s.isEnabledByDefault(settings)).collect(Collectors.toSet());
+        }
+    }
+
+    private static void validateLegacySettings(final Settings settings, final Map<String, DiscoveryNodeRole> roleMap) {
+        for (final DiscoveryNodeRole role : roleMap.values()) {
+            if (role.legacySetting() != null && role.legacySetting().exists(settings)) {
+                final String message = String.format(
+                    Locale.ROOT,
+                    "can not explicitly configure node roles and use legacy role setting [%s]=[%s]",
+                    role.legacySetting().getKey(),
+                    role.legacySetting().get(settings)
+                );
+                throw new IllegalArgumentException(message);
+            }
+        }
+    }
+
+    /**
+     * Creates a new {@link ProtobufDiscoveryNode} by reading from the stream provided as argument
+    * @param in the stream
+    * @throws IOException if there is an error while reading from the stream
+    */
+    public ProtobufDiscoveryNode(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        this.nodeName = in.readString();
+        this.nodeId = in.readString();
+        this.ephemeralId = in.readString();
+        this.hostName = in.readString();
+        this.hostAddress = in.readString();
+        this.address = new ProtobufTransportAddress(in);
+        int size = in.readInt32();
+        this.attributes = new HashMap<>(size);
+        for (int i = 0; i < size; i++) {
+            this.attributes.put(in.readString(), in.readString());
+        }
+        int rolesSize = in.readInt32();
+        final Set<DiscoveryNodeRole> roles = new HashSet<>(rolesSize);
+        for (int i = 0; i < rolesSize; i++) {
+            final String roleName = in.readString();
+            final String roleNameAbbreviation = in.readString();
+            final boolean canContainData = in.readBool();
+            final DiscoveryNodeRole role = roleMap.get(roleName);
+            if (role == null) {
+                if (protobufStreamInput.getVersion().onOrAfter(Version.V_2_1_0)) {
+                    roles.add(new DiscoveryNodeRole.DynamicRole(roleName, roleNameAbbreviation, canContainData));
+                } else {
+                    roles.add(new DiscoveryNodeRole.UnknownRole(roleName, roleNameAbbreviation, canContainData));
+                }
+            } else {
+                assert roleName.equals(role.roleName()) : "role name [" + roleName + "] does not match role [" + role.roleName() + "]";
+                assert roleNameAbbreviation.equals(role.roleNameAbbreviation()) : "role name abbreviation ["
+                    + roleName
+                    + "] does not match role ["
+                    + role.roleNameAbbreviation()
+                    + "]";
+                roles.add(role);
+            }
+        }
+        this.roles = Collections.unmodifiableSortedSet(new TreeSet<>(roles));
+        this.version = Version.readVersionProtobuf(in);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        out.writeStringNoTag(nodeName);
+        out.writeStringNoTag(nodeId);
+        out.writeStringNoTag(ephemeralId);
+        out.writeStringNoTag(hostName);
+        out.writeStringNoTag(hostAddress);
+        address.writeTo(out);
+        out.writeInt32NoTag(attributes.size());
+        for (Map.Entry<String, String> entry : attributes.entrySet()) {
+            out.writeStringNoTag(entry.getKey());
+            out.writeStringNoTag(entry.getValue());
+        }
+        out.writeInt32NoTag(roles.size());
+        for (final DiscoveryNodeRole role : roles) {
+            final DiscoveryNodeRole compatibleRole = role.getCompatibilityRole(protobufStreamOutput.getVersion());
+            out.writeStringNoTag(compatibleRole.roleName());
+            out.writeStringNoTag(compatibleRole.roleNameAbbreviation());
+            out.writeBoolNoTag(compatibleRole.canContainData());
+        }
+        out.writeInt32NoTag(version.id);
+    }
+
+    /**
+     * The address that the node can be communicated with.
+    */
+    public ProtobufTransportAddress getAddress() {
+        return address;
+    }
+
+    /**
+     * The unique id of the node.
+    */
+    public String getId() {
+        return nodeId;
+    }
+
+    /**
+     * The unique ephemeral id of the node. Ephemeral ids are meant to be attached the life span
+    * of a node process. When ever a node is restarted, it's ephemeral id is required to change (while it's {@link #getId()}
+    * will be read from the data folder and will remain the same across restarts).
+    */
+    public String getEphemeralId() {
+        return ephemeralId;
+    }
+
+    /**
+     * The name of the node.
+    */
+    public String getName() {
+        return this.nodeName;
+    }
+
+    /**
+     * The node attributes.
+    */
+    public Map<String, String> getAttributes() {
+        return this.attributes;
+    }
+
+    /**
+     * Should this node hold data (shards) or not.
+    */
+    public boolean isDataNode() {
+        return roles.stream().anyMatch(DiscoveryNodeRole::canContainData);
+    }
+
+    /**
+     * Can this node become cluster-manager or not.
+    */
+    public boolean isClusterManagerNode() {
+        return roles.contains(DiscoveryNodeRole.MASTER_ROLE) || roles.contains(DiscoveryNodeRole.CLUSTER_MANAGER_ROLE);
+    }
+
+    /**
+     * Can this node become cluster-manager or not.
+    *
+    * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #isClusterManagerNode()}
+    */
+    @Deprecated
+    public boolean isMasterNode() {
+        return isClusterManagerNode();
+    }
+
+    /**
+     * Returns a boolean that tells whether this an ingest node or not
+    */
+    public boolean isIngestNode() {
+        return roles.contains(DiscoveryNodeRole.INGEST_ROLE);
+    }
+
+    /**
+     * Returns whether or not the node can be a remote cluster client.
+    *
+    * @return true if the node can be a remote cluster client, false otherwise
+    */
+    public boolean isRemoteClusterClient() {
+        return roles.contains(DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE);
+    }
+
+    /**
+     * Returns whether the node is dedicated to provide search capability.
+    *
+    * @return true if the node contains search role, false otherwise
+    */
+    public boolean isSearchNode() {
+        return roles.contains(DiscoveryNodeRole.SEARCH_ROLE);
+    }
+
+    /**
+     * Returns a set of all the roles that the node has. The roles are returned in sorted order by the role name.
+    * <p>
+    * If a node does not have any specific role, the returned set is empty, which means that the node is a coordinating-only node.
+    *
+    * @return the sorted set of roles
+    */
+    public Set<DiscoveryNodeRole> getRoles() {
+        return roles;
+    }
+
+    public Version getVersion() {
+        return this.version;
+    }
+
+    public String getHostName() {
+        return this.hostName;
+    }
+
+    public String getHostAddress() {
+        return this.hostAddress;
+    }
+
+    private static Map<String, DiscoveryNodeRole> rolesToMap(final Stream<DiscoveryNodeRole> roles) {
+        return Collections.unmodifiableMap(roles.collect(Collectors.toMap(DiscoveryNodeRole::roleName, Function.identity())));
+    }
+
+    private static Map<String, DiscoveryNodeRole> roleMap = rolesToMap(DiscoveryNodeRole.BUILT_IN_ROLES.stream());
+
+    public static DiscoveryNodeRole getRoleFromRoleName(final String roleName) {
+        // As we are supporting dynamic role, should make role name case-insensitive to avoid confusion of role name like "Data"/"DATA"
+        String lowerCasedRoleName = Objects.requireNonNull(roleName).toLowerCase(Locale.ROOT);
+        if (roleMap.containsKey(lowerCasedRoleName)) {
+            return roleMap.get(lowerCasedRoleName);
+        }
+        return new DiscoveryNodeRole.DynamicRole(lowerCasedRoleName, lowerCasedRoleName, false);
+    }
+
+    public static Set<DiscoveryNodeRole> getPossibleRoles() {
+        return Collections.unmodifiableSet(new HashSet<>(roleMap.values()));
+    }
+
+    public static void setAdditionalRoles(final Set<DiscoveryNodeRole> additionalRoles) {
+        assert additionalRoles.stream().allMatch(r -> r.legacySetting() == null || r.legacySetting().isDeprecated()) : additionalRoles;
+        final Map<String, DiscoveryNodeRole> roleNameToPossibleRoles = rolesToMap(
+            Stream.concat(DiscoveryNodeRole.BUILT_IN_ROLES.stream(), additionalRoles.stream())
+        );
+        // collect the abbreviation names into a map to ensure that there are not any duplicate abbreviations
+        final Map<String, DiscoveryNodeRole> roleNameAbbreviationToPossibleRoles = Collections.unmodifiableMap(
+            roleNameToPossibleRoles.values()
+                .stream()
+                .collect(Collectors.toMap(DiscoveryNodeRole::roleNameAbbreviation, Function.identity()))
+        );
+        assert roleNameToPossibleRoles.size() == roleNameAbbreviationToPossibleRoles.size() : "roles by name ["
+            + roleNameToPossibleRoles
+            + "], roles by name abbreviation ["
+            + roleNameAbbreviationToPossibleRoles
+            + "]";
+        roleMap = roleNameToPossibleRoles;
+    }
+
+    /**
+     * Load the deprecated {@link DiscoveryNodeRole#MASTER_ROLE}.
+    * Master role is not added into BUILT_IN_ROLES, because {@link #setAdditionalRoles(Set)} check role name abbreviation duplication,
+    * and CLUSTER_MANAGER_ROLE has the same abbreviation name with MASTER_ROLE.
+    */
+    public static void setDeprecatedMasterRole() {
+        final Map<String, DiscoveryNodeRole> modifiableRoleMap = new HashMap<>(roleMap);
+        modifiableRoleMap.put(DiscoveryNodeRole.MASTER_ROLE.roleName(), DiscoveryNodeRole.MASTER_ROLE);
+        roleMap = Collections.unmodifiableMap(modifiableRoleMap);
+    }
+
+    public static Set<String> getPossibleRoleNames() {
+        return roleMap.keySet();
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java b/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java
new file mode 100644
index 0000000000000..d6a19ef75a134
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java
@@ -0,0 +1,886 @@
+/*
+* 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.
+*/
+
+package org.opensearch.cluster.node;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import com.carrotsearch.hppc.ObjectHashSet;
+import com.carrotsearch.hppc.cursors.ObjectCursor;
+import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
+import org.opensearch.Version;
+import org.opensearch.cluster.AbstractDiffable;
+import org.opensearch.cluster.Diff;
+import org.opensearch.common.Booleans;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.Strings;
+import org.opensearch.common.collect.ImmutableOpenMap;
+import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.StreamOutput;
+import org.opensearch.common.regex.Regex;
+import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.common.util.set.Sets;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+/**
+ * This class holds all {@link ProtobufDiscoveryNode} in the cluster and provides convenience methods to
+* access, modify merge / diff discovery nodes.
+*
+* @opensearch.internal
+*/
+public class ProtobufDiscoveryNodes extends AbstractDiffable<ProtobufDiscoveryNodes> implements Iterable<ProtobufDiscoveryNode> {
+
+    public static final ProtobufDiscoveryNodes EMPTY_NODES = builder().build();
+
+    private final ImmutableOpenMap<String, ProtobufDiscoveryNode> nodes;
+    private final ImmutableOpenMap<String, ProtobufDiscoveryNode> dataNodes;
+    private final ImmutableOpenMap<String, ProtobufDiscoveryNode> clusterManagerNodes;
+    private final ImmutableOpenMap<String, ProtobufDiscoveryNode> ingestNodes;
+
+    private final String clusterManagerNodeId;
+    private final String localNodeId;
+    private final Version minNonClientNodeVersion;
+    private final Version maxNonClientNodeVersion;
+    private final Version maxNodeVersion;
+    private final Version minNodeVersion;
+
+    private ProtobufDiscoveryNodes(
+        ImmutableOpenMap<String, ProtobufDiscoveryNode> nodes,
+        ImmutableOpenMap<String, ProtobufDiscoveryNode> dataNodes,
+        ImmutableOpenMap<String, ProtobufDiscoveryNode> clusterManagerNodes,
+        ImmutableOpenMap<String, ProtobufDiscoveryNode> ingestNodes,
+        String clusterManagerNodeId,
+        String localNodeId,
+        Version minNonClientNodeVersion,
+        Version maxNonClientNodeVersion,
+        Version maxNodeVersion,
+        Version minNodeVersion
+    ) {
+        this.nodes = nodes;
+        this.dataNodes = dataNodes;
+        this.clusterManagerNodes = clusterManagerNodes;
+        this.ingestNodes = ingestNodes;
+        this.clusterManagerNodeId = clusterManagerNodeId;
+        this.localNodeId = localNodeId;
+        this.minNonClientNodeVersion = minNonClientNodeVersion;
+        this.maxNonClientNodeVersion = maxNonClientNodeVersion;
+        this.minNodeVersion = minNodeVersion;
+        this.maxNodeVersion = maxNodeVersion;
+    }
+
+    @Override
+    public Iterator<ProtobufDiscoveryNode> iterator() {
+        return nodes.valuesIt();
+    }
+
+    /**
+     * Returns {@code true} if the local node is the elected cluster-manager node.
+    */
+    public boolean isLocalNodeElectedClusterManager() {
+        if (localNodeId == null) {
+            // we don't know yet the local node id, return false
+            return false;
+        }
+        return localNodeId.equals(clusterManagerNodeId);
+    }
+
+    /**
+     * Returns {@code true} if the local node is the elected cluster-manager node.
+    *
+    * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #isLocalNodeElectedClusterManager()}
+    */
+    @Deprecated
+    public boolean isLocalNodeElectedMaster() {
+        return isLocalNodeElectedClusterManager();
+    }
+
+    /**
+     * Get the number of known nodes
+    *
+    * @return number of nodes
+    */
+    public int getSize() {
+        return nodes.size();
+    }
+
+    /**
+     * Get a {@link Map} of the discovered nodes arranged by their ids
+    *
+    * @return {@link Map} of the discovered nodes arranged by their ids
+    */
+    public ImmutableOpenMap<String, ProtobufDiscoveryNode> getNodes() {
+        return this.nodes;
+    }
+
+    /**
+     * Get a {@link Map} of the discovered data nodes arranged by their ids
+    *
+    * @return {@link Map} of the discovered data nodes arranged by their ids
+    */
+    public ImmutableOpenMap<String, ProtobufDiscoveryNode> getDataNodes() {
+        return this.dataNodes;
+    }
+
+    /**
+     * Get a {@link Map} of the discovered cluster-manager nodes arranged by their ids
+    *
+    * @return {@link Map} of the discovered cluster-manager nodes arranged by their ids
+    */
+    public ImmutableOpenMap<String, ProtobufDiscoveryNode> getClusterManagerNodes() {
+        return this.clusterManagerNodes;
+    }
+
+    /**
+     * Get a {@link Map} of the discovered cluster-manager nodes arranged by their ids
+    *
+    * @return {@link Map} of the discovered cluster-manager nodes arranged by their ids
+    * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #getClusterManagerNodes()}
+    */
+    @Deprecated
+    public ImmutableOpenMap<String, ProtobufDiscoveryNode> getMasterNodes() {
+        return getClusterManagerNodes();
+    }
+
+    /**
+     * @return All the ingest nodes arranged by their ids
+    */
+    public ImmutableOpenMap<String, ProtobufDiscoveryNode> getIngestNodes() {
+        return ingestNodes;
+    }
+
+    /**
+     * Get a {@link Map} of the discovered cluster-manager and data nodes arranged by their ids
+    *
+    * @return {@link Map} of the discovered cluster-manager and data nodes arranged by their ids
+    */
+    public ImmutableOpenMap<String, ProtobufDiscoveryNode> getClusterManagerAndDataNodes() {
+        ImmutableOpenMap.Builder<String, ProtobufDiscoveryNode> nodes = ImmutableOpenMap.builder(dataNodes);
+        nodes.putAll(clusterManagerNodes);
+        return nodes.build();
+    }
+
+    /**
+     * Get a {@link Map} of the discovered cluster-manager and data nodes arranged by their ids
+    *
+    * @return {@link Map} of the discovered cluster-manager and data nodes arranged by their ids
+    * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #getClusterManagerAndDataNodes()}
+    */
+    @Deprecated
+    public ImmutableOpenMap<String, ProtobufDiscoveryNode> getMasterAndDataNodes() {
+        return getClusterManagerAndDataNodes();
+    }
+
+    /**
+     * Get a {@link Map} of the coordinating only nodes (nodes which are neither cluster-manager, nor data, nor ingest nodes) arranged by their ids
+    *
+    * @return {@link Map} of the coordinating only nodes arranged by their ids
+    */
+    public ImmutableOpenMap<String, ProtobufDiscoveryNode> getCoordinatingOnlyNodes() {
+        ImmutableOpenMap.Builder<String, ProtobufDiscoveryNode> nodes = ImmutableOpenMap.builder(this.nodes);
+        nodes.removeAll(clusterManagerNodes.keys());
+        nodes.removeAll(dataNodes.keys());
+        nodes.removeAll(ingestNodes.keys());
+        return nodes.build();
+    }
+
+    /**
+     * Returns a stream of all nodes, with cluster-manager nodes at the front
+    */
+    public Stream<ProtobufDiscoveryNode> clusterManagersFirstStream() {
+        return Stream.concat(
+            StreamSupport.stream(clusterManagerNodes.spliterator(), false).map(cur -> cur.value),
+            StreamSupport.stream(this.spliterator(), false).filter(n -> n.isClusterManagerNode() == false)
+        );
+    }
+
+    /**
+     * Returns a stream of all nodes, with cluster-manager nodes at the front
+    *
+    * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #clusterManagersFirstStream()}
+    */
+    @Deprecated
+    public Stream<ProtobufDiscoveryNode> mastersFirstStream() {
+        return clusterManagersFirstStream();
+    }
+
+    /**
+     * Get a node by its id
+    *
+    * @param nodeId id of the wanted node
+    * @return wanted node if it exists. Otherwise <code>null</code>
+    */
+    public ProtobufDiscoveryNode get(String nodeId) {
+        return nodes.get(nodeId);
+    }
+
+    /**
+     * Determine if a given node id exists
+    *
+    * @param nodeId id of the node which existence should be verified
+    * @return <code>true</code> if the node exists. Otherwise <code>false</code>
+    */
+    public boolean nodeExists(String nodeId) {
+        return nodes.containsKey(nodeId);
+    }
+
+    /**
+     * Determine if a given node exists
+    *
+    * @param node of the node which existence should be verified
+    * @return <code>true</code> if the node exists. Otherwise <code>false</code>
+    */
+    public boolean nodeExists(ProtobufDiscoveryNode node) {
+        ProtobufDiscoveryNode existing = nodes.get(node.getId());
+        return existing != null && existing.equals(node);
+    }
+
+    /**
+     * Determine if the given node exists and has the right roles. Supported roles vary by version, and our local cluster state might
+    * have come via an older cluster-manager, so the roles may differ even if the node is otherwise identical.
+    */
+    public boolean nodeExistsWithSameRoles(ProtobufDiscoveryNode discoveryNode) {
+        final ProtobufDiscoveryNode existing = nodes.get(discoveryNode.getId());
+        return existing != null && existing.equals(discoveryNode) && existing.getRoles().equals(discoveryNode.getRoles());
+    }
+
+    /**
+     * Get the id of the cluster-manager node
+    *
+    * @return id of the cluster-manager
+    */
+    public String getClusterManagerNodeId() {
+        return this.clusterManagerNodeId;
+    }
+
+    /**
+     * Get the id of the cluster-manager node
+    *
+    * @return id of the cluster-manager
+    * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #getClusterManagerNodeId()}
+    */
+    @Deprecated
+    public String getMasterNodeId() {
+        return getClusterManagerNodeId();
+    }
+
+    /**
+     * Get the id of the local node
+    *
+    * @return id of the local node
+    */
+    public String getLocalNodeId() {
+        return this.localNodeId;
+    }
+
+    /**
+     * Get the local node
+    *
+    * @return local node
+    */
+    public ProtobufDiscoveryNode getLocalNode() {
+        return nodes.get(localNodeId);
+    }
+
+    /**
+     * Returns the cluster-manager node, or {@code null} if there is no cluster-manager node
+    */
+    @Nullable
+    public ProtobufDiscoveryNode getClusterManagerNode() {
+        if (clusterManagerNodeId != null) {
+            return nodes.get(clusterManagerNodeId);
+        }
+        return null;
+    }
+
+    /**
+     * Returns the cluster-manager node, or {@code null} if there is no cluster-manager node
+    *
+    * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #getClusterManagerNode()}
+    */
+    @Deprecated
+    @Nullable
+    public ProtobufDiscoveryNode getMasterNode() {
+        return getClusterManagerNode();
+    }
+
+    /**
+     * Get a node by its address
+    *
+    * @param address {@link TransportAddress} of the wanted node
+    * @return node identified by the given address or <code>null</code> if no such node exists
+    */
+    public ProtobufDiscoveryNode findByAddress(TransportAddress address) {
+        for (ObjectCursor<ProtobufDiscoveryNode> cursor : nodes.values()) {
+            ProtobufDiscoveryNode node = cursor.value;
+            if (node.getAddress().equals(address)) {
+                return node;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Returns the version of the node with the oldest version in the cluster that is not a client node
+    *
+    * If there are no non-client nodes, Version.CURRENT will be returned.
+    *
+    * @return the oldest version in the cluster
+    */
+    public Version getSmallestNonClientNodeVersion() {
+        return minNonClientNodeVersion;
+    }
+
+    /**
+     * Returns the version of the node with the youngest version in the cluster that is not a client node.
+    *
+    * If there are no non-client nodes, Version.CURRENT will be returned.
+    *
+    * @return the youngest version in the cluster
+    */
+    public Version getLargestNonClientNodeVersion() {
+        return maxNonClientNodeVersion;
+    }
+
+    /**
+     * Returns the version of the node with the oldest version in the cluster.
+    *
+    * @return the oldest version in the cluster
+    */
+    public Version getMinNodeVersion() {
+        return minNodeVersion;
+    }
+
+    /**
+     * Returns the version of the node with the youngest version in the cluster
+    *
+    * @return the youngest version in the cluster
+    */
+    public Version getMaxNodeVersion() {
+        return maxNodeVersion;
+    }
+
+    /**
+     * Resolve a node with a given id
+    *
+    * @param node id of the node to discover
+    * @return discovered node matching the given id
+    * @throws IllegalArgumentException if more than one node matches the request or no nodes have been resolved
+    */
+    public ProtobufDiscoveryNode resolveNode(String node) {
+        String[] resolvedNodeIds = resolveNodes(node);
+        if (resolvedNodeIds.length > 1) {
+            throw new IllegalArgumentException(
+                "resolved [" + node + "] into [" + resolvedNodeIds.length + "] nodes, where expected to be resolved to a single node"
+            );
+        }
+        if (resolvedNodeIds.length == 0) {
+            throw new IllegalArgumentException("failed to resolve [" + node + "], no matching nodes");
+        }
+        return nodes.get(resolvedNodeIds[0]);
+    }
+
+    /**
+     * Resolves a set of nodes according to the given sequence of node specifications. Implements the logic in various APIs that allow the
+    * user to run the action on a subset of the nodes in the cluster. See [Node specification] in the reference manual for full details.
+    *
+    * Works by tracking the current set of nodes and applying each node specification in sequence. The set starts out empty and each node
+    * specification may either add or remove nodes. For instance:
+    *
+    * - _local, _cluster_manager (_master) and _all respectively add to the subset the local node, the currently-elected cluster_manager, and all the nodes
+    * - node IDs, names, hostnames and IP addresses all add to the subset any nodes which match
+    * - a wildcard-based pattern of the form "attr*:value*" adds to the subset all nodes with a matching attribute with a matching value
+    * - role:true adds to the subset all nodes with a matching role
+    * - role:false removes from the subset all nodes with a matching role.
+    *
+    * An empty sequence of node specifications returns all nodes, since the corresponding actions run on all nodes by default.
+    */
+    public String[] resolveNodes(String... nodes) {
+        if (nodes == null || nodes.length == 0) {
+            return StreamSupport.stream(this.spliterator(), false).map(ProtobufDiscoveryNode::getId).toArray(String[]::new);
+        } else {
+            ObjectHashSet<String> resolvedNodesIds = new ObjectHashSet<>(nodes.length);
+            for (String nodeId : nodes) {
+                if (nodeId == null) {
+                    // don't silence the underlying issue, it is a bug, so lets fail if assertions are enabled
+                    assert nodeId != null : "nodeId should not be null";
+                    continue;
+                } else if (nodeId.equals("_local")) {
+                    String localNodeId = getLocalNodeId();
+                    if (localNodeId != null) {
+                        resolvedNodesIds.add(localNodeId);
+                    }
+                } else if (nodeId.equals("_master") || nodeId.equals("_cluster_manager")) {
+                    String clusterManagerNodeId = getClusterManagerNodeId();
+                    if (clusterManagerNodeId != null) {
+                        resolvedNodesIds.add(clusterManagerNodeId);
+                    }
+                } else if (nodeExists(nodeId)) {
+                    resolvedNodesIds.add(nodeId);
+                } else {
+                    for (ProtobufDiscoveryNode node : this) {
+                        if ("_all".equals(nodeId)
+                            || Regex.simpleMatch(nodeId, node.getName())
+                            || Regex.simpleMatch(nodeId, node.getHostAddress())
+                            || Regex.simpleMatch(nodeId, node.getHostName())) {
+                            resolvedNodesIds.add(node.getId());
+                        }
+                    }
+                    int index = nodeId.indexOf(':');
+                    if (index != -1) {
+                        String matchAttrName = nodeId.substring(0, index);
+                        String matchAttrValue = nodeId.substring(index + 1);
+                        if (DiscoveryNodeRole.DATA_ROLE.roleName().equals(matchAttrName)) {
+                            if (Booleans.parseBoolean(matchAttrValue, true)) {
+                                resolvedNodesIds.addAll(dataNodes.keys());
+                            } else {
+                                resolvedNodesIds.removeAll(dataNodes.keys());
+                            }
+                        } else if (roleNameIsClusterManager(matchAttrName)) {
+                            if (Booleans.parseBoolean(matchAttrValue, true)) {
+                                resolvedNodesIds.addAll(clusterManagerNodes.keys());
+                            } else {
+                                resolvedNodesIds.removeAll(clusterManagerNodes.keys());
+                            }
+                        } else if (DiscoveryNodeRole.INGEST_ROLE.roleName().equals(matchAttrName)) {
+                            if (Booleans.parseBoolean(matchAttrValue, true)) {
+                                resolvedNodesIds.addAll(ingestNodes.keys());
+                            } else {
+                                resolvedNodesIds.removeAll(ingestNodes.keys());
+                            }
+                        } else if (ProtobufDiscoveryNode.COORDINATING_ONLY.equals(matchAttrName)) {
+                            if (Booleans.parseBoolean(matchAttrValue, true)) {
+                                resolvedNodesIds.addAll(getCoordinatingOnlyNodes().keys());
+                            } else {
+                                resolvedNodesIds.removeAll(getCoordinatingOnlyNodes().keys());
+                            }
+                        } else {
+                            for (ProtobufDiscoveryNode node : this) {
+                                for (DiscoveryNodeRole role : Sets.difference(node.getRoles(), DiscoveryNodeRole.BUILT_IN_ROLES)) {
+                                    if (role.roleName().equals(matchAttrName)) {
+                                        if (Booleans.parseBoolean(matchAttrValue, true)) {
+                                            resolvedNodesIds.add(node.getId());
+                                        } else {
+                                            resolvedNodesIds.remove(node.getId());
+                                        }
+                                    }
+                                }
+                            }
+                            for (ProtobufDiscoveryNode node : this) {
+                                for (Map.Entry<String, String> entry : node.getAttributes().entrySet()) {
+                                    String attrName = entry.getKey();
+                                    String attrValue = entry.getValue();
+                                    if (Regex.simpleMatch(matchAttrName, attrName) && Regex.simpleMatch(matchAttrValue, attrValue)) {
+                                        resolvedNodesIds.add(node.getId());
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return resolvedNodesIds.toArray(String.class);
+        }
+    }
+
+    public ProtobufDiscoveryNodes newNode(ProtobufDiscoveryNode node) {
+        return new Builder(this).add(node).build();
+    }
+
+    /**
+     * Returns the changes comparing this nodes to the provided nodes.
+    */
+    public Delta delta(ProtobufDiscoveryNodes other) {
+        final List<ProtobufDiscoveryNode> removed = new ArrayList<>();
+        final List<ProtobufDiscoveryNode> added = new ArrayList<>();
+        for (ProtobufDiscoveryNode node : other) {
+            if (this.nodeExists(node) == false) {
+                removed.add(node);
+            }
+        }
+        for (ProtobufDiscoveryNode node : this) {
+            if (other.nodeExists(node) == false) {
+                added.add(node);
+            }
+        }
+
+        return new Delta(
+            other.getClusterManagerNode(),
+            getClusterManagerNode(),
+            localNodeId,
+            Collections.unmodifiableList(removed),
+            Collections.unmodifiableList(added)
+        );
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("nodes: \n");
+        for (ProtobufDiscoveryNode node : this) {
+            sb.append("   ").append(node);
+            if (node == getLocalNode()) {
+                sb.append(", local");
+            }
+            if (node == getClusterManagerNode()) {
+                sb.append(", cluster-manager");
+            }
+            sb.append("\n");
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Delta between nodes.
+    *
+    * @opensearch.internal
+    */
+    public static class Delta {
+
+        private final String localNodeId;
+        @Nullable
+        private final ProtobufDiscoveryNode previousClusterManagerNode;
+        @Nullable
+        private final ProtobufDiscoveryNode newClusterManagerNode;
+        private final List<ProtobufDiscoveryNode> removed;
+        private final List<ProtobufDiscoveryNode> added;
+
+        private Delta(
+            @Nullable ProtobufDiscoveryNode previousClusterManagerNode,
+            @Nullable ProtobufDiscoveryNode newClusterManagerNode,
+            String localNodeId,
+            List<ProtobufDiscoveryNode> removed,
+            List<ProtobufDiscoveryNode> added
+        ) {
+            this.previousClusterManagerNode = previousClusterManagerNode;
+            this.newClusterManagerNode = newClusterManagerNode;
+            this.localNodeId = localNodeId;
+            this.removed = removed;
+            this.added = added;
+        }
+
+        public boolean hasChanges() {
+            return clusterManagerNodeChanged() || !removed.isEmpty() || !added.isEmpty();
+        }
+
+        public boolean clusterManagerNodeChanged() {
+            return Objects.equals(newClusterManagerNode, previousClusterManagerNode) == false;
+        }
+
+        /** @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #clusterManagerNodeChanged()} */
+        @Deprecated
+        public boolean masterNodeChanged() {
+            return clusterManagerNodeChanged();
+        }
+
+        @Nullable
+        public ProtobufDiscoveryNode previousClusterManagerNode() {
+            return previousClusterManagerNode;
+        }
+
+        /** @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #previousClusterManagerNode()} */
+        @Deprecated
+        @Nullable
+        public ProtobufDiscoveryNode previousMasterNode() {
+            return previousClusterManagerNode();
+        }
+
+        @Nullable
+        public ProtobufDiscoveryNode newClusterManagerNode() {
+            return newClusterManagerNode;
+        }
+
+        /** @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #newClusterManagerNode()} */
+        @Deprecated
+        @Nullable
+        public ProtobufDiscoveryNode newMasterNode() {
+            return newClusterManagerNode();
+        }
+
+        public boolean removed() {
+            return !removed.isEmpty();
+        }
+
+        public List<ProtobufDiscoveryNode> removedNodes() {
+            return removed;
+        }
+
+        public boolean added() {
+            return !added.isEmpty();
+        }
+
+        public List<ProtobufDiscoveryNode> addedNodes() {
+            return added;
+        }
+
+        public String shortSummary() {
+            final StringBuilder summary = new StringBuilder();
+            if (clusterManagerNodeChanged()) {
+                summary.append("cluster-manager node changed {previous [");
+                if (previousClusterManagerNode() != null) {
+                    summary.append(previousClusterManagerNode());
+                }
+                summary.append("], current [");
+                if (newClusterManagerNode() != null) {
+                    summary.append(newClusterManagerNode());
+                }
+                summary.append("]}");
+            }
+            if (removed()) {
+                if (summary.length() > 0) {
+                    summary.append(", ");
+                }
+                summary.append("removed {").append(Strings.collectionToCommaDelimitedString(removedNodes())).append('}');
+            }
+            if (added()) {
+                final String addedNodesExceptLocalNode = addedNodes().stream()
+                    .filter(node -> node.getId().equals(localNodeId) == false)
+                    .map(ProtobufDiscoveryNode::toString)
+                    .collect(Collectors.joining(","));
+                if (addedNodesExceptLocalNode.length() > 0) {
+                    // ignore ourselves when reporting on nodes being added
+                    if (summary.length() > 0) {
+                        summary.append(", ");
+                    }
+                    summary.append("added {").append(addedNodesExceptLocalNode).append('}');
+                }
+            }
+            return summary.toString();
+        }
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        if (clusterManagerNodeId == null) {
+            out.writeBoolNoTag(false);
+        } else {
+            out.writeBoolNoTag(true);
+            out.writeStringNoTag(clusterManagerNodeId);
+        }
+        out.writeInt32NoTag(nodes.size());
+        for (ProtobufDiscoveryNode node : this) {
+            node.writeTo(out);
+        }
+    }
+
+    public static ProtobufDiscoveryNodes readFrom(CodedInputStream in, ProtobufDiscoveryNode localNode) throws IOException {
+        Builder builder = new Builder();
+        if (in.readBool()) {
+            builder.clusterManagerNodeId(in.readString());
+        }
+        if (localNode != null) {
+            builder.localNodeId(localNode.getId());
+        }
+        int size = in.readInt32();
+        for (int i = 0; i < size; i++) {
+            ProtobufDiscoveryNode node = new ProtobufDiscoveryNode(in);
+            if (localNode != null && node.getId().equals(localNode.getId())) {
+                // reuse the same instance of our address and local node id for faster equality
+                node = localNode;
+            }
+            // some one already built this and validated it's OK, skip the n2 scans
+            assert builder.validateAdd(node) == null : "building disco nodes from network doesn't pass preflight: "
+                + builder.validateAdd(node);
+            builder.putUnsafe(node);
+        }
+        return builder.build();
+    }
+
+    public static Diff<ProtobufDiscoveryNodes> readDiffFrom(CodedInputStream in, ProtobufDiscoveryNode localNode) throws IOException {
+        return AbstractDiffable.readDiffFrom(in1 -> readFrom(in1, localNode), in);
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    public static Builder builder(ProtobufDiscoveryNodes nodes) {
+        return new Builder(nodes);
+    }
+
+    /**
+     * Builder of a map of discovery nodes.
+    *
+    * @opensearch.internal
+    */
+    public static class Builder {
+
+        private final ImmutableOpenMap.Builder<String, ProtobufDiscoveryNode> nodes;
+        private String clusterManagerNodeId;
+        private String localNodeId;
+
+        public Builder() {
+            nodes = ImmutableOpenMap.builder();
+        }
+
+        public Builder(ProtobufDiscoveryNodes nodes) {
+            this.clusterManagerNodeId = nodes.getClusterManagerNodeId();
+            this.localNodeId = nodes.getLocalNodeId();
+            this.nodes = ImmutableOpenMap.builder(nodes.getNodes());
+        }
+
+        /**
+         * adds a disco node to the builder. Will throw an {@link IllegalArgumentException} if
+        * the supplied node doesn't pass the pre-flight checks performed by {@link #validateAdd(ProtobufDiscoveryNode)}
+        */
+        public Builder add(ProtobufDiscoveryNode node) {
+            final String preflight = validateAdd(node);
+            if (preflight != null) {
+                throw new IllegalArgumentException(preflight);
+            }
+            putUnsafe(node);
+            return this;
+        }
+
+        /**
+         * Get a node by its id
+        *
+        * @param nodeId id of the wanted node
+        * @return wanted node if it exists. Otherwise <code>null</code>
+        */
+        @Nullable
+        public ProtobufDiscoveryNode get(String nodeId) {
+            return nodes.get(nodeId);
+        }
+
+        private void putUnsafe(ProtobufDiscoveryNode node) {
+            nodes.put(node.getId(), node);
+        }
+
+        public Builder remove(String nodeId) {
+            nodes.remove(nodeId);
+            return this;
+        }
+
+        public Builder remove(ProtobufDiscoveryNode node) {
+            if (node.equals(nodes.get(node.getId()))) {
+                nodes.remove(node.getId());
+            }
+            return this;
+        }
+
+        public Builder clusterManagerNodeId(String clusterManagerNodeId) {
+            this.clusterManagerNodeId = clusterManagerNodeId;
+            return this;
+        }
+
+        /** @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #clusterManagerNodeId} */
+        @Deprecated
+        public Builder masterNodeId(String clusterManagerNodeId) {
+            return clusterManagerNodeId(clusterManagerNodeId);
+        }
+
+        public Builder localNodeId(String localNodeId) {
+            this.localNodeId = localNodeId;
+            return this;
+        }
+
+        /**
+         * Checks that a node can be safely added to this node collection.
+        *
+        * @return null if all is OK or an error message explaining why a node can not be added.
+        *
+        * Note: if this method returns a non-null value, calling {@link #add(ProtobufDiscoveryNode)} will fail with an
+        * exception
+        */
+        private String validateAdd(ProtobufDiscoveryNode node) {
+            for (ObjectCursor<ProtobufDiscoveryNode> cursor : nodes.values()) {
+                final ProtobufDiscoveryNode existingNode = cursor.value;
+                if (node.getAddress().equals(existingNode.getAddress()) && node.getId().equals(existingNode.getId()) == false) {
+                    return "can't add node " + node + ", found existing node " + existingNode + " with same address";
+                }
+                if (node.getId().equals(existingNode.getId()) && node.equals(existingNode) == false) {
+                    return "can't add node "
+                        + node
+                        + ", found existing node "
+                        + existingNode
+                        + " with the same id but is a different node instance";
+                }
+            }
+            return null;
+        }
+
+        public ProtobufDiscoveryNodes build() {
+            ImmutableOpenMap.Builder<String, ProtobufDiscoveryNode> dataNodesBuilder = ImmutableOpenMap.builder();
+            ImmutableOpenMap.Builder<String, ProtobufDiscoveryNode> clusterManagerNodesBuilder = ImmutableOpenMap.builder();
+            ImmutableOpenMap.Builder<String, ProtobufDiscoveryNode> ingestNodesBuilder = ImmutableOpenMap.builder();
+            Version minNodeVersion = null;
+            Version maxNodeVersion = null;
+            Version minNonClientNodeVersion = null;
+            Version maxNonClientNodeVersion = null;
+            for (ObjectObjectCursor<String, ProtobufDiscoveryNode> nodeEntry : nodes) {
+                if (nodeEntry.value.isDataNode()) {
+                    dataNodesBuilder.put(nodeEntry.key, nodeEntry.value);
+                }
+                if (nodeEntry.value.isClusterManagerNode()) {
+                    clusterManagerNodesBuilder.put(nodeEntry.key, nodeEntry.value);
+                }
+                final Version version = nodeEntry.value.getVersion();
+                if (nodeEntry.value.isDataNode() || nodeEntry.value.isClusterManagerNode()) {
+                    if (minNonClientNodeVersion == null) {
+                        minNonClientNodeVersion = version;
+                        maxNonClientNodeVersion = version;
+                    } else {
+                        minNonClientNodeVersion = Version.min(minNonClientNodeVersion, version);
+                        maxNonClientNodeVersion = Version.max(maxNonClientNodeVersion, version);
+                    }
+                }
+                if (nodeEntry.value.isIngestNode()) {
+                    ingestNodesBuilder.put(nodeEntry.key, nodeEntry.value);
+                }
+                minNodeVersion = minNodeVersion == null ? version : Version.min(minNodeVersion, version);
+                maxNodeVersion = maxNodeVersion == null ? version : Version.max(maxNodeVersion, version);
+            }
+
+            return new ProtobufDiscoveryNodes(
+                nodes.build(),
+                dataNodesBuilder.build(),
+                clusterManagerNodesBuilder.build(),
+                ingestNodesBuilder.build(),
+                clusterManagerNodeId,
+                localNodeId,
+                minNonClientNodeVersion == null ? Version.CURRENT : minNonClientNodeVersion,
+                maxNonClientNodeVersion == null ? Version.CURRENT : maxNonClientNodeVersion,
+                maxNodeVersion == null ? Version.CURRENT : maxNodeVersion,
+                minNodeVersion == null ? Version.CURRENT : minNodeVersion
+            );
+        }
+
+        public boolean isLocalNodeElectedClusterManager() {
+            return clusterManagerNodeId != null && clusterManagerNodeId.equals(localNodeId);
+        }
+
+        /** @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #isLocalNodeElectedClusterManager()} */
+        @Deprecated
+        public boolean isLocalNodeElectedMaster() {
+            return isLocalNodeElectedClusterManager();
+        }
+    }
+
+    /**
+     * Check if the given name of the node role is 'cluster_manager' or 'master'.
+    * The method is added for {@link #resolveNodes} to keep the code clear, when support the both above roles.
+    * @deprecated As of 2.0, because promoting inclusive language. MASTER_ROLE is deprecated.
+    * @param matchAttrName a given String for a name of the node role.
+    * @return true if the given roleName is 'cluster_manger' or 'master'
+    */
+    @Deprecated
+    private boolean roleNameIsClusterManager(String matchAttrName) {
+        return DiscoveryNodeRole.MASTER_ROLE.roleName().equals(matchAttrName)
+            || DiscoveryNodeRole.CLUSTER_MANAGER_ROLE.roleName().equals(matchAttrName);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/routing/RoutingNodes.java b/server/src/main/java/org/opensearch/cluster/routing/RoutingNodes.java
index 5402218664f6f..5b2ef369a930c 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/RoutingNodes.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/RoutingNodes.java
@@ -36,6 +36,7 @@
 import org.apache.lucene.util.CollectionUtil;
 import org.opensearch.core.Assertions;
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.ProtobufClusterState;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
@@ -161,6 +162,64 @@ public RoutingNodes(ClusterState clusterState, boolean readOnly) {
         }
     }
 
+    public RoutingNodes(ProtobufClusterState clusterState) {
+        this(clusterState, true);
+    }
+
+    public RoutingNodes(ProtobufClusterState clusterState, boolean readOnly) {
+        this.readOnly = readOnly;
+        final RoutingTable routingTable = clusterState.routingTable();
+
+        // fill in the nodeToShards with the "live" nodes
+        for (ObjectCursor<DiscoveryNode> cursor : clusterState.nodes().getDataNodes().values()) {
+            String nodeId = cursor.value.getId();
+            this.nodesToShards.put(cursor.value.getId(), new RoutingNode(nodeId, clusterState.nodes().get(nodeId)));
+        }
+
+        // fill in the inverse of node -> shards allocated
+        // also fill replicaSet information
+        for (ObjectCursor<IndexRoutingTable> indexRoutingTable : routingTable.indicesRouting().values()) {
+            for (IndexShardRoutingTable indexShard : indexRoutingTable.value) {
+                assert indexShard.primary != null;
+                for (ShardRouting shard : indexShard) {
+                    // to get all the shards belonging to an index, including the replicas,
+                    // we define a replica set and keep track of it. A replica set is identified
+                    // by the ShardId, as this is common for primary and replicas.
+                    // A replica Set might have one (and not more) replicas with the state of RELOCATING.
+                    if (shard.assignedToNode()) {
+                        RoutingNode routingNode = this.nodesToShards.computeIfAbsent(
+                            shard.currentNodeId(),
+                            k -> new RoutingNode(shard.currentNodeId(), clusterState.nodes().get(shard.currentNodeId()))
+                        );
+                        routingNode.add(shard);
+                        assignedShardsAdd(shard);
+                        if (shard.relocating()) {
+                            relocatingShards++;
+                            // Add the counterpart shard with relocatingNodeId reflecting the source from which
+                            // it's relocating from.
+                            routingNode = nodesToShards.computeIfAbsent(
+                                shard.relocatingNodeId(),
+                                k -> new RoutingNode(shard.relocatingNodeId(), clusterState.nodes().get(shard.relocatingNodeId()))
+                            );
+                            ShardRouting targetShardRouting = shard.getTargetRelocatingShard();
+                            addInitialRecovery(targetShardRouting, indexShard.primary);
+                            routingNode.add(targetShardRouting);
+                            assignedShardsAdd(targetShardRouting);
+                        } else if (shard.initializing()) {
+                            if (shard.primary()) {
+                                inactivePrimaryCount++;
+                            }
+                            inactiveShardCount++;
+                            addInitialRecovery(shard, indexShard.primary);
+                        }
+                    } else {
+                        unassignedShards.add(shard);
+                    }
+                }
+            }
+        }
+    }
+
     private void addRecovery(ShardRouting routing) {
         updateRecoveryCounts(routing, true, findAssignedPrimaryIfPeerRecovery(routing));
     }
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufNamedWriteable.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufNamedWriteable.java
new file mode 100644
index 0000000000000..174f99d7e7f07
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/io/stream/ProtobufNamedWriteable.java
@@ -0,0 +1,29 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.common.io.stream;
+
+/**
+ * A {@link Writeable} object identified by its name.
+* To be used for arbitrary serializable objects (e.g. queries); when reading them, their name tells
+* which specific object needs to be created.
+*
+* @opensearch.internal
+*/
+public interface ProtobufNamedWriteable extends ProtobufWriteable {
+
+    /**
+     * Returns the name of the writeable object
+    */
+    String getWriteableName();
+}
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java
index 843d6755e42d7..54c7ec6adbc57 100644
--- a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java
+++ b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java
@@ -11,17 +11,25 @@
 import com.google.protobuf.CodedInputStream;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
+import java.util.EnumSet;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.function.IntFunction;
 
 import org.apache.lucene.util.ArrayUtil;
 
 import org.opensearch.common.bytes.BytesArray;
 import org.opensearch.common.bytes.BytesReference;
+import org.opensearch.common.unit.TimeValue;
 import org.opensearch.Version;
 import org.opensearch.common.Nullable;
+import org.opensearch.common.Strings;
 
 /**
  * A class for additional methods to read from a {@link CodedInputStream}.
@@ -30,6 +38,8 @@ public class ProtobufStreamInput {
 
     private Version version = Version.CURRENT;
 
+    private static final TimeUnit[] TIME_UNITS = TimeUnit.values();
+
     /**
      * The version of the node on the other side of this stream.
      */
@@ -52,6 +62,24 @@ public String readOptionalString(CodedInputStream in) throws IOException {
         return null;
     }
 
+    @Nullable
+    public Long readOptionalLong(CodedInputStream in) throws IOException {
+        if (readBoolean(in)) {
+            return in.readInt64();
+        }
+        return null;
+    }
+
+    @Nullable
+    public final Boolean readOptionalBoolean(CodedInputStream in) throws IOException {
+        final byte value = in.readRawByte();
+        if (value == 2) {
+            return null;
+        } else {
+            return readBoolean(value);
+        }
+    }
+
     /**
      * If the returned map contains any entries it will be mutable. If it is empty it might be immutable.
      */
@@ -162,6 +190,51 @@ public BytesReference readBytesReference(int length, CodedInputStream in) throws
         return new BytesArray(bytes, 0, length);
     }
 
+    /**
+     * Read a {@link TimeValue} from the stream
+     */
+    public TimeValue readTimeValue(CodedInputStream in) throws IOException {
+        long duration = in.readInt64();
+        TimeUnit timeUnit = TIME_UNITS[in.readRawByte()];
+        return new TimeValue(duration, timeUnit);
+    }
+
+    public String[] readStringArray(CodedInputStream in) throws IOException {
+        int size = readArraySize(in);
+        if (size == 0) {
+            return Strings.EMPTY_ARRAY;
+        }
+        String[] ret = new String[size];
+        for (int i = 0; i < size; i++) {
+            ret[i] = in.readString();
+        }
+        return ret;
+    }
+
+    private <E extends Enum<E>> E readEnum(Class<E> enumClass, E[] values, CodedInputStream in) throws IOException {
+        int ordinal = readVInt(in);
+        if (ordinal < 0 || ordinal >= values.length) {
+            throw new IOException("Unknown " + enumClass.getSimpleName() + " ordinal [" + ordinal + "]");
+        }
+        return values[ordinal];
+    }
+
+    /**
+     * Reads an enum with type E that was serialized based on the value of it's ordinal
+     */
+    public <E extends Enum<E>> EnumSet<E> readEnumSet(Class<E> enumClass, CodedInputStream in) throws IOException {
+        int size = readVInt(in);
+        final EnumSet<E> res = EnumSet.noneOf(enumClass);
+        if (size == 0) {
+            return res;
+        }
+        final E[] values = enumClass.getEnumConstants();
+        for (int i = 0; i < size; i++) {
+            res.add(readEnum(enumClass, values, in));
+        }
+        return res;
+    }
+
     private boolean readBoolean(final byte value) {
         if (value == 0) {
             return false;
@@ -172,4 +245,86 @@ private boolean readBoolean(final byte value) {
             throw new IllegalStateException(message);
         }
     }
+
+    /**
+     * Reads a list of objects. The list is expected to have been written using {@link StreamOutput#writeList(List)}.
+     * If the returned list contains any entries it will be mutable. If it is empty it might be immutable.
+     *
+     * @return the list of objects
+     * @throws IOException if an I/O exception occurs reading the list
+     */
+    public <T> List<T> readList(final ProtobufWriteable.Reader<T> reader, CodedInputStream in) throws IOException {
+        return readCollection(reader, ArrayList::new, Collections.emptyList(), in);
+    }
+
+    /**
+     * Reads a collection of objects
+     */
+    private <T, C extends Collection<? super T>> C readCollection(
+        ProtobufWriteable.Reader<T> reader,
+        IntFunction<C> constructor,
+        C empty,
+        CodedInputStream in
+    ) throws IOException {
+        int count = readArraySize(in);
+        if (count == 0) {
+            return empty;
+        }
+        C builder = constructor.apply(count);
+        for (int i = 0; i < count; i++) {
+            builder.add(reader.read(in));
+        }
+        return builder;
+    }
+
+    /**
+     * Reads a {@link NamedWriteable} from the current stream, by first reading its name and then looking for
+     * the corresponding entry in the registry by name, so that the proper object can be read and returned.
+     * Default implementation throws {@link UnsupportedOperationException} as StreamInput doesn't hold a registry.
+     */
+    @Nullable
+    public <C extends ProtobufNamedWriteable> C readNamedWriteable(@SuppressWarnings("unused") Class<C> categoryClass) throws IOException {
+        throw new UnsupportedOperationException("can't read named writeable from StreamInput");
+    }
+
+    /**
+     * Reads a {@link ProtobufNamedWriteable} from the current stream with the given name. It is assumed that the caller obtained the name
+     * from other source, so it's not read from the stream. The name is used for looking for
+     * the corresponding entry in the registry by name, so that the proper object can be read and returned.
+     * Default implementation throws {@link UnsupportedOperationException} as StreamInput doesn't hold a registry.
+     */
+    @Nullable
+    public <C extends ProtobufNamedWriteable> C readNamedWriteable(
+        @SuppressWarnings("unused") Class<C> categoryClass,
+        @SuppressWarnings("unused") String name
+    ) throws IOException {
+        throw new UnsupportedOperationException("can't read named writeable from StreamInput");
+    }
+
+    public <T> T[] readOptionalArray(ProtobufWriteable.Reader<T> reader, IntFunction<T[]> arraySupplier, CodedInputStream in)
+        throws IOException {
+        return readBoolean(in) ? readArray(reader, arraySupplier, in) : null;
+    }
+
+    public <T> T[] readArray(final ProtobufWriteable.Reader<T> reader, final IntFunction<T[]> arraySupplier, CodedInputStream in)
+        throws IOException {
+        final int length = readArraySize(in);
+        final T[] values = arraySupplier.apply(length);
+        for (int i = 0; i < length; i++) {
+            values[i] = reader.read(in);
+        }
+        return values;
+    }
+
+    /**
+     * Read an optional {@link TimeValue} from the stream, returning null if no TimeValue was written.
+     */
+    public @Nullable TimeValue readOptionalTimeValue(CodedInputStream in) throws IOException {
+        if (readBoolean(in)) {
+            return readTimeValue(in);
+        } else {
+            return null;
+        }
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java
index b6082159d024a..5c6f7106938b8 100644
--- a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java
+++ b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java
@@ -11,10 +11,14 @@
 import com.google.protobuf.CodedOutputStream;
 
 import java.io.IOException;
+import java.util.Collection;
+import java.util.EnumSet;
 import java.util.Map;
 
 import org.opensearch.Version;
 import org.opensearch.common.Nullable;
+import org.opensearch.common.io.stream.ProtobufWriteable.Writer;
+import org.opensearch.common.unit.TimeValue;
 
 /**
  * A class for additional methods to write to a {@link CodedOutputStream}.
@@ -68,4 +72,120 @@ public void writeOptionalWriteable(@Nullable ProtobufWriteable writeable, CodedO
         }
     }
 
+    /**
+     * Write a {@link TimeValue} to the stream
+     */
+    public void writeTimeValue(TimeValue timeValue, CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(timeValue.duration());
+        out.writeRawByte((byte) timeValue.timeUnit().ordinal());
+    }
+
+    /**
+     * Writes an EnumSet with type E that by serialized it based on it's ordinal value
+     */
+    public <E extends Enum<E>> void writeEnumSet(EnumSet<E> enumSet, CodedOutputStream out) throws IOException {
+        out.writeInt32NoTag(enumSet.size());
+        for (E e : enumSet) {
+            out.writeEnumNoTag(e.ordinal());
+        }
+    }
+
+    public void writeOptionalLong(@Nullable Long l, CodedOutputStream out) throws IOException {
+        if (l == null) {
+            out.writeBoolNoTag(false);
+        } else {
+            out.writeBoolNoTag(true);
+            out.writeInt64NoTag(l);
+        }
+    }
+
+    public void writeOptionalString(@Nullable String str, CodedOutputStream out) throws IOException {
+        if (str == null) {
+            out.writeBoolNoTag(false);
+        } else {
+            out.writeBoolNoTag(true);
+            out.writeStringNoTag(str);
+        }
+    }
+
+    public void writeOptionalBoolean(@Nullable Boolean b, CodedOutputStream out) throws IOException {
+        byte two = 2;
+        if (b == null) {
+            out.write(two);
+        } else {
+            out.writeBoolNoTag(b);
+        }
+    }
+
+    /**
+     * Writes a collection of objects via a {@link Writer}.
+     *
+     * @param collection the collection of objects
+     * @throws IOException if an I/O exception occurs writing the collection
+     */
+    public <T> void writeCollection(final Collection<T> collection, final Writer<T> writer, CodedOutputStream out) throws IOException {
+        out.writeInt32NoTag(collection.size());
+        for (final T val : collection) {
+            writer.write(out, val);
+        }
+    }
+
+    public void writeStringArray(String[] array, CodedOutputStream out) throws IOException {
+        out.writeInt32NoTag(array.length);
+        for (String s : array) {
+            out.writeStringNoTag(s);
+        }
+    }
+
+    /**
+     * Writes a {@link ProtobufNamedWriteable} to the current stream, by first writing its name and then the object itself
+     */
+    public void writeNamedWriteable(ProtobufNamedWriteable namedWriteable, CodedOutputStream out) throws IOException {
+        out.writeStringNoTag(namedWriteable.getWriteableName());
+        namedWriteable.writeTo(out);
+    }
+
+    /**
+     * Writes a string array, for nullable string, writes it as 0 (empty string).
+     */
+    public void writeStringArrayNullable(@Nullable String[] array, CodedOutputStream out) throws IOException {
+        if (array == null) {
+            out.writeInt32NoTag(0);
+        } else {
+            writeStringArray(array, out);
+        }
+    }
+
+    /**
+     * Write an optional {@link TimeValue} to the stream.
+     */
+    public void writeOptionalTimeValue(@Nullable TimeValue timeValue, CodedOutputStream out) throws IOException {
+        if (timeValue == null) {
+            out.writeBoolNoTag(false);
+        } else {
+            out.writeBoolNoTag(true);
+            writeTimeValue(timeValue, out);
+        }
+    }
+
+    /**
+     * Same as {@link #writeArray(Writer, Object[], CodedOutputStream)} but the provided array may be null. An additional boolean value is
+     * serialized to indicate whether the array was null or not.
+     */
+    public <T> void writeOptionalArray(final Writer<T> writer, final @Nullable T[] array, CodedOutputStream out) throws IOException {
+        if (array == null) {
+            out.writeBoolNoTag(false);
+        } else {
+            out.writeBoolNoTag(true);
+            writeArray(writer, array, out);
+        }
+    }
+
+    public <T> void writeArray(final Writer<T> writer, final T[] array, CodedOutputStream out) throws IOException {
+        out.writeInt32NoTag(array.length);
+        for (T value : array) {
+            writer.write(out, value);
+        }
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufVersionedNamedWriteable.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufVersionedNamedWriteable.java
new file mode 100644
index 0000000000000..5e888abc9b0aa
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/io/stream/ProtobufVersionedNamedWriteable.java
@@ -0,0 +1,34 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.common.io.stream;
+
+import org.opensearch.Version;
+
+/**
+ * A {@link NamedWriteable} that has a minimum version associated with it.
+*
+* @opensearch.internal
+*/
+public interface ProtobufVersionedNamedWriteable extends ProtobufNamedWriteable {
+
+    /**
+     * Returns the name of the writeable object
+    */
+    String getWriteableName();
+
+    /**
+     * The minimal version of the recipient this object can be sent to
+    */
+    Version getMinimalSupportedVersion();
+}
diff --git a/server/src/main/java/org/opensearch/common/settings/Settings.java b/server/src/main/java/org/opensearch/common/settings/Settings.java
index cd80e9727e0df..1ed86bf045726 100644
--- a/server/src/main/java/org/opensearch/common/settings/Settings.java
+++ b/server/src/main/java/org/opensearch/common/settings/Settings.java
@@ -32,6 +32,8 @@
 
 package org.opensearch.common.settings;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
 import org.apache.logging.log4j.Level;
 import org.opensearch.OpenSearchGenerationException;
 import org.opensearch.OpenSearchParseException;
@@ -575,6 +577,23 @@ public static Settings readSettingsFromStream(StreamInput in) throws IOException
         return builder.build();
     }
 
+    public static Settings readSettingsFromStreamProtobuf(CodedInputStream in) throws IOException {
+        Builder builder = new Builder();
+        int numberOfSettings = in.readInt32();
+        for (int i = 0; i < numberOfSettings; i++) {
+            String key = in.readString();
+            Object value = in.readString();
+            if (value == null) {
+                builder.putNull(key);
+            } else if (value instanceof List) {
+                builder.putList(key, (List<String>) value);
+            } else {
+                builder.put(key, value.toString());
+            }
+        }
+        return builder.build();
+    }
+
     public static void writeSettingsToStream(Settings settings, StreamOutput out) throws IOException {
         // pull settings to exclude secure settings in size()
         Set<Map.Entry<String, Object>> entries = settings.settings.entrySet();
@@ -585,6 +604,16 @@ public static void writeSettingsToStream(Settings settings, StreamOutput out) th
         }
     }
 
+    public static void writeSettingsToStreamProtobuf(Settings settings, CodedOutputStream out) throws IOException {
+        // pull settings to exclude secure settings in size()
+        Set<Map.Entry<String, Object>> entries = settings.settings.entrySet();
+        out.writeInt32NoTag(entries.size());
+        for (Map.Entry<String, Object> entry : entries) {
+            out.writeStringNoTag(entry.getKey());
+            out.writeStringNoTag(entry.getValue().toString());
+        }
+    }
+
     /**
      * Returns a builder to be used in order to build settings.
      */
diff --git a/server/src/main/java/org/opensearch/common/transport/ProtobufBoundTransportAddress.java b/server/src/main/java/org/opensearch/common/transport/ProtobufBoundTransportAddress.java
new file mode 100644
index 0000000000000..97de0d42b5592
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/transport/ProtobufBoundTransportAddress.java
@@ -0,0 +1,68 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.common.transport;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+
+import java.io.IOException;
+
+/**
+ * A bounded transport address is a tuple of {@link TransportAddress}, one array that represents
+* the addresses the transport is bound to, and the other is the published one that represents the address clients
+* should communicate on.
+*
+* @opensearch.internal
+*/
+public class ProtobufBoundTransportAddress implements ProtobufWriteable {
+
+    private ProtobufTransportAddress[] boundAddresses;
+
+    private ProtobufTransportAddress publishAddress;
+
+    public ProtobufBoundTransportAddress(CodedInputStream in) throws IOException {
+        int boundAddressLength = in.readInt32();
+        boundAddresses = new ProtobufTransportAddress[boundAddressLength];
+        for (int i = 0; i < boundAddressLength; i++) {
+            boundAddresses[i] = new ProtobufTransportAddress(in);
+        }
+        publishAddress = new ProtobufTransportAddress(in);
+    }
+
+    public ProtobufBoundTransportAddress(ProtobufTransportAddress[] boundAddresses, ProtobufTransportAddress publishAddress) {
+        if (boundAddresses == null || boundAddresses.length < 1) {
+            throw new IllegalArgumentException("at least one bound address must be provided");
+        }
+        this.boundAddresses = boundAddresses;
+        this.publishAddress = publishAddress;
+    }
+
+    public ProtobufTransportAddress[] boundAddresses() {
+        return boundAddresses;
+    }
+
+    public ProtobufTransportAddress publishAddress() {
+        return publishAddress;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt32NoTag(boundAddresses.length);
+        for (ProtobufTransportAddress address : boundAddresses) {
+            address.writeTo(out);
+        }
+        publishAddress.writeTo(out);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/common/transport/ProtobufTransportAddress.java b/server/src/main/java/org/opensearch/common/transport/ProtobufTransportAddress.java
new file mode 100644
index 0000000000000..274c8404e11af
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/transport/ProtobufTransportAddress.java
@@ -0,0 +1,108 @@
+/*
+* 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.
+*/
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.common.transport;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.network.NetworkAddress;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.UnknownHostException;
+
+/**
+ * A transport address used for IP socket address (wraps {@link java.net.InetSocketAddress}).
+*
+* @opensearch.internal
+*/
+public final class ProtobufTransportAddress implements ProtobufWriteable {
+
+    /**
+     * A <a href="https://en.wikipedia.org/wiki/0.0.0.0">non-routeable v4 meta transport address</a> that can be used for
+    * testing or in scenarios where targets should be marked as non-applicable from a transport perspective.
+    */
+    public static final InetAddress META_ADDRESS;
+
+    static {
+        try {
+            META_ADDRESS = InetAddress.getByName("0.0.0.0");
+        } catch (UnknownHostException e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    private final InetSocketAddress address;
+
+    public ProtobufTransportAddress(InetAddress address, int port) {
+        this(new InetSocketAddress(address, port));
+    }
+
+    public ProtobufTransportAddress(InetSocketAddress address) {
+        if (address == null) {
+            throw new IllegalArgumentException("InetSocketAddress must not be null");
+        }
+        if (address.getAddress() == null) {
+            throw new IllegalArgumentException("Address must be resolved but wasn't - InetSocketAddress#getAddress() returned null");
+        }
+        this.address = address;
+    }
+
+    /**
+     * Read from a stream.
+     */
+    public ProtobufTransportAddress(CodedInputStream in) throws IOException {
+        final int len = in.readRawByte();
+        final byte[] a = new byte[len]; // 4 bytes (IPv4) or 16 bytes (IPv6)
+        in.readRawBytes(len);
+        String host = in.readString(); // the host string was serialized so we can ignore the passed in version
+        final InetAddress inetAddress = InetAddress.getByAddress(host, a);
+        int port = in.readInt32();
+        this.address = new InetSocketAddress(inetAddress, port);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        byte[] bytes = address.getAddress().getAddress();  // 4 bytes (IPv4) or 16 bytes (IPv6)
+        out.write((byte) bytes.length); // 1 byte
+        out.write(bytes, 0, bytes.length);
+        out.writeStringNoTag(address.getHostString());
+        // don't serialize scope ids over the network!!!!
+        // these only make sense with respect to the local machine, and will only formulate
+        // the address incorrectly remotely.
+        out.writeInt32NoTag(address.getPort());
+    }
+
+    /**
+     * Returns a string representation of the enclosed {@link InetSocketAddress}
+    * @see NetworkAddress#format(InetAddress)
+    */
+    public String getAddress() {
+        return NetworkAddress.format(address.getAddress());
+    }
+
+    /**
+     * Returns the addresses port
+    */
+    public int getPort() {
+        return address.getPort();
+    }
+
+    /**
+     * Returns the enclosed {@link InetSocketAddress}
+    */
+    public InetSocketAddress address() {
+        return this.address;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/common/unit/ProtobufSizeValue.java b/server/src/main/java/org/opensearch/common/unit/ProtobufSizeValue.java
new file mode 100644
index 0000000000000..201b74d4a83c3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/unit/ProtobufSizeValue.java
@@ -0,0 +1,136 @@
+/*
+* 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.
+*/
+
+package org.opensearch.common.unit;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+
+import java.io.IOException;
+
+/**
+ * Conversion values.
+*
+* @opensearch.internal
+*/
+public class ProtobufSizeValue implements ProtobufWriteable {
+
+    private final long size;
+    private final SizeUnit sizeUnit;
+
+    public ProtobufSizeValue(long singles) {
+        this(singles, SizeUnit.SINGLE);
+    }
+
+    public ProtobufSizeValue(long size, SizeUnit sizeUnit) {
+        if (size < 0) {
+            throw new IllegalArgumentException("size in SizeValue may not be negative");
+        }
+        this.size = size;
+        this.sizeUnit = sizeUnit;
+    }
+
+    public ProtobufSizeValue(CodedInputStream in) throws IOException {
+        size = in.readInt64();
+        sizeUnit = SizeUnit.SINGLE;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(singles());
+    }
+
+    public long singles() {
+        return sizeUnit.toSingles(size);
+    }
+
+    public long getSingles() {
+        return singles();
+    }
+
+    public long kilo() {
+        return sizeUnit.toKilo(size);
+    }
+
+    public long getKilo() {
+        return kilo();
+    }
+
+    public long mega() {
+        return sizeUnit.toMega(size);
+    }
+
+    public long getMega() {
+        return mega();
+    }
+
+    public long giga() {
+        return sizeUnit.toGiga(size);
+    }
+
+    public long getGiga() {
+        return giga();
+    }
+
+    public long tera() {
+        return sizeUnit.toTera(size);
+    }
+
+    public long getTera() {
+        return tera();
+    }
+
+    public long peta() {
+        return sizeUnit.toPeta(size);
+    }
+
+    public long getPeta() {
+        return peta();
+    }
+
+    public double kiloFrac() {
+        return ((double) singles()) / SizeUnit.C1;
+    }
+
+    public double getKiloFrac() {
+        return kiloFrac();
+    }
+
+    public double megaFrac() {
+        return ((double) singles()) / SizeUnit.C2;
+    }
+
+    public double getMegaFrac() {
+        return megaFrac();
+    }
+
+    public double gigaFrac() {
+        return ((double) singles()) / SizeUnit.C3;
+    }
+
+    public double getGigaFrac() {
+        return gigaFrac();
+    }
+
+    public double teraFrac() {
+        return ((double) singles()) / SizeUnit.C4;
+    }
+
+    public double getTeraFrac() {
+        return teraFrac();
+    }
+
+    public double petaFrac() {
+        return ((double) singles()) / SizeUnit.C5;
+    }
+
+    public double getPetaFrac() {
+        return petaFrac();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java b/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
index 1e1d70f1468dd..924a773b578be 100644
--- a/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
+++ b/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
@@ -31,12 +31,15 @@
 
 package org.opensearch.common.util.concurrent;
 
+import com.google.protobuf.CodedOutputStream;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.opensearch.action.support.ContextPreservingActionListener;
 import org.opensearch.client.OriginSettingClient;
 import org.opensearch.common.collect.MapBuilder;
 import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
@@ -99,7 +102,7 @@
  *
  * @opensearch.internal
  */
-public final class ThreadContext implements Writeable {
+public final class ThreadContext implements Writeable, ProtobufWriteable {
 
     public static final String PREFIX = "request.headers";
     public static final Setting<Settings> DEFAULT_HEADERS_SETTING = Setting.groupSetting(PREFIX + ".", Property.NodeScope);
@@ -185,6 +188,25 @@ public Writeable captureAsWriteable() {
         };
     }
 
+    /**
+     * Captures the current thread context as writeable, allowing it to be serialized out later
+     */
+    public ProtobufWriteable captureAsWriteable() {
+        final ThreadContextStruct context = threadLocal.get();
+        return out -> {
+            final Map<String, String> propagatedHeaders = propagateHeaders(context.transientHeaders);
+            context.writeTo(out, defaultHeader, propagatedHeaders);
+        };
+    }
+
+    /**
+     * Captures the current thread context as writeable, allowing it to be serialized out later
+     */
+    public ProtobufWriteable captureAsWriteable() {
+        final ThreadContextStruct context = threadLocal.get();
+        return out -> context.writeTo(out, defaultHeader);
+    }
+
     /**
      * Removes the current context and resets a default context marked with as
      * originating from the supplied string. The removed context can be
@@ -828,6 +850,25 @@ private void writeTo(StreamOutput out, Map<String, String> defaultHeaders, Map<S
 
             out.writeMap(responseHeaders, StreamOutput::writeString, StreamOutput::writeStringCollection);
         }
+
+        private void writeTo(CodedOutputStream out, Map<String, String> defaultHeaders) throws IOException {
+            final Map<String, String> requestHeaders;
+            if (defaultHeaders.isEmpty()) {
+                requestHeaders = this.requestHeaders;
+            } else {
+                requestHeaders = new HashMap<>(defaultHeaders);
+                requestHeaders.putAll(this.requestHeaders);
+            }
+
+            out.writeInt32NoTag(requestHeaders.size());
+            for (Map.Entry<String, String> entry : requestHeaders.entrySet()) {
+                out.writeStringNoTag(entry.getKey());
+                out.writeStringNoTag(entry.getValue());
+            }
+
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+            protobufStreamOutput.writeMap(responseHeaders, CodedOutputStream::writeStringNoTag, CodedOutputStream::writeStringNoTag, out);
+        }
     }
 
     /**
@@ -960,4 +1001,9 @@ public Set<Characteristics> characteristics() {
         }
     }
 
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        threadLocal.get().writeTo(out, defaultHeader);
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/http/ProtobufHttpInfo.java b/server/src/main/java/org/opensearch/http/ProtobufHttpInfo.java
new file mode 100644
index 0000000000000..612c98e7df7e8
--- /dev/null
+++ b/server/src/main/java/org/opensearch/http/ProtobufHttpInfo.java
@@ -0,0 +1,64 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.http;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.node.ProtobufReportingService;
+
+import java.io.IOException;
+
+/**
+ * Information about an http connection
+*
+* @opensearch.internal
+*/
+public class ProtobufHttpInfo implements ProtobufReportingService.ProtobufInfo {
+
+    private final ProtobufBoundTransportAddress address;
+    private final long maxContentLength;
+
+    public ProtobufHttpInfo(CodedInputStream in) throws IOException {
+        this(new ProtobufBoundTransportAddress(in), in.readInt64());
+    }
+
+    public ProtobufHttpInfo(ProtobufBoundTransportAddress address, long maxContentLength) {
+        this.address = address;
+        this.maxContentLength = maxContentLength;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        address.writeTo(out);
+        out.writeInt64NoTag(maxContentLength);
+    }
+
+    public ProtobufBoundTransportAddress address() {
+        return address;
+    }
+
+    public ProtobufBoundTransportAddress getAddress() {
+        return address();
+    }
+
+    public ByteSizeValue maxContentLength() {
+        return new ByteSizeValue(maxContentLength);
+    }
+
+    public ByteSizeValue getMaxContentLength() {
+        return maxContentLength();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/ingest/ProtobufIngestInfo.java b/server/src/main/java/org/opensearch/ingest/ProtobufIngestInfo.java
new file mode 100644
index 0000000000000..d7a72cb078219
--- /dev/null
+++ b/server/src/main/java/org/opensearch/ingest/ProtobufIngestInfo.java
@@ -0,0 +1,59 @@
+/*
+* 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.
+*/
+
+package org.opensearch.ingest;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.node.ProtobufReportingService;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+/**
+ * Information about an ingest event
+*
+* @opensearch.internal
+*/
+public class ProtobufIngestInfo implements ProtobufReportingService.ProtobufInfo {
+
+    private final Set<ProtobufProcessorInfo> processors;
+
+    public ProtobufIngestInfo(List<ProtobufProcessorInfo> processors) {
+        this.processors = new TreeSet<>(processors);  // we use a treeset here to have a test-able / predictable order
+    }
+
+    /**
+     * Read from a stream.
+    */
+    public ProtobufIngestInfo(CodedInputStream in) throws IOException {
+        processors = new TreeSet<>();
+        final int size = in.readInt32();
+        for (int i = 0; i < size; i++) {
+            processors.add(new ProtobufProcessorInfo(in));
+        }
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt32NoTag(processors.size());
+        for (ProtobufProcessorInfo info : processors) {
+            info.writeTo(out);
+        }
+    }
+
+    public Iterable<ProtobufProcessorInfo> getProcessors() {
+        return processors;
+    }
+
+    public boolean containsProcessor(String type) {
+        return processors.contains(new ProtobufProcessorInfo(type));
+    }
+}
diff --git a/server/src/main/java/org/opensearch/ingest/ProtobufProcessorInfo.java b/server/src/main/java/org/opensearch/ingest/ProtobufProcessorInfo.java
new file mode 100644
index 0000000000000..debfcc669921c
--- /dev/null
+++ b/server/src/main/java/org/opensearch/ingest/ProtobufProcessorInfo.java
@@ -0,0 +1,48 @@
+/*
+* 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.
+*/
+
+package org.opensearch.ingest;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+
+import java.io.IOException;
+
+/**
+ * Information about an ingest processor
+*
+* @opensearch.internal
+*/
+public class ProtobufProcessorInfo implements ProtobufWriteable {
+
+    private final String type;
+
+    public ProtobufProcessorInfo(String type) {
+        this.type = type;
+    }
+
+    /**
+     * Read from a stream.
+    */
+    public ProtobufProcessorInfo(CodedInputStream input) throws IOException {
+        type = input.readString();
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeStringNoTag(this.type);
+    }
+
+    /**
+     * @return The unique processor type
+    */
+    public String getType() {
+        return type;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java b/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java
new file mode 100644
index 0000000000000..03add10433c54
--- /dev/null
+++ b/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java
@@ -0,0 +1,571 @@
+/*
+* 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.
+*/
+
+package org.opensearch.monitor.jvm;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.apache.lucene.util.Constants;
+import org.opensearch.common.Booleans;
+import org.opensearch.common.SuppressForbidden;
+import org.opensearch.common.io.PathUtils;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.node.ProtobufReportingService;
+
+import java.io.IOException;
+import java.lang.management.GarbageCollectorMXBean;
+import java.lang.management.ManagementFactory;
+import java.lang.management.ManagementPermission;
+import java.lang.management.MemoryMXBean;
+import java.lang.management.MemoryPoolMXBean;
+import java.lang.management.PlatformManagedObject;
+import java.lang.management.RuntimeMXBean;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Holds information about the JVM
+*
+* @opensearch.internal
+*/
+public class ProtobufJvmInfo implements ProtobufReportingService.ProtobufInfo {
+
+    private static ProtobufJvmInfo INSTANCE;
+
+    static {
+        RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
+        MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
+
+        long heapInit = memoryMXBean.getHeapMemoryUsage().getInit() < 0 ? 0 : memoryMXBean.getHeapMemoryUsage().getInit();
+        long heapMax = memoryMXBean.getHeapMemoryUsage().getMax() < 0 ? 0 : memoryMXBean.getHeapMemoryUsage().getMax();
+        long nonHeapInit = memoryMXBean.getNonHeapMemoryUsage().getInit() < 0 ? 0 : memoryMXBean.getNonHeapMemoryUsage().getInit();
+        long nonHeapMax = memoryMXBean.getNonHeapMemoryUsage().getMax() < 0 ? 0 : memoryMXBean.getNonHeapMemoryUsage().getMax();
+        long directMemoryMax = 0;
+        try {
+            Class<?> vmClass = Class.forName("sun.misc.VM");
+            directMemoryMax = (Long) vmClass.getMethod("maxDirectMemory").invoke(null);
+        } catch (Exception t) {
+            // ignore
+        }
+        String[] inputArguments = runtimeMXBean.getInputArguments().toArray(new String[0]);
+        Mem mem = new Mem(heapInit, heapMax, nonHeapInit, nonHeapMax, directMemoryMax);
+
+        String bootClassPath;
+        try {
+            bootClassPath = runtimeMXBean.getBootClassPath();
+        } catch (UnsupportedOperationException e) {
+            // oracle java 9
+            bootClassPath = System.getProperty("sun.boot.class.path");
+            if (bootClassPath == null) {
+                // something else
+                bootClassPath = "<unknown>";
+            }
+        }
+        String classPath = runtimeMXBean.getClassPath();
+        Map<String, String> systemProperties = Collections.unmodifiableMap(runtimeMXBean.getSystemProperties());
+
+        List<GarbageCollectorMXBean> gcMxBeans = ManagementFactory.getGarbageCollectorMXBeans();
+        String[] gcCollectors = new String[gcMxBeans.size()];
+        for (int i = 0; i < gcMxBeans.size(); i++) {
+            GarbageCollectorMXBean gcMxBean = gcMxBeans.get(i);
+            gcCollectors[i] = gcMxBean.getName();
+        }
+
+        List<MemoryPoolMXBean> memoryPoolMXBeans = ManagementFactory.getMemoryPoolMXBeans();
+        String[] memoryPools = new String[memoryPoolMXBeans.size()];
+        for (int i = 0; i < memoryPoolMXBeans.size(); i++) {
+            MemoryPoolMXBean memoryPoolMXBean = memoryPoolMXBeans.get(i);
+            memoryPools[i] = memoryPoolMXBean.getName();
+        }
+
+        String onError = null;
+        String onOutOfMemoryError = null;
+        String useCompressedOops = "unknown";
+        String useG1GC = "unknown";
+        long g1RegisionSize = -1;
+        String useSerialGC = "unknown";
+        long configuredInitialHeapSize = -1;
+        long configuredMaxHeapSize = -1;
+        try {
+            @SuppressWarnings("unchecked")
+            Class<? extends PlatformManagedObject> clazz = (Class<? extends PlatformManagedObject>) Class.forName(
+                "com.sun.management.HotSpotDiagnosticMXBean"
+            );
+            Class<?> vmOptionClazz = Class.forName("com.sun.management.VMOption");
+            PlatformManagedObject hotSpotDiagnosticMXBean = ManagementFactory.getPlatformMXBean(clazz);
+            Method vmOptionMethod = clazz.getMethod("getVMOption", String.class);
+            Method valueMethod = vmOptionClazz.getMethod("getValue");
+
+            try {
+                Object onErrorObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "OnError");
+                onError = (String) valueMethod.invoke(onErrorObject);
+            } catch (Exception ignored) {}
+
+            try {
+                Object onOutOfMemoryErrorObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "OnOutOfMemoryError");
+                onOutOfMemoryError = (String) valueMethod.invoke(onOutOfMemoryErrorObject);
+            } catch (Exception ignored) {}
+
+            try {
+                Object useCompressedOopsVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "UseCompressedOops");
+                useCompressedOops = (String) valueMethod.invoke(useCompressedOopsVmOptionObject);
+            } catch (Exception ignored) {}
+
+            try {
+                Object useG1GCVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "UseG1GC");
+                useG1GC = (String) valueMethod.invoke(useG1GCVmOptionObject);
+                Object regionSizeVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "G1HeapRegionSize");
+                g1RegisionSize = Long.parseLong((String) valueMethod.invoke(regionSizeVmOptionObject));
+            } catch (Exception ignored) {}
+
+            try {
+                Object initialHeapSizeVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "InitialHeapSize");
+                configuredInitialHeapSize = Long.parseLong((String) valueMethod.invoke(initialHeapSizeVmOptionObject));
+            } catch (Exception ignored) {}
+
+            try {
+                Object maxHeapSizeVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "MaxHeapSize");
+                configuredMaxHeapSize = Long.parseLong((String) valueMethod.invoke(maxHeapSizeVmOptionObject));
+            } catch (Exception ignored) {}
+
+            try {
+                Object useSerialGCVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "UseSerialGC");
+                useSerialGC = (String) valueMethod.invoke(useSerialGCVmOptionObject);
+            } catch (Exception ignored) {}
+
+        } catch (Exception ignored) {
+
+        }
+
+        final boolean bundledJdk = Booleans.parseBoolean(System.getProperty("opensearch.bundled_jdk", Boolean.FALSE.toString()));
+        final Boolean usingBundledJdk = bundledJdk ? usingBundledJdk() : null;
+
+        INSTANCE = new ProtobufJvmInfo(
+            JvmPid.getPid(),
+            System.getProperty("java.version"),
+            runtimeMXBean.getVmName(),
+            runtimeMXBean.getVmVersion(),
+            runtimeMXBean.getVmVendor(),
+            bundledJdk,
+            usingBundledJdk,
+            runtimeMXBean.getStartTime(),
+            configuredInitialHeapSize,
+            configuredMaxHeapSize,
+            mem,
+            inputArguments,
+            bootClassPath,
+            classPath,
+            systemProperties,
+            gcCollectors,
+            memoryPools,
+            onError,
+            onOutOfMemoryError,
+            useCompressedOops,
+            useG1GC,
+            useSerialGC,
+            g1RegisionSize
+        );
+    }
+
+    @SuppressForbidden(reason = "PathUtils#get")
+    private static boolean usingBundledJdk() {
+        /*
+        * We are using the bundled JDK if java.home is the jdk sub-directory of our working directory. This is because we always set
+        * the working directory of Elasticsearch to home, and the bundled JDK is in the jdk sub-directory there.
+        */
+        final String javaHome = System.getProperty("java.home");
+        final String userDir = System.getProperty("user.dir");
+        if (Constants.MAC_OS_X) {
+            return PathUtils.get(javaHome).equals(PathUtils.get(userDir).resolve("jdk.app/Contents/Home").toAbsolutePath());
+        } else {
+            return PathUtils.get(javaHome).equals(PathUtils.get(userDir).resolve("jdk").toAbsolutePath());
+        }
+    }
+
+    public static ProtobufJvmInfo jvmInfo() {
+        SecurityManager sm = System.getSecurityManager();
+        if (sm != null) {
+            sm.checkPermission(new ManagementPermission("monitor"));
+            sm.checkPropertyAccess("*");
+        }
+        return INSTANCE;
+    }
+
+    private final long pid;
+    private final String version;
+    private final String vmName;
+    private final String vmVersion;
+    private final String vmVendor;
+    private final boolean bundledJdk;
+    private final Boolean usingBundledJdk;
+    private final long startTime;
+    private final long configuredInitialHeapSize;
+    private final long configuredMaxHeapSize;
+    private final Mem mem;
+    private final String[] inputArguments;
+    private final String bootClassPath;
+    private final String classPath;
+    private final Map<String, String> systemProperties;
+    private final String[] gcCollectors;
+    private final String[] memoryPools;
+    private final String onError;
+    private final String onOutOfMemoryError;
+    private final String useCompressedOops;
+    private final String useG1GC;
+    private final String useSerialGC;
+    private final long g1RegionSize;
+
+    private ProtobufJvmInfo(
+        long pid,
+        String version,
+        String vmName,
+        String vmVersion,
+        String vmVendor,
+        boolean bundledJdk,
+        Boolean usingBundledJdk,
+        long startTime,
+        long configuredInitialHeapSize,
+        long configuredMaxHeapSize,
+        Mem mem,
+        String[] inputArguments,
+        String bootClassPath,
+        String classPath,
+        Map<String, String> systemProperties,
+        String[] gcCollectors,
+        String[] memoryPools,
+        String onError,
+        String onOutOfMemoryError,
+        String useCompressedOops,
+        String useG1GC,
+        String useSerialGC,
+        long g1RegionSize
+    ) {
+        this.pid = pid;
+        this.version = version;
+        this.vmName = vmName;
+        this.vmVersion = vmVersion;
+        this.vmVendor = vmVendor;
+        this.bundledJdk = bundledJdk;
+        this.usingBundledJdk = usingBundledJdk;
+        this.startTime = startTime;
+        this.configuredInitialHeapSize = configuredInitialHeapSize;
+        this.configuredMaxHeapSize = configuredMaxHeapSize;
+        this.mem = mem;
+        this.inputArguments = inputArguments;
+        this.bootClassPath = bootClassPath;
+        this.classPath = classPath;
+        this.systemProperties = systemProperties;
+        this.gcCollectors = gcCollectors;
+        this.memoryPools = memoryPools;
+        this.onError = onError;
+        this.onOutOfMemoryError = onOutOfMemoryError;
+        this.useCompressedOops = useCompressedOops;
+        this.useG1GC = useG1GC;
+        this.useSerialGC = useSerialGC;
+        this.g1RegionSize = g1RegionSize;
+    }
+
+    public ProtobufJvmInfo(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        pid = in.readInt64();
+        version = in.readString();
+        vmName = in.readString();
+        vmVersion = in.readString();
+        vmVendor = in.readString();
+        bundledJdk = in.readBool();
+        usingBundledJdk = protobufStreamInput.readOptionalBoolean(in);
+        startTime = in.readInt64();
+        inputArguments = new String[in.readInt32()];
+        for (int i = 0; i < inputArguments.length; i++) {
+            inputArguments[i] = in.readString();
+        }
+        bootClassPath = in.readString();
+        classPath = in.readString();
+        systemProperties = protobufStreamInput.readMap(CodedInputStream::readString, CodedInputStream::readString, in);
+        mem = new Mem(in);
+        gcCollectors = protobufStreamInput.readStringArray(in);
+        memoryPools = protobufStreamInput.readStringArray(in);
+        useCompressedOops = in.readString();
+        // the following members are only used locally for bootstrap checks, never serialized nor printed out
+        this.configuredMaxHeapSize = -1;
+        this.configuredInitialHeapSize = -1;
+        this.onError = null;
+        this.onOutOfMemoryError = null;
+        this.useG1GC = "unknown";
+        this.useSerialGC = "unknown";
+        this.g1RegionSize = -1;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        out.writeInt64NoTag(pid);
+        out.writeStringNoTag(version);
+        out.writeStringNoTag(vmName);
+        out.writeStringNoTag(vmVersion);
+        out.writeStringNoTag(vmVendor);
+        out.writeBoolNoTag(bundledJdk);
+        protobufStreamOutput.writeOptionalBoolean(usingBundledJdk, out);
+        out.writeInt64NoTag(startTime);
+        out.writeInt32NoTag(inputArguments.length);
+        for (String inputArgument : inputArguments) {
+            out.writeStringNoTag(inputArgument);
+        }
+        out.writeStringNoTag(bootClassPath);
+        out.writeStringNoTag(classPath);
+        out.writeInt32NoTag(this.systemProperties.size());
+        for (Map.Entry<String, String> entry : systemProperties.entrySet()) {
+            out.writeStringNoTag(entry.getKey());
+            out.writeStringNoTag(entry.getValue());
+        }
+        mem.writeTo(out);
+        protobufStreamOutput.writeStringArray(gcCollectors, out);
+        protobufStreamOutput.writeStringArray(memoryPools, out);
+        out.writeStringNoTag(useCompressedOops);
+    }
+
+    /**
+     * The process id.
+    */
+    public long pid() {
+        return this.pid;
+    }
+
+    /**
+     * The process id.
+    */
+    public long getPid() {
+        return pid;
+    }
+
+    public String version() {
+        return this.version;
+    }
+
+    public String getVersion() {
+        return this.version;
+    }
+
+    public int versionAsInteger() {
+        try {
+            int i = 0;
+            StringBuilder sVersion = new StringBuilder();
+            for (; i < version.length(); i++) {
+                if (!Character.isDigit(version.charAt(i)) && version.charAt(i) != '.') {
+                    break;
+                }
+                if (version.charAt(i) != '.') {
+                    sVersion.append(version.charAt(i));
+                }
+            }
+            if (i == 0) {
+                return -1;
+            }
+            return Integer.parseInt(sVersion.toString());
+        } catch (Exception e) {
+            return -1;
+        }
+    }
+
+    public int versionUpdatePack() {
+        try {
+            int i = 0;
+            StringBuilder sVersion = new StringBuilder();
+            for (; i < version.length(); i++) {
+                if (!Character.isDigit(version.charAt(i)) && version.charAt(i) != '.') {
+                    break;
+                }
+                if (version.charAt(i) != '.') {
+                    sVersion.append(version.charAt(i));
+                }
+            }
+            if (i == 0) {
+                return -1;
+            }
+            Integer.parseInt(sVersion.toString());
+            int from;
+            if (version.charAt(i) == '_') {
+                // 1.7.0_4
+                from = ++i;
+            } else if (version.charAt(i) == '-' && version.charAt(i + 1) == 'u') {
+                // 1.7.0-u2-b21
+                i = i + 2;
+                from = i;
+            } else {
+                return -1;
+            }
+            for (; i < version.length(); i++) {
+                if (!Character.isDigit(version.charAt(i)) && version.charAt(i) != '.') {
+                    break;
+                }
+            }
+            if (from == i) {
+                return -1;
+            }
+            return Integer.parseInt(version.substring(from, i));
+        } catch (Exception e) {
+            return -1;
+        }
+    }
+
+    public String getVmName() {
+        return this.vmName;
+    }
+
+    public String getVmVersion() {
+        return this.vmVersion;
+    }
+
+    public String getVmVendor() {
+        return this.vmVendor;
+    }
+
+    public boolean getBundledJdk() {
+        return bundledJdk;
+    }
+
+    public Boolean getUsingBundledJdk() {
+        return usingBundledJdk;
+    }
+
+    public long getStartTime() {
+        return this.startTime;
+    }
+
+    public Mem getMem() {
+        return this.mem;
+    }
+
+    public String[] getInputArguments() {
+        return this.inputArguments;
+    }
+
+    public String getBootClassPath() {
+        return this.bootClassPath;
+    }
+
+    public String getClassPath() {
+        return this.classPath;
+    }
+
+    public Map<String, String> getSystemProperties() {
+        return this.systemProperties;
+    }
+
+    public long getConfiguredInitialHeapSize() {
+        return configuredInitialHeapSize;
+    }
+
+    public long getConfiguredMaxHeapSize() {
+        return configuredMaxHeapSize;
+    }
+
+    public String onError() {
+        return onError;
+    }
+
+    public String onOutOfMemoryError() {
+        return onOutOfMemoryError;
+    }
+
+    /**
+     * The value of the JVM flag UseCompressedOops, if available otherwise
+    * "unknown". The value "unknown" indicates that an attempt was
+    * made to obtain the value of the flag on this JVM and the attempt
+    * failed.
+    *
+    * @return the value of the JVM flag UseCompressedOops or "unknown"
+    */
+    public String useCompressedOops() {
+        return this.useCompressedOops;
+    }
+
+    public String useG1GC() {
+        return this.useG1GC;
+    }
+
+    public String useSerialGC() {
+        return this.useSerialGC;
+    }
+
+    public long getG1RegionSize() {
+        return g1RegionSize;
+    }
+
+    public String[] getGcCollectors() {
+        return gcCollectors;
+    }
+
+    public String[] getMemoryPools() {
+        return memoryPools;
+    }
+
+    /**
+     * Memory information.
+    *
+    * @opensearch.internal
+    */
+    public static class Mem implements ProtobufWriteable {
+
+        private final long heapInit;
+        private final long heapMax;
+        private final long nonHeapInit;
+        private final long nonHeapMax;
+        private final long directMemoryMax;
+
+        public Mem(long heapInit, long heapMax, long nonHeapInit, long nonHeapMax, long directMemoryMax) {
+            this.heapInit = heapInit;
+            this.heapMax = heapMax;
+            this.nonHeapInit = nonHeapInit;
+            this.nonHeapMax = nonHeapMax;
+            this.directMemoryMax = directMemoryMax;
+        }
+
+        public Mem(CodedInputStream in) throws IOException {
+            this.heapInit = in.readInt64();
+            this.heapMax = in.readInt64();
+            this.nonHeapInit = in.readInt64();
+            this.nonHeapMax = in.readInt64();
+            this.directMemoryMax = in.readInt64();
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeInt64NoTag(heapInit);
+            out.writeInt64NoTag(heapMax);
+            out.writeInt64NoTag(nonHeapInit);
+            out.writeInt64NoTag(nonHeapMax);
+            out.writeInt64NoTag(directMemoryMax);
+        }
+
+        public ByteSizeValue getHeapInit() {
+            return new ByteSizeValue(heapInit);
+        }
+
+        public ByteSizeValue getHeapMax() {
+            return new ByteSizeValue(heapMax);
+        }
+
+        public ByteSizeValue getNonHeapInit() {
+            return new ByteSizeValue(nonHeapInit);
+        }
+
+        public ByteSizeValue getNonHeapMax() {
+            return new ByteSizeValue(nonHeapMax);
+        }
+
+        public ByteSizeValue getDirectMemoryMax() {
+            return new ByteSizeValue(directMemoryMax);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/monitor/os/ProtobufOsInfo.java b/server/src/main/java/org/opensearch/monitor/os/ProtobufOsInfo.java
new file mode 100644
index 0000000000000..e2ce99b62344f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/monitor/os/ProtobufOsInfo.java
@@ -0,0 +1,103 @@
+/*
+* 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.
+*/
+
+package org.opensearch.monitor.os;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.node.ProtobufReportingService;
+
+import java.io.IOException;
+
+/**
+ * Holds Operating System Information
+*
+* @opensearch.internal
+*/
+public class ProtobufOsInfo implements ProtobufReportingService.ProtobufInfo {
+
+    private final long refreshInterval;
+    private final int availableProcessors;
+    private final int allocatedProcessors;
+    private final String name;
+    private final String prettyName;
+    private final String arch;
+    private final String version;
+
+    public ProtobufOsInfo(
+        final long refreshInterval,
+        final int availableProcessors,
+        final int allocatedProcessors,
+        final String name,
+        final String prettyName,
+        final String arch,
+        final String version
+    ) {
+        this.refreshInterval = refreshInterval;
+        this.availableProcessors = availableProcessors;
+        this.allocatedProcessors = allocatedProcessors;
+        this.name = name;
+        this.prettyName = prettyName;
+        this.arch = arch;
+        this.version = version;
+    }
+
+    public ProtobufOsInfo(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        this.refreshInterval = in.readInt64();
+        this.availableProcessors = in.readInt32();
+        this.allocatedProcessors = in.readInt32();
+        this.name = protobufStreamInput.readOptionalString(in);
+        this.prettyName = protobufStreamInput.readOptionalString(in);
+        this.arch = protobufStreamInput.readOptionalString(in);
+        this.version = protobufStreamInput.readOptionalString(in);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        out.writeInt64NoTag(refreshInterval);
+        out.writeInt32NoTag(availableProcessors);
+        out.writeInt32NoTag(allocatedProcessors);
+        protobufStreamOutput.writeOptionalString(name, out);
+        protobufStreamOutput.writeOptionalString(prettyName, out);
+        protobufStreamOutput.writeOptionalString(arch, out);
+        protobufStreamOutput.writeOptionalString(version, out);
+    }
+
+    public long getRefreshInterval() {
+        return this.refreshInterval;
+    }
+
+    public int getAvailableProcessors() {
+        return this.availableProcessors;
+    }
+
+    public int getAllocatedProcessors() {
+        return this.allocatedProcessors;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getPrettyName() {
+        return prettyName;
+    }
+
+    public String getArch() {
+        return arch;
+    }
+
+    public String getVersion() {
+        return version;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessInfo.java b/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessInfo.java
new file mode 100644
index 0000000000000..ea7b1960c0372
--- /dev/null
+++ b/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessInfo.java
@@ -0,0 +1,65 @@
+/*
+* 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.
+*/
+
+package org.opensearch.monitor.process;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.node.ProtobufReportingService;
+
+import java.io.IOException;
+
+/**
+ * Holds information for monitoring the process
+*
+* @opensearch.internal
+*/
+public class ProtobufProcessInfo implements ProtobufReportingService.ProtobufInfo {
+
+    private final long refreshInterval;
+    private final long id;
+    private final boolean mlockall;
+
+    public ProtobufProcessInfo(long id, boolean mlockall, long refreshInterval) {
+        this.id = id;
+        this.mlockall = mlockall;
+        this.refreshInterval = refreshInterval;
+    }
+
+    public ProtobufProcessInfo(CodedInputStream in) throws IOException {
+        refreshInterval = in.readInt64();
+        id = in.readInt64();
+        mlockall = in.readBool();
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(refreshInterval);
+        out.writeInt64NoTag(id);
+        out.writeBoolNoTag(mlockall);
+    }
+
+    public long refreshInterval() {
+        return this.refreshInterval;
+    }
+
+    public long getRefreshInterval() {
+        return this.refreshInterval;
+    }
+
+    /**
+     * The process id.
+    */
+    public long getId() {
+        return id;
+    }
+
+    public boolean isMlockall() {
+        return mlockall;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/node/ProtobufReportingService.java b/server/src/main/java/org/opensearch/node/ProtobufReportingService.java
new file mode 100644
index 0000000000000..9d9f507ce8cb3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/node/ProtobufReportingService.java
@@ -0,0 +1,29 @@
+/*
+* 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.
+*/
+
+package org.opensearch.node;
+
+import org.opensearch.common.io.stream.ProtobufWriteable;
+
+/**
+ * Node reporting service
+*
+* @opensearch.internal
+*/
+public interface ProtobufReportingService<I extends ProtobufReportingService.ProtobufInfo> {
+    I info();
+
+    /**
+     * Information interface.
+    *
+    * @opensearch.internal
+    */
+    interface ProtobufInfo extends ProtobufWriteable {
+
+    }
+}
diff --git a/server/src/main/java/org/opensearch/plugins/ProtobufPluginInfo.java b/server/src/main/java/org/opensearch/plugins/ProtobufPluginInfo.java
new file mode 100644
index 0000000000000..fcc06a0d11ba3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/plugins/ProtobufPluginInfo.java
@@ -0,0 +1,350 @@
+/*
+* 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.
+*/
+
+package org.opensearch.plugins;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.Version;
+import org.opensearch.bootstrap.JarHell;
+import org.opensearch.common.Strings;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Properties;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * An in-memory representation of the plugin descriptor.
+*
+* @opensearch.api
+*/
+public class ProtobufPluginInfo implements ProtobufWriteable {
+
+    public static final String OPENSEARCH_PLUGIN_PROPERTIES = "plugin-descriptor.properties";
+    public static final String OPENSEARCH_PLUGIN_POLICY = "plugin-security.policy";
+
+    private final String name;
+    private final String description;
+    private final String version;
+    private final Version opensearchVersion;
+    private final String javaVersion;
+    private final String classname;
+    private final String customFolderName;
+    private final List<String> extendedPlugins;
+    private final boolean hasNativeController;
+
+    /**
+     * Construct plugin info.
+    *
+    * @param name                  the name of the plugin
+    * @param description           a description of the plugin
+    * @param version               an opaque version identifier for the plugin
+    * @param opensearchVersion     the version of OpenSearch the plugin was built for
+    * @param javaVersion           the version of Java the plugin was built with
+    * @param classname             the entry point to the plugin
+    * @param customFolderName      the custom folder name for the plugin
+    * @param extendedPlugins       other plugins this plugin extends through SPI
+    * @param hasNativeController   whether or not the plugin has a native controller
+    */
+    public ProtobufPluginInfo(
+        String name,
+        String description,
+        String version,
+        Version opensearchVersion,
+        String javaVersion,
+        String classname,
+        String customFolderName,
+        List<String> extendedPlugins,
+        boolean hasNativeController
+    ) {
+        this.name = name;
+        this.description = description;
+        this.version = version;
+        this.opensearchVersion = opensearchVersion;
+        this.javaVersion = javaVersion;
+        this.classname = classname;
+        this.customFolderName = customFolderName;
+        this.extendedPlugins = Collections.unmodifiableList(extendedPlugins);
+        this.hasNativeController = hasNativeController;
+    }
+
+    /**
+     * Construct plugin info.
+    *
+    * @param name                  the name of the plugin
+    * @param description           a description of the plugin
+    * @param version               an opaque version identifier for the plugin
+    * @param opensearchVersion     the version of OpenSearch the plugin was built for
+    * @param javaVersion           the version of Java the plugin was built with
+    * @param classname             the entry point to the plugin
+    * @param extendedPlugins       other plugins this plugin extends through SPI
+    * @param hasNativeController   whether or not the plugin has a native controller
+    */
+    public ProtobufPluginInfo(
+        String name,
+        String description,
+        String version,
+        Version opensearchVersion,
+        String javaVersion,
+        String classname,
+        List<String> extendedPlugins,
+        boolean hasNativeController
+    ) {
+        this(
+            name,
+            description,
+            version,
+            opensearchVersion,
+            javaVersion,
+            classname,
+            null /* customFolderName */,
+            extendedPlugins,
+            hasNativeController
+        );
+    }
+
+    /**
+     * Construct plugin info from a stream.
+    *
+    * @param in the stream
+    * @throws IOException if an I/O exception occurred reading the plugin info from the stream
+    */
+    public ProtobufPluginInfo(final CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        this.name = in.readString();
+        this.description = in.readString();
+        this.version = in.readString();
+        this.opensearchVersion = Version.readVersionProtobuf(in);
+        this.javaVersion = in.readString();
+        this.classname = in.readString();
+        this.customFolderName = in.readString();
+        this.extendedPlugins = protobufStreamInput.readList(CodedInputStream::readString, in);
+        this.hasNativeController = in.readBool();
+    }
+
+    @Override
+    public void writeTo(final CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        out.writeStringNoTag(name);
+        out.writeStringNoTag(description);
+        out.writeStringNoTag(version);
+        out.writeInt32NoTag(opensearchVersion.id);
+        out.writeStringNoTag(javaVersion);
+        out.writeStringNoTag(classname);
+        if (customFolderName != null) {
+            out.writeStringNoTag(customFolderName);
+        } else {
+            out.writeStringNoTag(name);
+        }
+        protobufStreamOutput.writeCollection(extendedPlugins, CodedOutputStream::writeStringNoTag, out);
+        out.writeBoolNoTag(hasNativeController);
+    }
+
+    /**
+     * Reads the plugin descriptor file.
+    *
+    * @param path           the path to the root directory for the plugin
+    * @return the plugin info
+    * @throws IOException if an I/O exception occurred reading the plugin descriptor
+    */
+    public static ProtobufPluginInfo readFromProperties(final Path path) throws IOException {
+        final Path descriptor = path.resolve(OPENSEARCH_PLUGIN_PROPERTIES);
+
+        final Map<String, String> propsMap;
+        {
+            final Properties props = new Properties();
+            try (InputStream stream = Files.newInputStream(descriptor)) {
+                props.load(stream);
+            }
+            propsMap = props.stringPropertyNames().stream().collect(Collectors.toMap(Function.identity(), props::getProperty));
+        }
+
+        final String name = propsMap.remove("name");
+        if (name == null || name.isEmpty()) {
+            throw new IllegalArgumentException("property [name] is missing in [" + descriptor + "]");
+        }
+        final String description = propsMap.remove("description");
+        if (description == null) {
+            throw new IllegalArgumentException("property [description] is missing for plugin [" + name + "]");
+        }
+        final String version = propsMap.remove("version");
+        if (version == null) {
+            throw new IllegalArgumentException("property [version] is missing for plugin [" + name + "]");
+        }
+
+        final String opensearchVersionString = propsMap.remove("opensearch.version");
+        if (opensearchVersionString == null) {
+            throw new IllegalArgumentException("property [opensearch.version] is missing for plugin [" + name + "]");
+        }
+        final Version opensearchVersion = Version.fromString(opensearchVersionString);
+        final String javaVersionString = propsMap.remove("java.version");
+        if (javaVersionString == null) {
+            throw new IllegalArgumentException("property [java.version] is missing for plugin [" + name + "]");
+        }
+        JarHell.checkVersionFormat(javaVersionString);
+        final String classname = propsMap.remove("classname");
+        if (classname == null) {
+            throw new IllegalArgumentException("property [classname] is missing for plugin [" + name + "]");
+        }
+
+        final String customFolderNameValue = propsMap.remove("custom.foldername");
+        final String customFolderName;
+        customFolderName = customFolderNameValue;
+
+        final String extendedString = propsMap.remove("extended.plugins");
+        final List<String> extendedPlugins;
+        if (extendedString == null) {
+            extendedPlugins = Collections.emptyList();
+        } else {
+            extendedPlugins = Arrays.asList(Strings.delimitedListToStringArray(extendedString, ","));
+        }
+
+        final String hasNativeControllerValue = propsMap.remove("has.native.controller");
+        final boolean hasNativeController;
+        if (hasNativeControllerValue == null) {
+            hasNativeController = false;
+        } else {
+            switch (hasNativeControllerValue) {
+                case "true":
+                    hasNativeController = true;
+                    break;
+                case "false":
+                    hasNativeController = false;
+                    break;
+                default:
+                    final String message = String.format(
+                        Locale.ROOT,
+                        "property [%s] must be [%s], [%s], or unspecified but was [%s]",
+                        "has_native_controller",
+                        "true",
+                        "false",
+                        hasNativeControllerValue
+                    );
+                    throw new IllegalArgumentException(message);
+            }
+        }
+
+        if (propsMap.isEmpty() == false) {
+            throw new IllegalArgumentException("Unknown properties in plugin descriptor: " + propsMap.keySet());
+        }
+
+        return new ProtobufPluginInfo(
+            name,
+            description,
+            version,
+            opensearchVersion,
+            javaVersionString,
+            classname,
+            customFolderName,
+            extendedPlugins,
+            hasNativeController
+        );
+    }
+
+    /**
+     * The name of the plugin.
+    *
+    * @return the plugin name
+    */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * The description of the plugin.
+    *
+    * @return the plugin description
+    */
+    public String getDescription() {
+        return description;
+    }
+
+    /**
+     * The entry point to the plugin.
+    *
+    * @return the entry point to the plugin
+    */
+    public String getClassname() {
+        return classname;
+    }
+
+    /**
+     * The custom folder name for the plugin.
+    *
+    * @return the custom folder name for the plugin
+    */
+    public String getFolderName() {
+        return customFolderName;
+    }
+
+    /**
+     * Other plugins this plugin extends through SPI.
+    *
+    * @return the names of the plugins extended
+    */
+    public List<String> getExtendedPlugins() {
+        return extendedPlugins;
+    }
+
+    /**
+     * The version of the plugin
+    *
+    * @return the version
+    */
+    public String getVersion() {
+        return version;
+    }
+
+    /**
+     * The version of OpenSearch the plugin was built for.
+    *
+    * @return an OpenSearch version
+    */
+    public Version getOpenSearchVersion() {
+        return opensearchVersion;
+    }
+
+    /**
+     * The version of Java the plugin was built with.
+    *
+    * @return a java version string
+    */
+    public String getJavaVersion() {
+        return javaVersion;
+    }
+
+    /**
+     * Whether or not the plugin has a native controller.
+    *
+    * @return {@code true} if the plugin has a native controller
+    */
+    public boolean hasNativeController() {
+        return hasNativeController;
+    }
+
+    /**
+     * The target folder name for the plugin.
+    *
+    * @return the custom folder name for the plugin if the folder name is specified, else return the id with kebab-case.
+    */
+    public String getTargetFolderName() {
+        return (this.customFolderName == null || this.customFolderName.isEmpty()) ? this.name : this.customFolderName;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/rest/BaseRestHandler.java b/server/src/main/java/org/opensearch/rest/BaseRestHandler.java
index e18a594236fc8..00b9b2fa1fec5 100644
--- a/server/src/main/java/org/opensearch/rest/BaseRestHandler.java
+++ b/server/src/main/java/org/opensearch/rest/BaseRestHandler.java
@@ -38,6 +38,7 @@
 import org.apache.lucene.util.CollectionUtil;
 import org.opensearch.OpenSearchParseException;
 import org.opensearch.action.support.clustermanager.ClusterManagerNodeRequest;
+import org.opensearch.action.support.clustermanager.ProtobufClusterManagerNodeRequest;
 import org.opensearch.client.node.NodeClient;
 import org.opensearch.common.CheckedConsumer;
 import org.opensearch.common.collect.Tuple;
@@ -254,6 +255,34 @@ public static void parseDeprecatedMasterTimeoutParameter(
         }
     }
 
+    /**
+     * Parse the deprecated request parameter 'master_timeout', and add deprecated log if the parameter is used.
+     * It also validates whether the two parameters 'master_timeout' and 'cluster_manager_timeout' are not assigned together.
+     * The method is temporarily added in 2.0 duing applying inclusive language. Remove the method along with MASTER_ROLE.
+     * @param mnr the action request
+     * @param request the REST request to handle
+     * @param logger the logger that logs deprecation notices
+     * @param logMsgKeyPrefix the key prefix of a deprecation message to avoid duplicate messages.
+     */
+    public static void parseDeprecatedMasterTimeoutParameterProtobuf(
+        ProtobufClusterManagerNodeRequest mnr,
+        RestRequest request,
+        DeprecationLogger logger,
+        String logMsgKeyPrefix
+    ) {
+        final String MASTER_TIMEOUT_DEPRECATED_MESSAGE =
+            "Parameter [master_timeout] is deprecated and will be removed in 3.0. To support inclusive language, please use [cluster_manager_timeout] instead.";
+        final String DUPLICATE_PARAMETER_ERROR_MESSAGE =
+            "Please only use one of the request parameters [master_timeout, cluster_manager_timeout].";
+        if (request.hasParam("master_timeout")) {
+            logger.deprecate(logMsgKeyPrefix + "_master_timeout_parameter", MASTER_TIMEOUT_DEPRECATED_MESSAGE);
+            if (request.hasParam("cluster_manager_timeout")) {
+                throw new OpenSearchParseException(DUPLICATE_PARAMETER_ERROR_MESSAGE);
+            }
+            mnr.clusterManagerNodeTimeout(request.paramAsTime("master_timeout", mnr.clusterManagerNodeTimeout()));
+        }
+    }
+
     /**
      * A wrapper for the base handler.
      *
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
index b54c8955283a2..19967097e78b9 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
@@ -35,11 +35,16 @@
 import org.opensearch.action.admin.cluster.node.info.NodeInfo;
 import org.opensearch.action.admin.cluster.node.info.NodesInfoRequest;
 import org.opensearch.action.admin.cluster.node.info.NodesInfoResponse;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodeInfo;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequest;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoResponse;
 import org.opensearch.action.admin.cluster.node.stats.NodeStats;
 import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
 import org.opensearch.action.admin.cluster.node.stats.NodesStatsResponse;
 import org.opensearch.action.admin.cluster.state.ClusterStateRequest;
 import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
 import org.opensearch.client.node.NodeClient;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
@@ -65,6 +70,7 @@
 import org.opensearch.monitor.fs.FsInfo;
 import org.opensearch.monitor.jvm.JvmInfo;
 import org.opensearch.monitor.jvm.JvmStats;
+import org.opensearch.monitor.jvm.ProtobufJvmInfo;
 import org.opensearch.monitor.os.OsStats;
 import org.opensearch.monitor.process.ProcessInfo;
 import org.opensearch.monitor.process.ProcessStats;
@@ -109,7 +115,7 @@ protected void documentation(StringBuilder sb) {
 
     @Override
     public RestChannelConsumer doCatRequest(final RestRequest request, final NodeClient client) {
-        final ClusterStateRequest clusterStateRequest = new ClusterStateRequest();
+        final ProtobufClusterStateRequest clusterStateRequest = new ProtobufClusterStateRequest();
         clusterStateRequest.clear().nodes(true);
         if (request.hasParam("local")) {
             deprecationLogger.deprecate("cat_nodes_local_parameter", LOCAL_DEPRECATED_MESSAGE);
@@ -118,23 +124,23 @@ public RestChannelConsumer doCatRequest(final RestRequest request, final NodeCli
         clusterStateRequest.clusterManagerNodeTimeout(
             request.paramAsTime("cluster_manager_timeout", clusterStateRequest.clusterManagerNodeTimeout())
         );
-        parseDeprecatedMasterTimeoutParameter(clusterStateRequest, request, deprecationLogger, getName());
+        parseDeprecatedMasterTimeoutParameterProtobuf(clusterStateRequest, request, deprecationLogger, getName());
         final boolean fullId = request.paramAsBoolean("full_id", false);
-        return channel -> client.admin().cluster().state(clusterStateRequest, new RestActionListener<ClusterStateResponse>(channel) {
+        return channel -> client.admin().cluster().state(clusterStateRequest, new RestActionListener<ProtobufClusterStateResponse>(channel) {
             @Override
-            public void processResponse(final ClusterStateResponse clusterStateResponse) {
-                NodesInfoRequest nodesInfoRequest = new NodesInfoRequest();
+            public void processResponse(final ProtobufClusterStateResponse clusterStateResponse) {
+                ProtobufNodesInfoRequest nodesInfoRequest = new ProtobufNodesInfoRequest();
                 nodesInfoRequest.timeout(request.param("timeout"));
                 nodesInfoRequest.clear()
                     .addMetrics(
-                        NodesInfoRequest.Metric.JVM.metricName(),
-                        NodesInfoRequest.Metric.OS.metricName(),
-                        NodesInfoRequest.Metric.PROCESS.metricName(),
-                        NodesInfoRequest.Metric.HTTP.metricName()
+                        ProtobufNodesInfoRequest.Metric.JVM.metricName(),
+                        ProtobufNodesInfoRequest.Metric.OS.metricName(),
+                        ProtobufNodesInfoRequest.Metric.PROCESS.metricName(),
+                        ProtobufNodesInfoRequest.Metric.HTTP.metricName()
                     );
-                client.admin().cluster().nodesInfo(nodesInfoRequest, new RestActionListener<NodesInfoResponse>(channel) {
+                client.admin().cluster().nodesInfo(nodesInfoRequest, new RestActionListener<ProtobufNodesInfoResponse>(channel) {
                     @Override
-                    public void processResponse(final NodesInfoResponse nodesInfoResponse) {
+                    public void processResponse(final ProtobufNodesInfoResponse nodesInfoResponse) {
                         NodesStatsRequest nodesStatsRequest = new NodesStatsRequest();
                         nodesStatsRequest.timeout(request.param("timeout"));
                         nodesStatsRequest.clear()
@@ -350,8 +356,8 @@ protected Table getTableWithHeader(final RestRequest request) {
     Table buildTable(
         boolean fullId,
         RestRequest req,
-        ClusterStateResponse state,
-        NodesInfoResponse nodesInfo,
+        ProtobufClusterStateResponse state,
+        ProtobufNodesInfoResponse nodesInfo,
         NodesStatsResponse nodesStats
     ) {
 
@@ -360,10 +366,10 @@ Table buildTable(
         Table table = getTableWithHeader(req);
 
         for (DiscoveryNode node : nodes) {
-            NodeInfo info = nodesInfo.getNodesMap().get(node.getId());
+            ProtobufNodeInfo info = nodesInfo.getNodesMap().get(node.getId());
             NodeStats stats = nodesStats.getNodesMap().get(node.getId());
 
-            JvmInfo jvmInfo = info == null ? null : info.getInfo(JvmInfo.class);
+            ProtobufJvmInfo jvmInfo = info == null ? null : info.getInfo(ProtobufJvmInfo.class);
             JvmStats jvmStats = stats == null ? null : stats.getJvm();
             FsInfo fsInfo = stats == null ? null : stats.getFs();
             OsStats osStats = stats == null ? null : stats.getOs();
diff --git a/server/src/main/java/org/opensearch/search/aggregations/support/ProtobufAggregationInfo.java b/server/src/main/java/org/opensearch/search/aggregations/support/ProtobufAggregationInfo.java
new file mode 100644
index 0000000000000..cb90457671506
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/aggregations/support/ProtobufAggregationInfo.java
@@ -0,0 +1,71 @@
+/*
+* 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.
+*/
+
+package org.opensearch.search.aggregations.support;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.node.ProtobufReportingService;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.concurrent.atomic.LongAdder;
+
+/**
+ * Data describing an agg
+*
+* @opensearch.internal
+*/
+public class ProtobufAggregationInfo implements ProtobufReportingService.ProtobufInfo {
+
+    private final Map<String, Set<String>> aggs;
+
+    ProtobufAggregationInfo(Map<String, Map<String, LongAdder>> aggs) {
+        // we use a treemap/treeset here to have a test-able / predictable order
+        Map<String, Set<String>> aggsMap = new TreeMap<>();
+        aggs.forEach((s, m) -> aggsMap.put(s, Collections.unmodifiableSet(new TreeSet<>(m.keySet()))));
+        this.aggs = Collections.unmodifiableMap(aggsMap);
+    }
+
+    /**
+     * Read from a stream.
+    */
+    public ProtobufAggregationInfo(CodedInputStream in) throws IOException {
+        aggs = new TreeMap<>();
+        final int size = in.readInt32();
+        for (int i = 0; i < size; i++) {
+            String key = in.readString();
+            final int keys = in.readInt32();
+            final Set<String> types = new TreeSet<>();
+            for (int j = 0; j < keys; j++) {
+                types.add(in.readString());
+            }
+            aggs.put(key, types);
+        }
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt32NoTag(aggs.size());
+        for (Map.Entry<String, Set<String>> e : aggs.entrySet()) {
+            out.writeStringNoTag(e.getKey());
+            out.writeInt32NoTag(e.getValue().size());
+            for (String type : e.getValue()) {
+                out.writeStringNoTag(type);
+            }
+        }
+    }
+
+    public Map<String, Set<String>> getAggregations() {
+        return aggs;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/search/pipeline/ProtobufSearchPipelineInfo.java b/server/src/main/java/org/opensearch/search/pipeline/ProtobufSearchPipelineInfo.java
new file mode 100644
index 0000000000000..245eaa31b7bcc
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/pipeline/ProtobufSearchPipelineInfo.java
@@ -0,0 +1,56 @@
+/*
+* 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.
+*/
+
+package org.opensearch.search.pipeline;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.ingest.ProtobufProcessorInfo;
+import org.opensearch.node.ProtobufReportingService;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+/**
+ * Information about a search pipelines event
+*
+* @opensearch.internal
+*/
+public class ProtobufSearchPipelineInfo implements ProtobufReportingService.ProtobufInfo {
+
+    private final Set<ProtobufProcessorInfo> processors;
+
+    public ProtobufSearchPipelineInfo(List<ProtobufProcessorInfo> processors) {
+        this.processors = new TreeSet<>(processors);  // we use a treeset here to have a test-able / predictable order
+    }
+
+    /**
+     * Read from a stream.
+    */
+    public ProtobufSearchPipelineInfo(CodedInputStream in) throws IOException {
+        processors = new TreeSet<>();
+        final int size = in.readInt32();
+        for (int i = 0; i < size; i++) {
+            processors.add(new ProtobufProcessorInfo(in));
+        }
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt32NoTag(processors.size());
+        for (ProtobufProcessorInfo info : processors) {
+            info.writeTo(out);
+        }
+    }
+
+    public boolean containsProcessor(String type) {
+        return processors.contains(new ProtobufProcessorInfo(type));
+    }
+}
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTask.java b/server/src/main/java/org/opensearch/tasks/ProtobufTask.java
index 7c7ee83adb679..21165cb7736ca 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTask.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTask.java
@@ -14,9 +14,9 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.opensearch.ExceptionsHelper;
-import org.opensearch.action.ActionResponse;
+import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.action.NotifyOnceListener;
-import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
 import org.opensearch.common.io.stream.NamedWriteable;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.ToXContentObject;
@@ -385,11 +385,11 @@ public String getHeader(String header) {
         return headers.get(header);
     }
 
-    public ProtobufTaskResult result(DiscoveryNode node, Exception error) throws IOException {
+    public ProtobufTaskResult result(ProtobufDiscoveryNode node, Exception error) throws IOException {
         return new ProtobufTaskResult(taskInfo(node.getId(), true, true), error);
     }
 
-    public ProtobufTaskResult result(DiscoveryNode node, ActionResponse response) throws IOException {
+    public ProtobufTaskResult result(ProtobufDiscoveryNode node, ProtobufActionResponse response) throws IOException {
         if (response instanceof ToXContent) {
             return new ProtobufTaskResult(taskInfo(node.getId(), true, true), (ToXContent) response);
         } else {
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
new file mode 100644
index 0000000000000..7236fa2ebdc2f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
@@ -0,0 +1,236 @@
+/*
+* 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.
+*/
+
+package org.opensearch.tasks;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.ExceptionsHelper;
+import org.opensearch.OpenSearchSecurityException;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.StepListener;
+import org.opensearch.action.support.ChannelActionListener;
+import org.opensearch.action.support.GroupedActionListener;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.StreamOutput;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.EmptyTransportResponseHandler;
+import org.opensearch.transport.TransportChannel;
+import org.opensearch.transport.TransportException;
+import org.opensearch.transport.TransportRequest;
+import org.opensearch.transport.TransportRequestHandler;
+import org.opensearch.transport.TransportResponse;
+import org.opensearch.transport.TransportService;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * Service used to cancel a task
+*
+* @opensearch.internal
+*/
+public class ProtobufTaskCancellationService {
+    public static final String BAN_PARENT_ACTION_NAME = "internal:admin/tasks/ban";
+    private static final Logger logger = LogManager.getLogger(ProtobufTaskCancellationService.class);
+    private final TransportService transportService;
+    private final ProtobufTaskManager taskManager;
+
+    public ProtobufTaskCancellationService(TransportService transportService) {
+        this.transportService = transportService;
+        this.taskManager = transportService.getTaskManager();
+        transportService.registerRequestHandler(
+            BAN_PARENT_ACTION_NAME,
+            ThreadPool.Names.SAME,
+            BanParentTaskRequest::new,
+            new BanParentRequestHandler()
+        );
+    }
+
+    private String localNodeId() {
+        return transportService.getLocalNode().getId();
+    }
+
+    void cancelTaskAndDescendants(CancellableTask task, String reason, boolean waitForCompletion, ActionListener<Void> listener) {
+        final TaskId taskId = task.taskInfo(localNodeId(), false).getTaskId();
+        if (task.shouldCancelChildrenOnCancellation()) {
+            logger.trace("cancelling task [{}] and its descendants", taskId);
+            StepListener<Void> completedListener = new StepListener<>();
+            GroupedActionListener<Void> groupedListener = new GroupedActionListener<>(ActionListener.map(completedListener, r -> null), 3);
+            Collection<DiscoveryNode> childrenNodes = taskManager.startBanOnChildrenNodes(task.getId(), () -> {
+                logger.trace("child tasks of parent [{}] are completed", taskId);
+                groupedListener.onResponse(null);
+            });
+            taskManager.cancel(task, reason, () -> {
+                logger.trace("task [{}] is cancelled", taskId);
+                groupedListener.onResponse(null);
+            });
+            StepListener<Void> banOnNodesListener = new StepListener<>();
+            setBanOnNodes(reason, waitForCompletion, task, childrenNodes, banOnNodesListener);
+            banOnNodesListener.whenComplete(groupedListener::onResponse, groupedListener::onFailure);
+            // If we start unbanning when the last child task completed and that child task executed with a specific user, then unban
+            // requests are denied because internal requests can't run with a user. We need to remove bans with the current thread context.
+            final Runnable removeBansRunnable = transportService.getThreadPool()
+                .getThreadContext()
+                .preserveContext(() -> removeBanOnNodes(task, childrenNodes));
+            // We remove bans after all child tasks are completed although in theory we can do it on a per-node basis.
+            completedListener.whenComplete(r -> removeBansRunnable.run(), e -> removeBansRunnable.run());
+            // if wait_for_completion is true, then only return when (1) bans are placed on child nodes, (2) child tasks are
+            // completed or failed, (3) the main task is cancelled. Otherwise, return after bans are placed on child nodes.
+            if (waitForCompletion) {
+                completedListener.whenComplete(r -> listener.onResponse(null), listener::onFailure);
+            } else {
+                banOnNodesListener.whenComplete(r -> listener.onResponse(null), listener::onFailure);
+            }
+        } else {
+            logger.trace("task [{}] doesn't have any children that should be cancelled", taskId);
+            if (waitForCompletion) {
+                taskManager.cancel(task, reason, () -> listener.onResponse(null));
+            } else {
+                taskManager.cancel(task, reason, () -> {});
+                listener.onResponse(null);
+            }
+        }
+    }
+
+    private void setBanOnNodes(
+        String reason,
+        boolean waitForCompletion,
+        CancellableTask task,
+        Collection<DiscoveryNode> childNodes,
+        ActionListener<Void> listener
+    ) {
+        if (childNodes.isEmpty()) {
+            listener.onResponse(null);
+            return;
+        }
+        final TaskId taskId = new TaskId(localNodeId(), task.getId());
+        logger.trace("cancelling child tasks of [{}] on child nodes {}", taskId, childNodes);
+        GroupedActionListener<Void> groupedListener = new GroupedActionListener<>(
+            ActionListener.map(listener, r -> null),
+            childNodes.size()
+        );
+        final BanParentTaskRequest banRequest = BanParentTaskRequest.createSetBanParentTaskRequest(taskId, reason, waitForCompletion);
+        for (DiscoveryNode node : childNodes) {
+            transportService.sendRequest(
+                node,
+                BAN_PARENT_ACTION_NAME,
+                banRequest,
+                new EmptyTransportResponseHandler(ThreadPool.Names.SAME) {
+                    @Override
+                    public void handleResponse(TransportResponse.Empty response) {
+                        logger.trace("sent ban for tasks with the parent [{}] to the node [{}]", taskId, node);
+                        groupedListener.onResponse(null);
+                    }
+
+                    @Override
+                    public void handleException(TransportException exp) {
+                        assert ExceptionsHelper.unwrapCause(exp) instanceof OpenSearchSecurityException == false;
+                        logger.warn("Cannot send ban for tasks with the parent [{}] to the node [{}]", taskId, node);
+                        groupedListener.onFailure(exp);
+                    }
+                }
+            );
+        }
+    }
+
+    private void removeBanOnNodes(CancellableTask task, Collection<DiscoveryNode> childNodes) {
+        final BanParentTaskRequest request = BanParentTaskRequest.createRemoveBanParentTaskRequest(new TaskId(localNodeId(), task.getId()));
+        for (DiscoveryNode node : childNodes) {
+            logger.trace("Sending remove ban for tasks with the parent [{}] to the node [{}]", request.parentTaskId, node);
+            transportService.sendRequest(node, BAN_PARENT_ACTION_NAME, request, new EmptyTransportResponseHandler(ThreadPool.Names.SAME) {
+                @Override
+                public void handleException(TransportException exp) {
+                    assert ExceptionsHelper.unwrapCause(exp) instanceof OpenSearchSecurityException == false;
+                    logger.info("failed to remove the parent ban for task {} on node {}", request.parentTaskId, node);
+                }
+            });
+        }
+    }
+
+    private static class BanParentTaskRequest extends TransportRequest {
+
+        private final TaskId parentTaskId;
+        private final boolean ban;
+        private final boolean waitForCompletion;
+        private final String reason;
+
+        static BanParentTaskRequest createSetBanParentTaskRequest(TaskId parentTaskId, String reason, boolean waitForCompletion) {
+            return new BanParentTaskRequest(parentTaskId, reason, waitForCompletion);
+        }
+
+        static BanParentTaskRequest createRemoveBanParentTaskRequest(TaskId parentTaskId) {
+            return new BanParentTaskRequest(parentTaskId);
+        }
+
+        private BanParentTaskRequest(TaskId parentTaskId, String reason, boolean waitForCompletion) {
+            this.parentTaskId = parentTaskId;
+            this.ban = true;
+            this.reason = reason;
+            this.waitForCompletion = waitForCompletion;
+        }
+
+        private BanParentTaskRequest(TaskId parentTaskId) {
+            this.parentTaskId = parentTaskId;
+            this.ban = false;
+            this.reason = null;
+            this.waitForCompletion = false;
+        }
+
+        private BanParentTaskRequest(StreamInput in) throws IOException {
+            super(in);
+            parentTaskId = TaskId.readFromStream(in);
+            ban = in.readBoolean();
+            reason = ban ? in.readString() : null;
+            waitForCompletion = in.readBoolean();
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            super.writeTo(out);
+            parentTaskId.writeTo(out);
+            out.writeBoolean(ban);
+            if (ban) {
+                out.writeString(reason);
+            }
+            out.writeBoolean(waitForCompletion);
+        }
+    }
+
+    private class BanParentRequestHandler implements TransportRequestHandler<BanParentTaskRequest> {
+        @Override
+        public void messageReceived(final BanParentTaskRequest request, final TransportChannel channel, Task task) throws Exception {
+            if (request.ban) {
+                logger.debug(
+                    "Received ban for the parent [{}] on the node [{}], reason: [{}]",
+                    request.parentTaskId,
+                    localNodeId(),
+                    request.reason
+                );
+                final List<CancellableTask> childTasks = taskManager.setBan(request.parentTaskId, request.reason);
+                final GroupedActionListener<Void> listener = new GroupedActionListener<>(
+                    ActionListener.map(
+                        new ChannelActionListener<>(channel, BAN_PARENT_ACTION_NAME, request),
+                        r -> TransportResponse.Empty.INSTANCE
+                    ),
+                    childTasks.size() + 1
+                );
+                for (CancellableTask childTask : childTasks) {
+                    cancelTaskAndDescendants(childTask, request.reason, request.waitForCompletion, listener);
+                }
+                listener.onResponse(null);
+            } else {
+                logger.debug("Removing ban for the parent [{}] on the node [{}]", request.parentTaskId, localNodeId());
+                taskManager.removeBan(request.parentTaskId);
+                channel.sendResponse(TransportResponse.Empty.INSTANCE);
+            }
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskManager.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskManager.java
new file mode 100644
index 0000000000000..55f9213214ca5
--- /dev/null
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskManager.java
@@ -0,0 +1,752 @@
+/*
+* 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.
+*/
+
+package org.opensearch.tasks;
+
+import com.carrotsearch.hppc.ObjectIntHashMap;
+import com.carrotsearch.hppc.ObjectIntMap;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.core.Assertions;
+import org.opensearch.ExceptionsHelper;
+import org.opensearch.OpenSearchException;
+import org.opensearch.OpenSearchTimeoutException;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.ProtobufActionResponse;
+import org.opensearch.action.NotifyOnceListener;
+import org.opensearch.cluster.ProtobufClusterChangedEvent;
+import org.opensearch.cluster.ProtobufClusterStateApplier;
+import org.opensearch.cluster.ClusterStateApplier;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.common.SetOnce;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.lease.Releasables;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.concurrent.AbstractRunnable;
+import org.opensearch.common.util.concurrent.ConcurrentCollections;
+import org.opensearch.common.util.concurrent.ConcurrentMapLong;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.transport.TcpChannel;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
+
+import static org.opensearch.common.unit.TimeValue.timeValueMillis;
+import static org.opensearch.http.HttpTransportSettings.SETTING_HTTP_MAX_HEADER_SIZE;
+
+/**
+ * ProtobufTask Manager service for keeping track of currently running tasks on the nodes
+*
+* @opensearch.internal
+*/
+public class ProtobufTaskManager implements ProtobufClusterStateApplier {
+
+    private static final Logger logger = LogManager.getLogger(ProtobufTaskManager.class);
+
+    private static final TimeValue WAIT_FOR_COMPLETION_POLL = timeValueMillis(100);
+
+    public static final String TASK_RESOURCE_CONSUMERS_ATTRIBUTES = "task_resource_consumers.enabled";
+
+    public static final Setting<Boolean> TASK_RESOURCE_CONSUMERS_ENABLED = Setting.boolSetting(
+        TASK_RESOURCE_CONSUMERS_ATTRIBUTES,
+        false,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope
+    );
+
+    /**
+     * Rest headers that are copied to the task
+    */
+    private final List<String> taskHeaders;
+    private final ProtobufThreadPool threadPool;
+
+    private final ConcurrentMapLong<ProtobufTask> tasks = ConcurrentCollections.newConcurrentMapLongWithAggressiveConcurrency();
+
+    private final ConcurrentMapLong<CancellableTaskHolder> cancellableTasks = ConcurrentCollections
+        .newConcurrentMapLongWithAggressiveConcurrency();
+
+    private final AtomicLong taskIdGenerator = new AtomicLong();
+
+    private final Map<ProtobufTaskId, String> banedParents = new ConcurrentHashMap<>();
+
+    private TaskResultsService taskResultsService;
+    private final SetOnce<ProtobufTaskResourceTrackingService> taskResourceTrackingService = new SetOnce<>();
+
+    private volatile ProtobufDiscoveryNodes lastDiscoveryNodes = ProtobufDiscoveryNodes.EMPTY_NODES;
+
+    private final ByteSizeValue maxHeaderSize;
+    private final Map<TcpChannel, ChannelPendingTaskTracker> channelPendingTaskTrackers = ConcurrentCollections.newConcurrentMap();
+    private final SetOnce<TaskCancellationService> cancellationService = new SetOnce<>();
+
+    private volatile boolean taskResourceConsumersEnabled;
+    private final Set<Consumer<ProtobufTask>> taskResourceConsumer;
+
+    public static ProtobufTaskManager createTaskManagerWithClusterSettings(
+        Settings settings,
+        ClusterSettings clusterSettings,
+        ProtobufThreadPool threadPool,
+        Set<String> taskHeaders
+    ) {
+        final ProtobufTaskManager taskManager = new ProtobufTaskManager(settings, threadPool, taskHeaders);
+        clusterSettings.addSettingsUpdateConsumer(TASK_RESOURCE_CONSUMERS_ENABLED, taskManager::setTaskResourceConsumersEnabled);
+        return taskManager;
+    }
+
+    public ProtobufTaskManager(Settings settings, ProtobufThreadPool threadPool, Set<String> taskHeaders) {
+        this.threadPool = threadPool;
+        this.taskHeaders = new ArrayList<>(taskHeaders);
+        this.maxHeaderSize = SETTING_HTTP_MAX_HEADER_SIZE.get(settings);
+        this.taskResourceConsumersEnabled = TASK_RESOURCE_CONSUMERS_ENABLED.get(settings);
+        taskResourceConsumer = new HashSet<>();
+    }
+
+    public void registerTaskResourceConsumer(Consumer<ProtobufTask> consumer) {
+        taskResourceConsumer.add(consumer);
+    }
+
+    public void setTaskResultsService(TaskResultsService taskResultsService) {
+        assert this.taskResultsService == null;
+        this.taskResultsService = taskResultsService;
+    }
+
+    public void setTaskCancellationService(TaskCancellationService taskCancellationService) {
+        this.cancellationService.set(taskCancellationService);
+    }
+
+    public void setTaskResourceTrackingService(ProtobufTaskResourceTrackingService taskResourceTrackingService) {
+        this.taskResourceTrackingService.set(taskResourceTrackingService);
+    }
+
+    public void setTaskResourceConsumersEnabled(boolean taskResourceConsumersEnabled) {
+        this.taskResourceConsumersEnabled = taskResourceConsumersEnabled;
+    }
+
+    /**
+     * Registers a task without parent task
+    */
+    public ProtobufTask register(String type, String action, ProtobufTaskAwareRequest request) {
+        Map<String, String> headers = new HashMap<>();
+        long headerSize = 0;
+        long maxSize = maxHeaderSize.getBytes();
+        ThreadContext threadContext = threadPool.getThreadContext();
+        for (String key : taskHeaders) {
+            String httpHeader = threadContext.getHeader(key);
+            if (httpHeader != null) {
+                headerSize += key.length() * 2 + httpHeader.length() * 2;
+                if (headerSize > maxSize) {
+                    throw new IllegalArgumentException("Request exceeded the maximum size of task headers " + maxHeaderSize);
+                }
+                headers.put(key, httpHeader);
+            }
+        }
+        ProtobufTask task = request.createTask(taskIdGenerator.incrementAndGet(), type, action, request.getParentTask(), headers);
+        Objects.requireNonNull(task);
+        assert task.getParentTaskId().equals(request.getParentTask()) : "Request [ " + request + "] didn't preserve it parentTaskId";
+        if (logger.isTraceEnabled()) {
+            logger.trace("register {} [{}] [{}] [{}]", task.getId(), type, action, task.getDescription());
+        }
+
+        if (task.supportsResourceTracking()) {
+            boolean success = task.addResourceTrackingCompletionListener(new NotifyOnceListener<>() {
+                @Override
+                protected void innerOnResponse(ProtobufTask task) {
+                    // Stop tracking the task once the last thread has been marked inactive.
+                    if (taskResourceTrackingService.get() != null && task.supportsResourceTracking()) {
+                        taskResourceTrackingService.get().stopTracking(task);
+                    }
+                }
+
+                @Override
+                protected void innerOnFailure(Exception e) {
+                    ExceptionsHelper.reThrowIfNotNull(e);
+                }
+            });
+
+            if (success == false) {
+                logger.debug(
+                    "failed to register a completion listener as task resource tracking has already completed [taskId={}]",
+                    task.getId()
+                );
+            }
+        }
+
+        if (task instanceof ProtobufCancellableTask) {
+            registerCancellableTask(task);
+        } else {
+            ProtobufTask previousTask = tasks.put(task.getId(), task);
+            assert previousTask == null;
+        }
+        return task;
+    }
+
+    private void registerCancellableTask(ProtobufTask task) {
+        ProtobufCancellableTask cancellableTask = (ProtobufCancellableTask) task;
+        CancellableTaskHolder holder = new CancellableTaskHolder(cancellableTask);
+        CancellableTaskHolder oldHolder = cancellableTasks.put(task.getId(), holder);
+        assert oldHolder == null;
+        // Check if this task was banned before we start it. The empty check is used to avoid
+        // computing the hash code of the parent taskId as most of the time banedParents is empty.
+        if (task.getParentTaskId().isSet() && banedParents.isEmpty() == false) {
+            String reason = banedParents.get(task.getParentTaskId());
+            if (reason != null) {
+                try {
+                    holder.cancel(reason);
+                    throw new TaskCancelledException("ProtobufTask cancelled before it started: " + reason);
+                } finally {
+                    // let's clean up the registration
+                    unregister(task);
+                }
+            }
+        }
+    }
+
+    /**
+     * Cancels a task
+    * <p>
+    * After starting cancellation on the parent task, the task manager tries to cancel all children tasks
+    * of the current task. Once cancellation of the children tasks is done, the listener is triggered.
+    * If the task is completed or unregistered from ProtobufTaskManager, then the listener is called immediately.
+    */
+    public void cancel(ProtobufCancellableTask task, String reason, Runnable listener) {
+        CancellableTaskHolder holder = cancellableTasks.get(task.getId());
+        if (holder != null) {
+            logger.trace("cancelling task with id {}", task.getId());
+            holder.cancel(reason, listener);
+        } else {
+            listener.run();
+        }
+    }
+
+    /**
+     * Unregister the task
+    */
+    public ProtobufTask unregister(ProtobufTask task) {
+        logger.trace("unregister task for id: {}", task.getId());
+
+        // Decrement the task's self-thread as part of unregistration.
+        task.decrementResourceTrackingThreads();
+
+        if (taskResourceConsumersEnabled) {
+            for (Consumer<ProtobufTask> taskConsumer : taskResourceConsumer) {
+                try {
+                    taskConsumer.accept(task);
+                } catch (Exception e) {
+                    logger.error("error encountered when updating the consumer", e);
+                }
+            }
+        }
+
+        if (task instanceof ProtobufCancellableTask) {
+            CancellableTaskHolder holder = cancellableTasks.remove(task.getId());
+            if (holder != null) {
+                holder.finish();
+                return holder.getTask();
+            } else {
+                return null;
+            }
+        } else {
+            return tasks.remove(task.getId());
+        }
+    }
+
+    /**
+     * Register a node on which a child task will execute. The returned {@link Releasable} must be called
+    * to unregister the child node once the child task is completed or failed.
+    */
+    public Releasable registerChildNode(long taskId, ProtobufDiscoveryNode node) {
+        final CancellableTaskHolder holder = cancellableTasks.get(taskId);
+        if (holder != null) {
+            logger.trace("register child node [{}] task [{}]", node, taskId);
+            holder.registerChildNode(node);
+            return Releasables.releaseOnce(() -> {
+                logger.trace("unregister child node [{}] task [{}]", node, taskId);
+                holder.unregisterChildNode(node);
+            });
+        }
+        return () -> {};
+    }
+
+    public ProtobufDiscoveryNode localNode() {
+        return lastDiscoveryNodes.getLocalNode();
+    }
+
+    /**
+     * Stores the task failure
+    */
+    public <Response extends ProtobufActionResponse> void storeResult(ProtobufTask task, Exception error, ActionListener<Response> listener) {
+        ProtobufDiscoveryNode localNode = lastDiscoveryNodes.getLocalNode();
+        if (localNode == null) {
+            // too early to store anything, shouldn't really be here - just pass the error along
+            listener.onFailure(error);
+            return;
+        }
+        final ProtobufTaskResult taskResult;
+        try {
+            taskResult = task.result(localNode, error);
+        } catch (IOException ex) {
+            logger.warn(() -> new ParameterizedMessage("couldn't store error {}", ExceptionsHelper.detailedMessage(error)), ex);
+            listener.onFailure(ex);
+            return;
+        }
+        taskResultsService.storeResult(taskResult, new ActionListener<Void>() {
+            @Override
+            public void onResponse(Void aVoid) {
+                listener.onFailure(error);
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                logger.warn(() -> new ParameterizedMessage("couldn't store error {}", ExceptionsHelper.detailedMessage(error)), e);
+                listener.onFailure(e);
+            }
+        });
+    }
+
+    /**
+     * Stores the task result
+    */
+    public <Response extends ProtobufActionResponse> void storeResult(ProtobufTask task, Response response, ActionListener<Response> listener) {
+        ProtobufDiscoveryNode localNode = lastDiscoveryNodes.getLocalNode();
+        if (localNode == null) {
+            // too early to store anything, shouldn't really be here - just pass the response along
+            logger.warn("couldn't store response {}, the node didn't join the cluster yet", response);
+            listener.onResponse(response);
+            return;
+        }
+        final ProtobufTaskResult taskResult;
+        try {
+            taskResult = task.result(localNode, response);
+        } catch (IOException ex) {
+            logger.warn(() -> new ParameterizedMessage("couldn't store response {}", response), ex);
+            listener.onFailure(ex);
+            return;
+        }
+
+        taskResultsService.storeResult(taskResult, new ActionListener<Void>() {
+            @Override
+            public void onResponse(Void aVoid) {
+                listener.onResponse(response);
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                logger.warn(() -> new ParameterizedMessage("couldn't store response {}", response), e);
+                listener.onFailure(e);
+            }
+        });
+    }
+
+    /**
+     * Returns the list of currently running tasks on the node
+    */
+    public Map<Long, ProtobufTask> getTasks() {
+        HashMap<Long, ProtobufTask> taskHashMap = new HashMap<>(this.tasks);
+        for (CancellableTaskHolder holder : cancellableTasks.values()) {
+            taskHashMap.put(holder.getTask().getId(), holder.getTask());
+        }
+        return Collections.unmodifiableMap(taskHashMap);
+    }
+
+    /**
+     * Returns the list of currently running tasks on the node that can be cancelled
+    */
+    public Map<Long, ProtobufCancellableTask> getCancellableTasks() {
+        HashMap<Long, ProtobufCancellableTask> taskHashMap = new HashMap<>();
+        for (CancellableTaskHolder holder : cancellableTasks.values()) {
+            taskHashMap.put(holder.getTask().getId(), holder.getTask());
+        }
+        return Collections.unmodifiableMap(taskHashMap);
+    }
+
+    /**
+     * Returns a task with given id, or null if the task is not found.
+    */
+    public ProtobufTask getTask(long id) {
+        ProtobufTask task = tasks.get(id);
+        if (task != null) {
+            return task;
+        } else {
+            return getCancellableTask(id);
+        }
+    }
+
+    /**
+     * Returns a cancellable task with given id, or null if the task is not found.
+    */
+    public ProtobufCancellableTask getCancellableTask(long id) {
+        CancellableTaskHolder holder = cancellableTasks.get(id);
+        if (holder != null) {
+            return holder.getTask();
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Returns the number of currently banned tasks.
+    * <p>
+    * Will be used in task manager stats and for debugging.
+    */
+    public int getBanCount() {
+        return banedParents.size();
+    }
+
+    /**
+     * Bans all tasks with the specified parent task from execution, cancels all tasks that are currently executing.
+    * <p>
+    * This method is called when a parent task that has children is cancelled.
+    *
+    * @return a list of pending cancellable child tasks
+    */
+    public List<ProtobufCancellableTask> setBan(ProtobufTaskId parentTaskId, String reason) {
+        logger.trace("setting ban for the parent task {} {}", parentTaskId, reason);
+
+        // Set the ban first, so the newly created tasks cannot be registered
+        synchronized (banedParents) {
+            if (lastDiscoveryNodes.nodeExists(parentTaskId.getNodeId())) {
+                // Only set the ban if the node is the part of the cluster
+                banedParents.put(parentTaskId, reason);
+            }
+        }
+        return cancellableTasks.values().stream().filter(t -> t.hasParent(parentTaskId)).map(t -> t.task).collect(Collectors.toList());
+    }
+
+    /**
+     * Removes the ban for the specified parent task.
+    * <p>
+    * This method is called when a previously banned task finally cancelled
+    */
+    public void removeBan(ProtobufTaskId parentTaskId) {
+        logger.trace("removing ban for the parent task {}", parentTaskId);
+        banedParents.remove(parentTaskId);
+    }
+
+    // for testing
+    public Set<ProtobufTaskId> getBannedTaskIds() {
+        return Collections.unmodifiableSet(banedParents.keySet());
+    }
+
+    /**
+     * Start rejecting new child requests as the parent task was cancelled.
+    *
+    * @param taskId                the parent task id
+    * @param onChildTasksCompleted called when all child tasks are completed or failed
+    * @return the set of current nodes that have outstanding child tasks
+    */
+    public Collection<ProtobufDiscoveryNode> startBanOnChildrenNodes(long taskId, Runnable onChildTasksCompleted) {
+        final CancellableTaskHolder holder = cancellableTasks.get(taskId);
+        if (holder != null) {
+            return holder.startBan(onChildTasksCompleted);
+        } else {
+            onChildTasksCompleted.run();
+            return Collections.emptySet();
+        }
+    }
+
+    @Override
+    public void applyClusterState(ProtobufClusterChangedEvent event) {
+        lastDiscoveryNodes = event.state().getNodes();
+        if (event.nodesRemoved()) {
+            synchronized (banedParents) {
+                lastDiscoveryNodes = event.state().getNodes();
+                // Remove all bans that were registered by nodes that are no longer in the cluster state
+                Iterator<ProtobufTaskId> banIterator = banedParents.keySet().iterator();
+                while (banIterator.hasNext()) {
+                    ProtobufTaskId taskId = banIterator.next();
+                    if (lastDiscoveryNodes.nodeExists(taskId.getNodeId()) == false) {
+                        logger.debug(
+                            "Removing ban for the parent [{}] on the node [{}], reason: the parent node is gone",
+                            taskId,
+                            event.state().getNodes().getLocalNode()
+                        );
+                        banIterator.remove();
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Blocks the calling thread, waiting for the task to vanish from the ProtobufTaskManager.
+    */
+    public void waitForTaskCompletion(ProtobufTask task, long untilInNanos) {
+        while (System.nanoTime() - untilInNanos < 0) {
+            if (getTask(task.getId()) == null) {
+                return;
+            }
+            try {
+                Thread.sleep(WAIT_FOR_COMPLETION_POLL.millis());
+            } catch (InterruptedException e) {
+                throw new OpenSearchException("Interrupted waiting for completion of [{}]", e, task);
+            }
+        }
+        throw new OpenSearchTimeoutException("Timed out waiting for completion of [{}]", task);
+    }
+
+    /**
+     * Takes actions when a task is registered and its execution starts
+    *
+    * @param task getting executed.
+    * @return AutoCloseable to free up resources (clean up thread context) when task execution block returns
+    */
+    public ThreadContext.StoredContext taskExecutionStarted(ProtobufTask task) {
+        if (taskResourceTrackingService.get() == null) return () -> {};
+
+        return taskResourceTrackingService.get().startTracking(task);
+    }
+
+    private static class CancellableTaskHolder {
+        private final ProtobufCancellableTask task;
+        private boolean finished = false;
+        private List<Runnable> cancellationListeners = null;
+        private ObjectIntMap<ProtobufDiscoveryNode> childTasksPerNode = null;
+        private boolean banChildren = false;
+        private List<Runnable> childTaskCompletedListeners = null;
+
+        CancellableTaskHolder(ProtobufCancellableTask task) {
+            this.task = task;
+        }
+
+        void cancel(String reason, Runnable listener) {
+            final Runnable toRun;
+            synchronized (this) {
+                if (finished) {
+                    assert cancellationListeners == null;
+                    toRun = listener;
+                } else {
+                    toRun = () -> {};
+                    if (listener != null) {
+                        if (cancellationListeners == null) {
+                            cancellationListeners = new ArrayList<>();
+                        }
+                        cancellationListeners.add(listener);
+                    }
+                }
+            }
+            try {
+                task.cancel(reason);
+            } finally {
+                if (toRun != null) {
+                    toRun.run();
+                }
+            }
+        }
+
+        void cancel(String reason) {
+            task.cancel(reason);
+        }
+
+        /**
+         * Marks task as finished.
+        */
+        public void finish() {
+            final List<Runnable> listeners;
+            synchronized (this) {
+                this.finished = true;
+                if (cancellationListeners != null) {
+                    listeners = cancellationListeners;
+                    cancellationListeners = null;
+                } else {
+                    listeners = Collections.emptyList();
+                }
+            }
+            // We need to call the listener outside of the synchronised section to avoid potential bottle necks
+            // in the listener synchronization
+            notifyListeners(listeners);
+        }
+
+        private void notifyListeners(List<Runnable> listeners) {
+            assert Thread.holdsLock(this) == false;
+            Exception rootException = null;
+            for (Runnable listener : listeners) {
+                try {
+                    listener.run();
+                } catch (RuntimeException inner) {
+                    rootException = ExceptionsHelper.useOrSuppress(rootException, inner);
+                }
+            }
+            ExceptionsHelper.reThrowIfNotNull(rootException);
+        }
+
+        public boolean hasParent(ProtobufTaskId parentTaskId) {
+            return task.getParentTaskId().equals(parentTaskId);
+        }
+
+        public ProtobufCancellableTask getTask() {
+            return task;
+        }
+
+        synchronized void registerChildNode(ProtobufDiscoveryNode node) {
+            if (banChildren) {
+                throw new TaskCancelledException("The parent task was cancelled, shouldn't start any child tasks");
+            }
+            if (childTasksPerNode == null) {
+                childTasksPerNode = new ObjectIntHashMap<>();
+            }
+            childTasksPerNode.addTo(node, 1);
+        }
+
+        void unregisterChildNode(ProtobufDiscoveryNode node) {
+            final List<Runnable> listeners;
+            synchronized (this) {
+                if (childTasksPerNode.addTo(node, -1) == 0) {
+                    childTasksPerNode.remove(node);
+                }
+                if (childTasksPerNode.isEmpty() && this.childTaskCompletedListeners != null) {
+                    listeners = childTaskCompletedListeners;
+                    childTaskCompletedListeners = null;
+                } else {
+                    listeners = Collections.emptyList();
+                }
+            }
+            notifyListeners(listeners);
+        }
+
+        Set<ProtobufDiscoveryNode> startBan(Runnable onChildTasksCompleted) {
+            final Set<ProtobufDiscoveryNode> pendingChildNodes;
+            final Runnable toRun;
+            synchronized (this) {
+                banChildren = true;
+                if (childTasksPerNode == null) {
+                    pendingChildNodes = Collections.emptySet();
+                } else {
+                    pendingChildNodes = StreamSupport.stream(childTasksPerNode.spliterator(), false)
+                        .map(e -> e.key)
+                        .collect(Collectors.toSet());
+                }
+                if (pendingChildNodes.isEmpty()) {
+                    assert childTaskCompletedListeners == null;
+                    toRun = onChildTasksCompleted;
+                } else {
+                    toRun = () -> {};
+                    if (childTaskCompletedListeners == null) {
+                        childTaskCompletedListeners = new ArrayList<>();
+                    }
+                    childTaskCompletedListeners.add(onChildTasksCompleted);
+                }
+            }
+            toRun.run();
+            return pendingChildNodes;
+        }
+    }
+
+    /**
+     * Start tracking a cancellable task with its tcp channel, so if the channel gets closed we can get a set of
+    * pending tasks associated that channel and cancel them as these results won't be retrieved by the parent task.
+    *
+    * @return a releasable that should be called when this pending task is completed
+    */
+    public Releasable startTrackingCancellableChannelTask(TcpChannel channel, ProtobufCancellableTask task) {
+        assert cancellableTasks.containsKey(task.getId()) : "task [" + task.getId() + "] is not registered yet";
+        final ChannelPendingTaskTracker tracker = channelPendingTaskTrackers.compute(channel, (k, curr) -> {
+            if (curr == null) {
+                curr = new ChannelPendingTaskTracker();
+            }
+            curr.addTask(task);
+            return curr;
+        });
+        if (tracker.registered.compareAndSet(false, true)) {
+            channel.addCloseListener(ActionListener.wrap(r -> {
+                final ChannelPendingTaskTracker removedTracker = channelPendingTaskTrackers.remove(channel);
+                assert removedTracker == tracker;
+                cancelTasksOnChannelClosed(tracker.drainTasks());
+            }, e -> { assert false : new AssertionError("must not be here", e); }));
+        }
+        return () -> tracker.removeTask(task);
+    }
+
+    // for testing
+    final int numberOfChannelPendingTaskTrackers() {
+        return channelPendingTaskTrackers.size();
+    }
+
+    private static class ChannelPendingTaskTracker {
+        final AtomicBoolean registered = new AtomicBoolean();
+        final Semaphore permits = Assertions.ENABLED ? new Semaphore(Integer.MAX_VALUE) : null;
+        final Set<ProtobufCancellableTask> pendingTasks = ConcurrentCollections.newConcurrentSet();
+
+        void addTask(ProtobufCancellableTask task) {
+            assert permits.tryAcquire() : "tracker was drained";
+            final boolean added = pendingTasks.add(task);
+            assert added : "task " + task.getId() + " is in the pending list already";
+            assert releasePermit();
+        }
+
+        boolean acquireAllPermits() {
+            permits.acquireUninterruptibly(Integer.MAX_VALUE);
+            return true;
+        }
+
+        boolean releasePermit() {
+            permits.release();
+            return true;
+        }
+
+        Set<ProtobufCancellableTask> drainTasks() {
+            assert acquireAllPermits(); // do not release permits so we can't add tasks to this tracker after draining
+            return Collections.unmodifiableSet(pendingTasks);
+        }
+
+        void removeTask(ProtobufCancellableTask task) {
+            final boolean removed = pendingTasks.remove(task);
+            assert removed : "task " + task.getId() + " is not in the pending list";
+        }
+    }
+
+    private void cancelTasksOnChannelClosed(Set<ProtobufCancellableTask> tasks) {
+        if (tasks.isEmpty() == false) {
+            threadPool.generic().execute(new AbstractRunnable() {
+                @Override
+                public void onFailure(Exception e) {
+                    logger.warn("failed to cancel tasks on channel closed", e);
+                }
+
+                @Override
+                protected void doRun() {
+                    for (ProtobufCancellableTask task : tasks) {
+                        cancelTaskAndDescendants(task, "channel was closed", false, ActionListener.wrap(() -> {}));
+                    }
+                }
+            });
+        }
+    }
+
+    public void cancelTaskAndDescendants(ProtobufCancellableTask task, String reason, boolean waitForCompletion, ActionListener<Void> listener) {
+        final TaskCancellationService service = cancellationService.get();
+        if (service != null) {
+            service.cancelTaskAndDescendants(task, reason, waitForCompletion, listener);
+        } else {
+            assert false : "TaskCancellationService is not initialized";
+            throw new IllegalStateException("TaskCancellationService is not initialized");
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceTrackingService.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceTrackingService.java
new file mode 100644
index 0000000000000..8b67855d2fc98
--- /dev/null
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceTrackingService.java
@@ -0,0 +1,270 @@
+/*
+* 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.
+*/
+
+package org.opensearch.tasks;
+
+import com.sun.management.ThreadMXBean;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.ExceptionsHelper;
+import org.opensearch.common.SuppressForbidden;
+import org.opensearch.common.inject.Inject;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.concurrent.ConcurrentCollections;
+import org.opensearch.common.util.concurrent.ConcurrentMapLong;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.threadpool.RunnableTaskExecutionListener;
+import org.opensearch.threadpool.ProtobufThreadPool;
+
+import java.lang.management.ManagementFactory;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import static org.opensearch.tasks.ResourceStatsType.WORKER_STATS;
+
+/**
+ * Service that helps track resource usage of tasks running on a node.
+*/
+@SuppressForbidden(reason = "ThreadMXBean#getThreadAllocatedBytes")
+public class ProtobufTaskResourceTrackingService implements RunnableTaskExecutionListener {
+
+    private static final Logger logger = LogManager.getLogger(TaskManager.class);
+
+    public static final Setting<Boolean> TASK_RESOURCE_TRACKING_ENABLED = Setting.boolSetting(
+        "task_resource_tracking.enabled",
+        true,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope
+    );
+    public static final String TASK_ID = "TASK_ID";
+
+    private static final ThreadMXBean threadMXBean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
+
+    private final ConcurrentMapLong<ProtobufTask> resourceAwareTasks = ConcurrentCollections.newConcurrentMapLongWithAggressiveConcurrency();
+    private final List<TaskCompletionListener> taskCompletionListeners = new ArrayList<>();
+    private final ProtobufThreadPool threadPool;
+    private volatile boolean taskResourceTrackingEnabled;
+
+    @Inject
+    public ProtobufTaskResourceTrackingService(Settings settings, ClusterSettings clusterSettings, ProtobufThreadPool threadPool) {
+        this.taskResourceTrackingEnabled = TASK_RESOURCE_TRACKING_ENABLED.get(settings);
+        this.threadPool = threadPool;
+        clusterSettings.addSettingsUpdateConsumer(TASK_RESOURCE_TRACKING_ENABLED, this::setTaskResourceTrackingEnabled);
+    }
+
+    public void setTaskResourceTrackingEnabled(boolean taskResourceTrackingEnabled) {
+        this.taskResourceTrackingEnabled = taskResourceTrackingEnabled;
+    }
+
+    public boolean isTaskResourceTrackingEnabled() {
+        return taskResourceTrackingEnabled;
+    }
+
+    public boolean isTaskResourceTrackingSupported() {
+        return threadMXBean.isThreadAllocatedMemorySupported() && threadMXBean.isThreadAllocatedMemoryEnabled();
+    }
+
+    /**
+     * Executes logic only if task supports resource tracking and resource tracking setting is enabled.
+    * <p>
+    * 1. Starts tracking the task in map of resourceAwareTasks.
+    * 2. Adds ProtobufTask Id in thread context to make sure it's available while task is processed across multiple threads.
+    *
+    * @param task for which resources needs to be tracked
+    * @return Autocloseable stored context to restore ThreadContext to the state before this method changed it.
+    */
+    public ThreadContext.StoredContext startTracking(ProtobufTask task) {
+        if (task.supportsResourceTracking() == false
+            || isTaskResourceTrackingEnabled() == false
+            || isTaskResourceTrackingSupported() == false) {
+            return () -> {};
+        }
+
+        logger.debug("Starting resource tracking for task: {}", task.getId());
+        resourceAwareTasks.put(task.getId(), task);
+        return addTaskIdToThreadContext(task);
+    }
+
+    /**
+     * Stops tracking task registered earlier for tracking.
+    * <p>
+    * It doesn't have feature enabled check to avoid any issues if setting was disable while the task was in progress.
+    * <p>
+    * It's also responsible to stop tracking the current thread's resources against this task if not already done.
+    * This happens when the thread executing the request logic itself calls the unregister method. So in this case unregister
+    * happens before runnable finishes.
+    *
+    * @param task task which has finished and doesn't need resource tracking.
+    */
+    public void stopTracking(ProtobufTask task) {
+        logger.debug("Stopping resource tracking for task: {}", task.getId());
+        try {
+            if (isCurrentThreadWorkingOnTask(task)) {
+                taskExecutionFinishedOnThread(task.getId(), Thread.currentThread().getId());
+            }
+        } catch (Exception e) {
+            logger.warn("Failed while trying to mark the task execution on current thread completed.", e);
+            assert false;
+        } finally {
+            resourceAwareTasks.remove(task.getId());
+        }
+
+        List<Exception> exceptions = new ArrayList<>();
+        for (TaskCompletionListener listener : taskCompletionListeners) {
+            try {
+                listener.onTaskCompleted(task);
+            } catch (Exception e) {
+                exceptions.add(e);
+            }
+        }
+        ExceptionsHelper.maybeThrowRuntimeAndSuppress(exceptions);
+    }
+
+    /**
+     * Refreshes the resource stats for the tasks provided by looking into which threads are actively working on these
+    * and how much resources these have consumed till now.
+    *
+    * @param tasks for which resource stats needs to be refreshed.
+    */
+    public void refreshResourceStats(ProtobufTask... tasks) {
+        if (isTaskResourceTrackingEnabled() == false || isTaskResourceTrackingSupported() == false) {
+            return;
+        }
+
+        for (ProtobufTask task : tasks) {
+            if (task.supportsResourceTracking() && resourceAwareTasks.containsKey(task.getId())) {
+                refreshResourceStats(task);
+            }
+        }
+    }
+
+    private void refreshResourceStats(ProtobufTask resourceAwareTask) {
+        try {
+            logger.debug("Refreshing resource stats for ProtobufTask: {}", resourceAwareTask.getId());
+            List<Long> threadsWorkingOnTask = getThreadsWorkingOnTask(resourceAwareTask);
+            threadsWorkingOnTask.forEach(
+                threadId -> resourceAwareTask.updateThreadResourceStats(threadId, WORKER_STATS, getResourceUsageMetricsForThread(threadId))
+            );
+        } catch (IllegalStateException e) {
+            logger.debug("Resource stats already updated.");
+        }
+
+    }
+
+    /**
+     * Called when a thread starts working on a task's runnable.
+    *
+    * @param taskId   of the task for which runnable is starting
+    * @param threadId of the thread which will be executing the runnable and we need to check resource usage for this
+    *                 thread
+    */
+    @Override
+    public void taskExecutionStartedOnThread(long taskId, long threadId) {
+        try {
+            final ProtobufTask task = resourceAwareTasks.get(taskId);
+            if (task != null) {
+                logger.debug("ProtobufTask execution started on thread. ProtobufTask: {}, Thread: {}", taskId, threadId);
+                task.startThreadResourceTracking(threadId, WORKER_STATS, getResourceUsageMetricsForThread(threadId));
+            }
+        } catch (Exception e) {
+            logger.warn(new ParameterizedMessage("Failed to mark thread execution started for task: [{}]", taskId), e);
+            assert false;
+        }
+
+    }
+
+    /**
+     * Called when a thread finishes working on a task's runnable.
+    *
+    * @param taskId   of the task for which runnable is complete
+    * @param threadId of the thread which executed the runnable and we need to check resource usage for this thread
+    */
+    @Override
+    public void taskExecutionFinishedOnThread(long taskId, long threadId) {
+        try {
+            final ProtobufTask task = resourceAwareTasks.get(taskId);
+            if (task != null) {
+                logger.debug("ProtobufTask execution finished on thread. ProtobufTask: {}, Thread: {}", taskId, threadId);
+                task.stopThreadResourceTracking(threadId, WORKER_STATS, getResourceUsageMetricsForThread(threadId));
+            }
+        } catch (Exception e) {
+            logger.warn(new ParameterizedMessage("Failed to mark thread execution finished for task: [{}]", taskId), e);
+            assert false;
+        }
+    }
+
+    public Map<Long, ProtobufTask> getResourceAwareTasks() {
+        return Collections.unmodifiableMap(resourceAwareTasks);
+    }
+
+    private ResourceUsageMetric[] getResourceUsageMetricsForThread(long threadId) {
+        ResourceUsageMetric currentMemoryUsage = new ResourceUsageMetric(
+            ResourceStats.MEMORY,
+            threadMXBean.getThreadAllocatedBytes(threadId)
+        );
+        ResourceUsageMetric currentCPUUsage = new ResourceUsageMetric(ResourceStats.CPU, threadMXBean.getThreadCpuTime(threadId));
+        return new ResourceUsageMetric[] { currentMemoryUsage, currentCPUUsage };
+    }
+
+    private boolean isCurrentThreadWorkingOnTask(ProtobufTask task) {
+        long threadId = Thread.currentThread().getId();
+        List<ThreadResourceInfo> threadResourceInfos = task.getResourceStats().getOrDefault(threadId, Collections.emptyList());
+
+        for (ThreadResourceInfo threadResourceInfo : threadResourceInfos) {
+            if (threadResourceInfo.isActive()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private List<Long> getThreadsWorkingOnTask(ProtobufTask task) {
+        List<Long> activeThreads = new ArrayList<>();
+        for (List<ThreadResourceInfo> threadResourceInfos : task.getResourceStats().values()) {
+            for (ThreadResourceInfo threadResourceInfo : threadResourceInfos) {
+                if (threadResourceInfo.isActive()) {
+                    activeThreads.add(threadResourceInfo.getThreadId());
+                }
+            }
+        }
+        return activeThreads;
+    }
+
+    /**
+     * Adds ProtobufTask Id in the ThreadContext.
+    * <p>
+    * Stashes the existing ThreadContext and preserves all the existing ThreadContext's data in the new ThreadContext
+    * as well.
+    *
+    * @param task for which ProtobufTask Id needs to be added in ThreadContext.
+    * @return StoredContext reference to restore the ThreadContext from which we created a new one.
+    * Caller can call context.restore() to get the existing ThreadContext back.
+    */
+    private ThreadContext.StoredContext addTaskIdToThreadContext(ProtobufTask task) {
+        ThreadContext threadContext = threadPool.getThreadContext();
+        ThreadContext.StoredContext storedContext = threadContext.newStoredContext(true, Collections.singletonList(TASK_ID));
+        threadContext.putTransient(TASK_ID, task.getId());
+        return storedContext;
+    }
+
+    /**
+     * Listener that gets invoked when a task execution completes.
+    */
+    public interface TaskCompletionListener {
+        void onTaskCompleted(ProtobufTask task);
+    }
+
+    public void addTaskCompletionListener(TaskCompletionListener listener) {
+        this.taskCompletionListeners.add(listener);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/tasks/TaskResultsService.java b/server/src/main/java/org/opensearch/tasks/TaskResultsService.java
index 01be4eaaaf732..26cebbea22a6e 100644
--- a/server/src/main/java/org/opensearch/tasks/TaskResultsService.java
+++ b/server/src/main/java/org/opensearch/tasks/TaskResultsService.java
@@ -154,6 +154,53 @@ public void onFailure(Exception e) {
         }
     }
 
+    public void storeResult(ProtobufTaskResult taskResult, ActionListener<Void> listener) {
+
+        ClusterState state = clusterService.state();
+
+        if (state.routingTable().hasIndex(TASK_INDEX) == false) {
+            CreateIndexRequest createIndexRequest = new CreateIndexRequest();
+            createIndexRequest.settings(taskResultIndexSettings());
+            createIndexRequest.index(TASK_INDEX);
+            createIndexRequest.mapping(taskResultIndexMapping());
+            createIndexRequest.cause("auto(task api)");
+
+            client.admin().indices().create(createIndexRequest, new ActionListener<CreateIndexResponse>() {
+                @Override
+                public void onResponse(CreateIndexResponse result) {
+                    doStoreResult(taskResult, listener);
+                }
+
+                @Override
+                public void onFailure(Exception e) {
+                    if (ExceptionsHelper.unwrapCause(e) instanceof ResourceAlreadyExistsException) {
+                        // we have the index, do it
+                        try {
+                            doStoreResult(taskResult, listener);
+                        } catch (Exception inner) {
+                            inner.addSuppressed(e);
+                            listener.onFailure(inner);
+                        }
+                    } else {
+                        listener.onFailure(e);
+                    }
+                }
+            });
+        } else {
+            IndexMetadata metadata = state.getMetadata().index(TASK_INDEX);
+            if (getTaskResultMappingVersion(metadata) < TASK_RESULT_MAPPING_VERSION) {
+                // The index already exists but doesn't have our mapping
+                client.admin()
+                    .indices()
+                    .preparePutMapping(TASK_INDEX)
+                    .setSource(taskResultIndexMapping(), XContentType.JSON)
+                    .execute(ActionListener.delegateFailure(listener, (l, r) -> doStoreResult(taskResult, listener)));
+            } else {
+                doStoreResult(taskResult, listener);
+            }
+        }
+    }
+
     private int getTaskResultMappingVersion(IndexMetadata metadata) {
         MappingMetadata mappingMetadata = metadata.mapping();
         if (mappingMetadata == null) {
@@ -178,6 +225,17 @@ private void doStoreResult(TaskResult taskResult, ActionListener<Void> listener)
         doStoreResult(STORE_BACKOFF_POLICY.iterator(), index, listener);
     }
 
+    private void doStoreResult(ProtobufTaskResult taskResult, ActionListener<Void> listener) {
+        IndexRequestBuilder index = client.prepareIndex(TASK_INDEX).setId(taskResult.getTask().getTaskId().toString());
+        try (XContentBuilder builder = XContentFactory.contentBuilder(Requests.INDEX_CONTENT_TYPE)) {
+            taskResult.toXContent(builder, ToXContent.EMPTY_PARAMS);
+            index.setSource(builder);
+        } catch (IOException e) {
+            throw new OpenSearchException("Couldn't convert task result to XContent for [{}]", e, taskResult.getTask());
+        }
+        doStoreResult(STORE_BACKOFF_POLICY.iterator(), index, listener);
+    }
+
     private void doStoreResult(Iterator<TimeValue> backoff, IndexRequestBuilder index, ActionListener<Void> listener) {
         index.execute(new ActionListener<IndexResponse>() {
             @Override
diff --git a/server/src/main/java/org/opensearch/threadpool/ProtobufExecutorBuilder.java b/server/src/main/java/org/opensearch/threadpool/ProtobufExecutorBuilder.java
new file mode 100644
index 0000000000000..3276e5029e6f2
--- /dev/null
+++ b/server/src/main/java/org/opensearch/threadpool/ProtobufExecutorBuilder.java
@@ -0,0 +1,91 @@
+/*
+* 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.
+*/
+
+package org.opensearch.threadpool;
+
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.concurrent.OpenSearchExecutors;
+import org.opensearch.common.util.concurrent.ThreadContext;
+
+import java.util.List;
+
+/**
+ * Base class for executor builders.
+*
+* @param <U> the underlying type of the executor settings
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufExecutorBuilder<U extends ProtobufExecutorBuilder.ExecutorSettings> {
+
+    private final String name;
+
+    public ProtobufExecutorBuilder(String name) {
+        this.name = name;
+    }
+
+    protected String name() {
+        return name;
+    }
+
+    protected static String settingsKey(final String prefix, final String key) {
+        return String.join(".", prefix, key);
+    }
+
+    protected int applyHardSizeLimit(final Settings settings, final String name) {
+        if (name.equals("bulk") || name.equals(ThreadPool.Names.WRITE) || name.equals(ThreadPool.Names.SYSTEM_WRITE)) {
+            return 1 + OpenSearchExecutors.allocatedProcessors(settings);
+        } else {
+            return Integer.MAX_VALUE;
+        }
+    }
+
+    /**
+     * The list of settings this builder will register.
+    *
+    * @return the list of registered settings
+    */
+    public abstract List<Setting<?>> getRegisteredSettings();
+
+    /**
+     * Return an executor settings object from the node-level settings.
+    *
+    * @param settings the node-level settings
+    * @return the executor settings object
+    */
+    abstract U getSettings(Settings settings);
+
+    /**
+     * Builds the executor with the specified executor settings.
+    *
+    * @param settings      the executor settings
+    * @param threadContext the current thread context
+    * @return a new executor built from the specified executor settings
+    */
+    abstract ProtobufThreadPool.ExecutorHolder build(U settings, ThreadContext threadContext);
+
+    /**
+     * Format the thread pool info object for this executor.
+    *
+    * @param info the thread pool info object to format
+    * @return a formatted thread pool info (useful for logging)
+    */
+    abstract String formatInfo(ProtobufThreadPool.Info info);
+
+    abstract static class ExecutorSettings {
+
+        protected final String nodeName;
+
+        ExecutorSettings(String nodeName) {
+            this.nodeName = nodeName;
+        }
+
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/threadpool/ProtobufFixedExecutorBuilder.java b/server/src/main/java/org/opensearch/threadpool/ProtobufFixedExecutorBuilder.java
new file mode 100644
index 0000000000000..6d5bce32533ab
--- /dev/null
+++ b/server/src/main/java/org/opensearch/threadpool/ProtobufFixedExecutorBuilder.java
@@ -0,0 +1,182 @@
+/*
+* 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.
+*/
+
+package org.opensearch.threadpool;
+
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.ProtobufSizeValue;
+import org.opensearch.common.util.concurrent.OpenSearchExecutors;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.node.Node;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ThreadFactory;
+
+/**
+ * A builder for fixed executors.
+*
+* @opensearch.internal
+*/
+public final class ProtobufFixedExecutorBuilder extends ProtobufExecutorBuilder<ProtobufFixedExecutorBuilder.FixedExecutorSettings> {
+
+    private final Setting<Integer> sizeSetting;
+    private final Setting<Integer> queueSizeSetting;
+
+    /**
+     * Construct a fixed executor builder; the settings will have the key prefix "thread_pool." followed by the executor name.
+    *
+    * @param settings  the node-level settings
+    * @param name      the name of the executor
+    * @param size      the fixed number of threads
+    * @param queueSize the size of the backing queue, -1 for unbounded
+    */
+    ProtobufFixedExecutorBuilder(final Settings settings, final String name, final int size, final int queueSize) {
+        this(settings, name, size, queueSize, false);
+    }
+
+    /**
+     * Construct a fixed executor builder; the settings will have the key prefix "thread_pool." followed by the executor name.
+    *
+    * @param settings   the node-level settings
+    * @param name       the name of the executor
+    * @param size       the fixed number of threads
+    * @param queueSize  the size of the backing queue, -1 for unbounded
+    * @param deprecated whether or not the thread pool is deprecated
+    */
+    ProtobufFixedExecutorBuilder(
+        final Settings settings,
+        final String name,
+        final int size,
+        final int queueSize,
+        final boolean deprecated
+    ) {
+        this(settings, name, size, queueSize, "thread_pool." + name, deprecated);
+    }
+
+    /**
+     * Construct a fixed executor builder.
+    *
+    * @param settings  the node-level settings
+    * @param name      the name of the executor
+    * @param size      the fixed number of threads
+    * @param queueSize the size of the backing queue, -1 for unbounded
+    * @param prefix    the prefix for the settings keys
+    */
+    public ProtobufFixedExecutorBuilder(
+        final Settings settings,
+        final String name,
+        final int size,
+        final int queueSize,
+        final String prefix
+    ) {
+        this(settings, name, size, queueSize, prefix, false);
+    }
+
+    /**
+     * Construct a fixed executor builder.
+    *
+    * @param settings   the node-level settings
+    * @param name       the name of the executor
+    * @param size       the fixed number of threads
+    * @param queueSize  the size of the backing queue, -1 for unbounded
+    * @param prefix     the prefix for the settings keys
+    * @param deprecated whether or not the thread pool is deprecated
+    */
+    public ProtobufFixedExecutorBuilder(
+        final Settings settings,
+        final String name,
+        final int size,
+        final int queueSize,
+        final String prefix,
+        final boolean deprecated
+    ) {
+        super(name);
+        final String sizeKey = settingsKey(prefix, "size");
+        final Setting.Property[] properties;
+        if (deprecated) {
+            properties = new Setting.Property[] { Setting.Property.NodeScope, Setting.Property.Deprecated };
+        } else {
+            properties = new Setting.Property[] { Setting.Property.NodeScope };
+        }
+        this.sizeSetting = new Setting<>(
+            sizeKey,
+            s -> Integer.toString(size),
+            s -> Setting.parseInt(s, 1, applyHardSizeLimit(settings, name), sizeKey),
+            properties
+        );
+        final String queueSizeKey = settingsKey(prefix, "queue_size");
+        this.queueSizeSetting = Setting.intSetting(queueSizeKey, queueSize, properties);
+    }
+
+    @Override
+    public List<Setting<?>> getRegisteredSettings() {
+        return Arrays.asList(sizeSetting, queueSizeSetting);
+    }
+
+    @Override
+    FixedExecutorSettings getSettings(Settings settings) {
+        final String nodeName = Node.NODE_NAME_SETTING.get(settings);
+        final int size = sizeSetting.get(settings);
+        final int queueSize = queueSizeSetting.get(settings);
+        return new FixedExecutorSettings(nodeName, size, queueSize);
+    }
+
+    @Override
+    ProtobufThreadPool.ExecutorHolder build(final FixedExecutorSettings settings, final ThreadContext threadContext) {
+        int size = settings.size;
+        int queueSize = settings.queueSize;
+        final ThreadFactory threadFactory = OpenSearchExecutors.daemonThreadFactory(
+            OpenSearchExecutors.threadName(settings.nodeName, name())
+        );
+        final ExecutorService executor = OpenSearchExecutors.newFixed(
+            settings.nodeName + "/" + name(),
+            size,
+            queueSize,
+            threadFactory,
+            threadContext
+        );
+        final ProtobufThreadPool.Info info = new ProtobufThreadPool.Info(
+            name(),
+            ProtobufThreadPool.ThreadPoolType.FIXED,
+            size,
+            size,
+            null,
+            queueSize < 0 ? null : new ProtobufSizeValue(queueSize)
+        );
+        return new ProtobufThreadPool.ExecutorHolder(executor, info);
+    }
+
+    @Override
+    String formatInfo(ProtobufThreadPool.Info info) {
+        return String.format(
+            Locale.ROOT,
+            "name [%s], size [%d], queue size [%s]",
+            info.getName(),
+            info.getMax(),
+            info.getQueueSize() == null ? "unbounded" : info.getQueueSize()
+        );
+    }
+
+    static class FixedExecutorSettings extends ProtobufExecutorBuilder.ExecutorSettings {
+
+        private final int size;
+        private final int queueSize;
+
+        FixedExecutorSettings(final String nodeName, final int size, final int queueSize) {
+            super(nodeName);
+            this.size = size;
+            this.queueSize = queueSize;
+        }
+
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/threadpool/ProtobufResizableExecutorBuilder.java b/server/src/main/java/org/opensearch/threadpool/ProtobufResizableExecutorBuilder.java
new file mode 100644
index 0000000000000..f95a13d2b6a82
--- /dev/null
+++ b/server/src/main/java/org/opensearch/threadpool/ProtobufResizableExecutorBuilder.java
@@ -0,0 +1,134 @@
+/*
+* 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.
+*/
+
+package org.opensearch.threadpool;
+
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.ProtobufSizeValue;
+import org.opensearch.common.util.concurrent.OpenSearchExecutors;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.node.Node;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * A builder for resizable executors.
+*
+* @opensearch.internal
+*/
+public final class ProtobufResizableExecutorBuilder extends ProtobufExecutorBuilder<
+    ProtobufResizableExecutorBuilder.ResizableExecutorSettings> {
+
+    private final Setting<Integer> sizeSetting;
+    private final Setting<Integer> queueSizeSetting;
+    private final AtomicReference<RunnableTaskExecutionListener> runnableTaskListener;
+
+    ProtobufResizableExecutorBuilder(
+        final Settings settings,
+        final String name,
+        final int size,
+        final int queueSize,
+        final AtomicReference<RunnableTaskExecutionListener> runnableTaskListener
+    ) {
+        this(settings, name, size, queueSize, "thread_pool." + name, runnableTaskListener);
+    }
+
+    public ProtobufResizableExecutorBuilder(
+        final Settings settings,
+        final String name,
+        final int size,
+        final int queueSize,
+        final String prefix,
+        final AtomicReference<RunnableTaskExecutionListener> runnableTaskListener
+    ) {
+        super(name);
+        final String sizeKey = settingsKey(prefix, "size");
+        this.sizeSetting = new Setting<>(
+            sizeKey,
+            s -> Integer.toString(size),
+            s -> Setting.parseInt(s, 1, applyHardSizeLimit(settings, name), sizeKey),
+            Setting.Property.NodeScope
+        );
+        final String queueSizeKey = settingsKey(prefix, "queue_size");
+        this.queueSizeSetting = Setting.intSetting(
+            queueSizeKey,
+            queueSize,
+            new Setting.Property[] { Setting.Property.NodeScope, Setting.Property.Dynamic }
+        );
+        this.runnableTaskListener = runnableTaskListener;
+    }
+
+    @Override
+    public List<Setting<?>> getRegisteredSettings() {
+        return Arrays.asList(sizeSetting, queueSizeSetting);
+    }
+
+    @Override
+    ResizableExecutorSettings getSettings(Settings settings) {
+        final String nodeName = Node.NODE_NAME_SETTING.get(settings);
+        final int size = sizeSetting.get(settings);
+        final int queueSize = queueSizeSetting.get(settings);
+        return new ResizableExecutorSettings(nodeName, size, queueSize);
+    }
+
+    @Override
+    ProtobufThreadPool.ExecutorHolder build(final ResizableExecutorSettings settings, final ThreadContext threadContext) {
+        int size = settings.size;
+        int queueSize = settings.queueSize;
+        final ThreadFactory threadFactory = OpenSearchExecutors.daemonThreadFactory(
+            OpenSearchExecutors.threadName(settings.nodeName, name())
+        );
+        final ExecutorService executor = OpenSearchExecutors.newResizable(
+            settings.nodeName + "/" + name(),
+            size,
+            queueSize,
+            threadFactory,
+            threadContext,
+            runnableTaskListener
+        );
+        final ProtobufThreadPool.Info info = new ProtobufThreadPool.Info(
+            name(),
+            ProtobufThreadPool.ThreadPoolType.RESIZABLE,
+            size,
+            size,
+            null,
+            queueSize < 0 ? null : new ProtobufSizeValue(queueSize)
+        );
+        return new ProtobufThreadPool.ExecutorHolder(executor, info);
+    }
+
+    @Override
+    String formatInfo(ProtobufThreadPool.Info info) {
+        return String.format(
+            Locale.ROOT,
+            "name [%s], size [%d], queue size [%s]",
+            info.getName(),
+            info.getMax(),
+            info.getQueueSize() == null ? "unbounded" : info.getQueueSize()
+        );
+    }
+
+    static class ResizableExecutorSettings extends ProtobufExecutorBuilder.ExecutorSettings {
+
+        private final int size;
+        private final int queueSize;
+
+        ResizableExecutorSettings(final String nodeName, final int size, final int queueSize) {
+            super(nodeName);
+            this.size = size;
+            this.queueSize = queueSize;
+        }
+
+    }
+}
diff --git a/server/src/main/java/org/opensearch/threadpool/ProtobufScalingExecutorBuilder.java b/server/src/main/java/org/opensearch/threadpool/ProtobufScalingExecutorBuilder.java
new file mode 100644
index 0000000000000..583dfb4e785ba
--- /dev/null
+++ b/server/src/main/java/org/opensearch/threadpool/ProtobufScalingExecutorBuilder.java
@@ -0,0 +1,141 @@
+/*
+* 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.
+*/
+
+package org.opensearch.threadpool;
+
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.concurrent.OpenSearchExecutors;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.node.Node;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A builder for scaling executors.
+*
+* @opensearch.internal
+*/
+public final class ProtobufScalingExecutorBuilder extends ProtobufExecutorBuilder<ProtobufScalingExecutorBuilder.ScalingExecutorSettings> {
+
+    private final Setting<Integer> coreSetting;
+    private final Setting<Integer> maxSetting;
+    private final Setting<TimeValue> keepAliveSetting;
+
+    /**
+     * Construct a scaling executor builder; the settings will have the
+    * key prefix "thread_pool." followed by the executor name.
+    *
+    * @param name      the name of the executor
+    * @param core      the minimum number of threads in the pool
+    * @param max       the maximum number of threads in the pool
+    * @param keepAlive the time that spare threads above {@code core}
+    *                  threads will be kept alive
+    */
+    public ProtobufScalingExecutorBuilder(final String name, final int core, final int max, final TimeValue keepAlive) {
+        this(name, core, max, keepAlive, "thread_pool." + name);
+    }
+
+    /**
+     * Construct a scaling executor builder; the settings will have the
+    * specified key prefix.
+    *
+    * @param name      the name of the executor
+    * @param core      the minimum number of threads in the pool
+    * @param max       the maximum number of threads in the pool
+    * @param keepAlive the time that spare threads above {@code core}
+    *                  threads will be kept alive
+    * @param prefix    the prefix for the settings keys
+    */
+    public ProtobufScalingExecutorBuilder(
+        final String name,
+        final int core,
+        final int max,
+        final TimeValue keepAlive,
+        final String prefix
+    ) {
+        super(name);
+        this.coreSetting = Setting.intSetting(settingsKey(prefix, "core"), core, Setting.Property.NodeScope);
+        this.maxSetting = Setting.intSetting(settingsKey(prefix, "max"), max, Setting.Property.NodeScope);
+        this.keepAliveSetting = Setting.timeSetting(settingsKey(prefix, "keep_alive"), keepAlive, Setting.Property.NodeScope);
+    }
+
+    @Override
+    public List<Setting<?>> getRegisteredSettings() {
+        return Arrays.asList(coreSetting, maxSetting, keepAliveSetting);
+    }
+
+    @Override
+    ScalingExecutorSettings getSettings(Settings settings) {
+        final String nodeName = Node.NODE_NAME_SETTING.get(settings);
+        final int coreThreads = coreSetting.get(settings);
+        final int maxThreads = maxSetting.get(settings);
+        final TimeValue keepAlive = keepAliveSetting.get(settings);
+        return new ScalingExecutorSettings(nodeName, coreThreads, maxThreads, keepAlive);
+    }
+
+    ProtobufThreadPool.ExecutorHolder build(final ScalingExecutorSettings settings, final ThreadContext threadContext) {
+        TimeValue keepAlive = settings.keepAlive;
+        int core = settings.core;
+        int max = settings.max;
+        final ProtobufThreadPool.Info info = new ProtobufThreadPool.Info(
+            name(),
+            ProtobufThreadPool.ThreadPoolType.SCALING,
+            core,
+            max,
+            keepAlive,
+            null
+        );
+        final ThreadFactory threadFactory = OpenSearchExecutors.daemonThreadFactory(
+            OpenSearchExecutors.threadName(settings.nodeName, name())
+        );
+        final ExecutorService executor = OpenSearchExecutors.newScaling(
+            settings.nodeName + "/" + name(),
+            core,
+            max,
+            keepAlive.millis(),
+            TimeUnit.MILLISECONDS,
+            threadFactory,
+            threadContext
+        );
+        return new ProtobufThreadPool.ExecutorHolder(executor, info);
+    }
+
+    @Override
+    String formatInfo(ProtobufThreadPool.Info info) {
+        return String.format(
+            Locale.ROOT,
+            "name [%s], core [%d], max [%d], keep alive [%s]",
+            info.getName(),
+            info.getMin(),
+            info.getMax(),
+            info.getKeepAlive()
+        );
+    }
+
+    static class ScalingExecutorSettings extends ProtobufExecutorBuilder.ExecutorSettings {
+
+        private final int core;
+        private final int max;
+        private final TimeValue keepAlive;
+
+        ScalingExecutorSettings(final String nodeName, final int core, final int max, final TimeValue keepAlive) {
+            super(nodeName);
+            this.core = core;
+            this.max = max;
+            this.keepAlive = keepAlive;
+        }
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPool.java b/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPool.java
new file mode 100644
index 0000000000000..d48704fa5777a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPool.java
@@ -0,0 +1,860 @@
+/*
+* 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.
+*/
+
+package org.opensearch.threadpool;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.Version;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.ProtobufSizeValue;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.concurrent.OpenSearchExecutors;
+import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
+import org.opensearch.common.util.concurrent.OpenSearchThreadPoolExecutor;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.util.concurrent.XRejectedExecutionHandler;
+import org.opensearch.node.Node;
+import org.opensearch.node.ProtobufReportingService;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.RejectedExecutionHandler;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
+
+import static java.util.Collections.unmodifiableMap;
+
+/**
+ * The OpenSearch threadpool class
+*
+* @opensearch.internal
+*/
+public class ProtobufThreadPool implements ProtobufReportingService<ProtobufThreadPoolInfo>, Scheduler {
+
+    private static final Logger logger = LogManager.getLogger(ThreadPool.class);
+
+    /**
+     * The threadpool names.
+    *
+    * @opensearch.internal
+    */
+    public static class Names {
+        public static final String SAME = "same";
+        public static final String GENERIC = "generic";
+        @Deprecated
+        public static final String LISTENER = "listener";
+        public static final String GET = "get";
+        public static final String ANALYZE = "analyze";
+        public static final String WRITE = "write";
+        public static final String SEARCH = "search";
+        public static final String SEARCH_THROTTLED = "search_throttled";
+        public static final String MANAGEMENT = "management";
+        public static final String FLUSH = "flush";
+        public static final String REFRESH = "refresh";
+        public static final String WARMER = "warmer";
+        public static final String SNAPSHOT = "snapshot";
+        public static final String FORCE_MERGE = "force_merge";
+        public static final String FETCH_SHARD_STARTED = "fetch_shard_started";
+        public static final String FETCH_SHARD_STORE = "fetch_shard_store";
+        public static final String SYSTEM_READ = "system_read";
+        public static final String SYSTEM_WRITE = "system_write";
+        public static final String TRANSLOG_TRANSFER = "translog_transfer";
+        public static final String TRANSLOG_SYNC = "translog_sync";
+        public static final String REMOTE_PURGE = "remote_purge";
+    }
+
+    /**
+     * The threadpool type.
+    *
+    * @opensearch.internal
+    */
+    public enum ThreadPoolType {
+        DIRECT("direct"),
+        FIXED("fixed"),
+        RESIZABLE("resizable"),
+        SCALING("scaling");
+
+        private final String type;
+
+        public String getType() {
+            return type;
+        }
+
+        ThreadPoolType(String type) {
+            this.type = type;
+        }
+
+        private static final Map<String, ThreadPoolType> TYPE_MAP;
+
+        static {
+            Map<String, ThreadPoolType> typeMap = new HashMap<>();
+            for (ThreadPoolType threadPoolType : ThreadPoolType.values()) {
+                typeMap.put(threadPoolType.getType(), threadPoolType);
+            }
+            TYPE_MAP = Collections.unmodifiableMap(typeMap);
+        }
+
+        public static ThreadPoolType fromType(String type) {
+            ThreadPoolType threadPoolType = TYPE_MAP.get(type);
+            if (threadPoolType == null) {
+                throw new IllegalArgumentException("no ThreadPoolType for " + type);
+            }
+            return threadPoolType;
+        }
+    }
+
+    public static final Map<String, ThreadPoolType> THREAD_POOL_TYPES;
+
+    static {
+        HashMap<String, ThreadPoolType> map = new HashMap<>();
+        map.put(Names.SAME, ThreadPoolType.DIRECT);
+        map.put(Names.GENERIC, ThreadPoolType.SCALING);
+        map.put(Names.LISTENER, ThreadPoolType.FIXED);
+        map.put(Names.GET, ThreadPoolType.FIXED);
+        map.put(Names.ANALYZE, ThreadPoolType.FIXED);
+        map.put(Names.WRITE, ThreadPoolType.FIXED);
+        map.put(Names.SEARCH, ThreadPoolType.RESIZABLE);
+        map.put(Names.MANAGEMENT, ThreadPoolType.SCALING);
+        map.put(Names.FLUSH, ThreadPoolType.SCALING);
+        map.put(Names.REFRESH, ThreadPoolType.SCALING);
+        map.put(Names.WARMER, ThreadPoolType.SCALING);
+        map.put(Names.SNAPSHOT, ThreadPoolType.SCALING);
+        map.put(Names.FORCE_MERGE, ThreadPoolType.FIXED);
+        map.put(Names.FETCH_SHARD_STARTED, ThreadPoolType.SCALING);
+        map.put(Names.FETCH_SHARD_STORE, ThreadPoolType.SCALING);
+        map.put(Names.SEARCH_THROTTLED, ThreadPoolType.RESIZABLE);
+        map.put(Names.SYSTEM_READ, ThreadPoolType.FIXED);
+        map.put(Names.SYSTEM_WRITE, ThreadPoolType.FIXED);
+        map.put(Names.TRANSLOG_TRANSFER, ThreadPoolType.SCALING);
+        map.put(Names.TRANSLOG_SYNC, ThreadPoolType.FIXED);
+        map.put(Names.REMOTE_PURGE, ThreadPoolType.SCALING);
+        THREAD_POOL_TYPES = Collections.unmodifiableMap(map);
+    }
+
+    private final Map<String, ExecutorHolder> executors;
+
+    private final ProtobufThreadPoolInfo threadPoolInfo;
+
+    private final CachedTimeThread cachedTimeThread;
+
+    static final ExecutorService DIRECT_EXECUTOR = OpenSearchExecutors.newDirectExecutorService();
+
+    private final ThreadContext threadContext;
+
+    private final Map<String, ProtobufExecutorBuilder> builders;
+
+    private final ScheduledThreadPoolExecutor scheduler;
+
+    public Collection<ProtobufExecutorBuilder> builders() {
+        return Collections.unmodifiableCollection(builders.values());
+    }
+
+    public static Setting<TimeValue> ESTIMATED_TIME_INTERVAL_SETTING = Setting.timeSetting(
+        "thread_pool.estimated_time_interval",
+        TimeValue.timeValueMillis(200),
+        TimeValue.ZERO,
+        Setting.Property.NodeScope
+    );
+
+    public ProtobufThreadPool(final Settings settings, final ProtobufExecutorBuilder<?>... customBuilders) {
+        this(settings, null, customBuilders);
+    }
+
+    public ProtobufThreadPool(
+        final Settings settings,
+        final AtomicReference<RunnableTaskExecutionListener> runnableTaskListener,
+        final ProtobufExecutorBuilder<?>... customBuilders
+    ) {
+        assert Node.NODE_NAME_SETTING.exists(settings);
+
+        final Map<String, ProtobufExecutorBuilder> builders = new HashMap<>();
+        final int allocatedProcessors = OpenSearchExecutors.allocatedProcessors(settings);
+        final int halfProcMaxAt5 = halfAllocatedProcessorsMaxFive(allocatedProcessors);
+        final int halfProcMaxAt10 = halfAllocatedProcessorsMaxTen(allocatedProcessors);
+        final int genericThreadPoolMax = boundedBy(4 * allocatedProcessors, 128, 512);
+        builders.put(
+            Names.GENERIC,
+            new ProtobufScalingExecutorBuilder(Names.GENERIC, 4, genericThreadPoolMax, TimeValue.timeValueSeconds(30))
+        );
+        builders.put(Names.WRITE, new ProtobufFixedExecutorBuilder(settings, Names.WRITE, allocatedProcessors, 10000));
+        builders.put(Names.GET, new ProtobufFixedExecutorBuilder(settings, Names.GET, allocatedProcessors, 1000));
+        builders.put(Names.ANALYZE, new ProtobufFixedExecutorBuilder(settings, Names.ANALYZE, 1, 16));
+        builders.put(
+            Names.SEARCH,
+            new ProtobufResizableExecutorBuilder(
+                settings,
+                Names.SEARCH,
+                searchThreadPoolSize(allocatedProcessors),
+                1000,
+                runnableTaskListener
+            )
+        );
+        builders.put(
+            Names.SEARCH_THROTTLED,
+            new ProtobufResizableExecutorBuilder(settings, Names.SEARCH_THROTTLED, 1, 100, runnableTaskListener)
+        );
+        builders.put(Names.MANAGEMENT, new ProtobufScalingExecutorBuilder(Names.MANAGEMENT, 1, 5, TimeValue.timeValueMinutes(5)));
+        // no queue as this means clients will need to handle rejections on listener queue even if the operation succeeded
+        // the assumption here is that the listeners should be very lightweight on the listeners side
+        builders.put(Names.LISTENER, new ProtobufFixedExecutorBuilder(settings, Names.LISTENER, halfProcMaxAt10, -1, true));
+        builders.put(Names.FLUSH, new ProtobufScalingExecutorBuilder(Names.FLUSH, 1, halfProcMaxAt5, TimeValue.timeValueMinutes(5)));
+        builders.put(Names.REFRESH, new ProtobufScalingExecutorBuilder(Names.REFRESH, 1, halfProcMaxAt10, TimeValue.timeValueMinutes(5)));
+        builders.put(Names.WARMER, new ProtobufScalingExecutorBuilder(Names.WARMER, 1, halfProcMaxAt5, TimeValue.timeValueMinutes(5)));
+        builders.put(Names.SNAPSHOT, new ProtobufScalingExecutorBuilder(Names.SNAPSHOT, 1, halfProcMaxAt5, TimeValue.timeValueMinutes(5)));
+        builders.put(
+            Names.FETCH_SHARD_STARTED,
+            new ProtobufScalingExecutorBuilder(Names.FETCH_SHARD_STARTED, 1, 2 * allocatedProcessors, TimeValue.timeValueMinutes(5))
+        );
+        builders.put(Names.FORCE_MERGE, new ProtobufFixedExecutorBuilder(settings, Names.FORCE_MERGE, 1, -1));
+        builders.put(
+            Names.FETCH_SHARD_STORE,
+            new ProtobufScalingExecutorBuilder(Names.FETCH_SHARD_STORE, 1, 2 * allocatedProcessors, TimeValue.timeValueMinutes(5))
+        );
+        builders.put(Names.SYSTEM_READ, new ProtobufFixedExecutorBuilder(settings, Names.SYSTEM_READ, halfProcMaxAt5, 2000, false));
+        builders.put(Names.SYSTEM_WRITE, new ProtobufFixedExecutorBuilder(settings, Names.SYSTEM_WRITE, halfProcMaxAt5, 1000, false));
+        builders.put(
+            Names.TRANSLOG_TRANSFER,
+            new ProtobufScalingExecutorBuilder(Names.TRANSLOG_TRANSFER, 1, halfProcMaxAt10, TimeValue.timeValueMinutes(5))
+        );
+        builders.put(Names.TRANSLOG_SYNC, new ProtobufFixedExecutorBuilder(settings, Names.TRANSLOG_SYNC, allocatedProcessors * 4, 10000));
+        builders.put(
+            Names.REMOTE_PURGE,
+            new ProtobufScalingExecutorBuilder(Names.REMOTE_PURGE, 1, halfProcMaxAt5, TimeValue.timeValueMinutes(5))
+        );
+
+        for (final ProtobufExecutorBuilder<?> builder : customBuilders) {
+            if (builders.containsKey(builder.name())) {
+                throw new IllegalArgumentException("builder with name [" + builder.name() + "] already exists");
+            }
+            builders.put(builder.name(), builder);
+        }
+        this.builders = Collections.unmodifiableMap(builders);
+
+        threadContext = new ThreadContext(settings);
+
+        final Map<String, ExecutorHolder> executors = new HashMap<>();
+        for (final Map.Entry<String, ProtobufExecutorBuilder> entry : builders.entrySet()) {
+            final ProtobufExecutorBuilder.ExecutorSettings executorSettings = entry.getValue().getSettings(settings);
+            final ExecutorHolder executorHolder = entry.getValue().build(executorSettings, threadContext);
+            if (executors.containsKey(executorHolder.info.getName())) {
+                throw new IllegalStateException("duplicate executors with name [" + executorHolder.info.getName() + "] registered");
+            }
+            logger.debug("created thread pool: {}", entry.getValue().formatInfo(executorHolder.info));
+            executors.put(entry.getKey(), executorHolder);
+        }
+
+        executors.put(Names.SAME, new ExecutorHolder(DIRECT_EXECUTOR, new Info(Names.SAME, ThreadPoolType.DIRECT)));
+        this.executors = unmodifiableMap(executors);
+
+        final List<Info> infos = executors.values()
+            .stream()
+            .filter(holder -> holder.info.getName().equals("same") == false)
+            .map(holder -> holder.info)
+            .collect(Collectors.toList());
+        this.threadPoolInfo = new ProtobufThreadPoolInfo(infos);
+        this.scheduler = Scheduler.initScheduler(settings);
+        TimeValue estimatedTimeInterval = ESTIMATED_TIME_INTERVAL_SETTING.get(settings);
+        this.cachedTimeThread = new CachedTimeThread(OpenSearchExecutors.threadName(settings, "[timer]"), estimatedTimeInterval.millis());
+        this.cachedTimeThread.start();
+    }
+
+    /**
+     * Returns a value of milliseconds that may be used for relative time calculations.
+    *
+    * This method should only be used for calculating time deltas. For an epoch based
+    * timestamp, see {@link #absoluteTimeInMillis()}.
+    */
+    public long relativeTimeInMillis() {
+        return TimeValue.nsecToMSec(relativeTimeInNanos());
+    }
+
+    /**
+     * Returns a value of nanoseconds that may be used for relative time calculations.
+    *
+    * This method should only be used for calculating time deltas. For an epoch based
+    * timestamp, see {@link #absoluteTimeInMillis()}.
+    */
+    public long relativeTimeInNanos() {
+        return cachedTimeThread.relativeTimeInNanos();
+    }
+
+    /**
+     * Returns the value of milliseconds since UNIX epoch.
+    *
+    * This method should only be used for exact date/time formatting. For calculating
+    * time deltas that should not suffer from negative deltas, which are possible with
+    * this method, see {@link #relativeTimeInMillis()}.
+    */
+    public long absoluteTimeInMillis() {
+        return cachedTimeThread.absoluteTimeInMillis();
+    }
+
+    @Override
+    public ProtobufThreadPoolInfo info() {
+        return threadPoolInfo;
+    }
+
+    public Info info(String name) {
+        ExecutorHolder holder = executors.get(name);
+        if (holder == null) {
+            return null;
+        }
+        return holder.info;
+    }
+
+    public ThreadPoolStats stats() {
+        List<ThreadPoolStats.Stats> stats = new ArrayList<>();
+        for (ExecutorHolder holder : executors.values()) {
+            final String name = holder.info.getName();
+            // no need to have info on "same" thread pool
+            if ("same".equals(name)) {
+                continue;
+            }
+            int threads = -1;
+            int queue = -1;
+            int active = -1;
+            long rejected = -1;
+            int largest = -1;
+            long completed = -1;
+            if (holder.executor() instanceof ThreadPoolExecutor) {
+                ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) holder.executor();
+                threads = threadPoolExecutor.getPoolSize();
+                queue = threadPoolExecutor.getQueue().size();
+                active = threadPoolExecutor.getActiveCount();
+                largest = threadPoolExecutor.getLargestPoolSize();
+                completed = threadPoolExecutor.getCompletedTaskCount();
+                RejectedExecutionHandler rejectedExecutionHandler = threadPoolExecutor.getRejectedExecutionHandler();
+                if (rejectedExecutionHandler instanceof XRejectedExecutionHandler) {
+                    rejected = ((XRejectedExecutionHandler) rejectedExecutionHandler).rejected();
+                }
+            }
+            stats.add(new ThreadPoolStats.Stats(name, threads, queue, active, rejected, largest, completed));
+        }
+        return new ThreadPoolStats(stats);
+    }
+
+    /**
+     * Get the generic {@link ExecutorService}. This executor service
+    * {@link Executor#execute(Runnable)} method will run the {@link Runnable} it is given in the
+    * {@link ThreadContext} of the thread that queues it.
+    * <p>
+    * Warning: this {@linkplain ExecutorService} will not throw {@link RejectedExecutionException}
+    * if you submit a task while it shutdown. It will instead silently queue it and not run it.
+    */
+    public ExecutorService generic() {
+        return executor(Names.GENERIC);
+    }
+
+    /**
+     * Get the {@link ExecutorService} with the given name. This executor service's
+    * {@link Executor#execute(Runnable)} method will run the {@link Runnable} it is given in the
+    * {@link ThreadContext} of the thread that queues it.
+    * <p>
+    * Warning: this {@linkplain ExecutorService} might not throw {@link RejectedExecutionException}
+    * if you submit a task while it shutdown. It will instead silently queue it and not run it.
+    *
+    * @param name the name of the executor service to obtain
+    * @throws IllegalArgumentException if no executor service with the specified name exists
+    */
+    public ExecutorService executor(String name) {
+        final ExecutorHolder holder = executors.get(name);
+        if (holder == null) {
+            throw new IllegalArgumentException("no executor service found for [" + name + "]");
+        }
+        return holder.executor();
+    }
+
+    /**
+     * Schedules a one-shot command to run after a given delay. The command is run in the context of the calling thread.
+    *
+    * @param command the command to run
+    * @param delay delay before the task executes
+    * @param executor the name of the thread pool on which to execute this task. SAME means "execute on the scheduler thread" which changes
+    *        the meaning of the ScheduledFuture returned by this method. In that case the ScheduledFuture will complete only when the
+    *        command completes.
+    * @return a ScheduledFuture who's get will return when the task is has been added to its target thread pool and throw an exception if
+    *         the task is canceled before it was added to its target thread pool. Once the task has been added to its target thread pool
+    *         the ScheduledFuture will cannot interact with it.
+    * @throws OpenSearchRejectedExecutionException if the task cannot be scheduled for execution
+    */
+    @Override
+    public ScheduledCancellable schedule(Runnable command, TimeValue delay, String executor) {
+        command = threadContext.preserveContext(command);
+        if (!Names.SAME.equals(executor)) {
+            command = new ThreadedRunnable(command, executor(executor));
+        }
+        return new ScheduledCancellableAdapter(scheduler.schedule(command, delay.millis(), TimeUnit.MILLISECONDS));
+    }
+
+    public void scheduleUnlessShuttingDown(TimeValue delay, String executor, Runnable command) {
+        try {
+            schedule(command, delay, executor);
+        } catch (OpenSearchRejectedExecutionException e) {
+            if (e.isExecutorShutdown()) {
+                logger.debug(
+                    new ParameterizedMessage(
+                        "could not schedule execution of [{}] after [{}] on [{}] as executor is shut down",
+                        command,
+                        delay,
+                        executor
+                    ),
+                    e
+                );
+            } else {
+                throw e;
+            }
+        }
+    }
+
+    @Override
+    public Cancellable scheduleWithFixedDelay(Runnable command, TimeValue interval, String executor) {
+        return new ReschedulingRunnable(command, interval, executor, this, (e) -> {
+            if (logger.isDebugEnabled()) {
+                logger.debug(() -> new ParameterizedMessage("scheduled task [{}] was rejected on thread pool [{}]", command, executor), e);
+            }
+        },
+            (e) -> logger.warn(
+                () -> new ParameterizedMessage("failed to run scheduled task [{}] on thread pool [{}]", command, executor),
+                e
+            )
+        );
+    }
+
+    protected final void stopCachedTimeThread() {
+        cachedTimeThread.running = false;
+        cachedTimeThread.interrupt();
+    }
+
+    public void shutdown() {
+        stopCachedTimeThread();
+        scheduler.shutdown();
+        for (ExecutorHolder executor : executors.values()) {
+            if (executor.executor() instanceof ThreadPoolExecutor) {
+                executor.executor().shutdown();
+            }
+        }
+    }
+
+    public void shutdownNow() {
+        stopCachedTimeThread();
+        scheduler.shutdownNow();
+        for (ExecutorHolder executor : executors.values()) {
+            if (executor.executor() instanceof ThreadPoolExecutor) {
+                executor.executor().shutdownNow();
+            }
+        }
+    }
+
+    public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
+        boolean result = scheduler.awaitTermination(timeout, unit);
+        for (ExecutorHolder executor : executors.values()) {
+            if (executor.executor() instanceof ThreadPoolExecutor) {
+                result &= executor.executor().awaitTermination(timeout, unit);
+            }
+        }
+        cachedTimeThread.join(unit.toMillis(timeout));
+        return result;
+    }
+
+    public ScheduledExecutorService scheduler() {
+        return this.scheduler;
+    }
+
+    /**
+     * Constrains a value between minimum and maximum values
+    * (inclusive).
+    *
+    * @param value the value to constrain
+    * @param min   the minimum acceptable value
+    * @param max   the maximum acceptable value
+    * @return min if value is less than min, max if value is greater
+    * than value, otherwise value
+    */
+    static int boundedBy(int value, int min, int max) {
+        return Math.min(max, Math.max(min, value));
+    }
+
+    static int halfAllocatedProcessorsMaxFive(final int allocatedProcessors) {
+        return boundedBy((allocatedProcessors + 1) / 2, 1, 5);
+    }
+
+    static int halfAllocatedProcessorsMaxTen(final int allocatedProcessors) {
+        return boundedBy((allocatedProcessors + 1) / 2, 1, 10);
+    }
+
+    static int twiceAllocatedProcessors(final int allocatedProcessors) {
+        return boundedBy(2 * allocatedProcessors, 2, Integer.MAX_VALUE);
+    }
+
+    public static int searchThreadPoolSize(final int allocatedProcessors) {
+        return ((allocatedProcessors * 3) / 2) + 1;
+    }
+
+    class LoggingRunnable implements Runnable {
+
+        private final Runnable runnable;
+
+        LoggingRunnable(Runnable runnable) {
+            this.runnable = runnable;
+        }
+
+        @Override
+        public void run() {
+            try {
+                runnable.run();
+            } catch (Exception e) {
+                logger.warn(() -> new ParameterizedMessage("failed to run {}", runnable.toString()), e);
+                throw e;
+            }
+        }
+
+        @Override
+        public int hashCode() {
+            return runnable.hashCode();
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            return runnable.equals(obj);
+        }
+
+        @Override
+        public String toString() {
+            return "[threaded] " + runnable.toString();
+        }
+    }
+
+    class ThreadedRunnable implements Runnable {
+
+        private final Runnable runnable;
+
+        private final Executor executor;
+
+        ThreadedRunnable(Runnable runnable, Executor executor) {
+            this.runnable = runnable;
+            this.executor = executor;
+        }
+
+        @Override
+        public void run() {
+            try {
+                executor.execute(runnable);
+            } catch (OpenSearchRejectedExecutionException e) {
+                if (e.isExecutorShutdown()) {
+                    logger.debug(
+                        new ParameterizedMessage(
+                            "could not schedule execution of [{}] on [{}] as executor is shut down",
+                            runnable,
+                            executor
+                        ),
+                        e
+                    );
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        @Override
+        public int hashCode() {
+            return runnable.hashCode();
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            return runnable.equals(obj);
+        }
+
+        @Override
+        public String toString() {
+            return "[threaded] " + runnable.toString();
+        }
+    }
+
+    /**
+     * A thread to cache millisecond time values from
+    * {@link System#nanoTime()} and {@link System#currentTimeMillis()}.
+    *
+    * The values are updated at a specified interval.
+    */
+    static class CachedTimeThread extends Thread {
+
+        final long interval;
+        volatile boolean running = true;
+        volatile long relativeNanos;
+        volatile long absoluteMillis;
+
+        CachedTimeThread(String name, long interval) {
+            super(name);
+            this.interval = interval;
+            this.relativeNanos = System.nanoTime();
+            this.absoluteMillis = System.currentTimeMillis();
+            setDaemon(true);
+        }
+
+        /**
+         * Return the current time used for relative calculations. This is {@link System#nanoTime()}.
+        * <p>
+        * If {@link ThreadPool#ESTIMATED_TIME_INTERVAL_SETTING} is set to 0
+        * then the cache is disabled and the method calls {@link System#nanoTime()}
+        * whenever called. Typically used for testing.
+        */
+        long relativeTimeInNanos() {
+            if (0 < interval) {
+                return relativeNanos;
+            }
+            return System.nanoTime();
+        }
+
+        /**
+         * Return the current epoch time, used to find absolute time. This is
+        * a cached version of {@link System#currentTimeMillis()}.
+        * <p>
+        * If {@link ThreadPool#ESTIMATED_TIME_INTERVAL_SETTING} is set to 0
+        * then the cache is disabled and the method calls {@link System#currentTimeMillis()}
+        * whenever called. Typically used for testing.
+        */
+        long absoluteTimeInMillis() {
+            if (0 < interval) {
+                return absoluteMillis;
+            }
+            return System.currentTimeMillis();
+        }
+
+        @Override
+        public void run() {
+            while (running && 0 < interval) {
+                relativeNanos = System.nanoTime();
+                absoluteMillis = System.currentTimeMillis();
+                try {
+                    Thread.sleep(interval);
+                } catch (InterruptedException e) {
+                    running = false;
+                    return;
+                }
+            }
+        }
+    }
+
+    static class ExecutorHolder {
+        private final ExecutorService executor;
+        public final Info info;
+
+        ExecutorHolder(ExecutorService executor, Info info) {
+            assert executor instanceof OpenSearchThreadPoolExecutor || executor == DIRECT_EXECUTOR;
+            this.executor = executor;
+            this.info = info;
+        }
+
+        ExecutorService executor() {
+            return executor;
+        }
+    }
+
+    /**
+     * The thread pool information.
+    *
+    * @opensearch.internal
+    */
+    public static class Info implements ProtobufWriteable {
+
+        private final String name;
+        private final ThreadPoolType type;
+        private final int min;
+        private final int max;
+        private final TimeValue keepAlive;
+        private final ProtobufSizeValue queueSize;
+
+        public Info(String name, ThreadPoolType type) {
+            this(name, type, -1);
+        }
+
+        public Info(String name, ThreadPoolType type, int size) {
+            this(name, type, size, size, null, null);
+        }
+
+        public Info(
+            String name,
+            ThreadPoolType type,
+            int min,
+            int max,
+            @Nullable TimeValue keepAlive,
+            @Nullable ProtobufSizeValue queueSize
+        ) {
+            this.name = name;
+            this.type = type;
+            this.min = min;
+            this.max = max;
+            this.keepAlive = keepAlive;
+            this.queueSize = queueSize;
+        }
+
+        public Info(CodedInputStream in) throws IOException {
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+            name = in.readString();
+            final String typeStr = in.readString();
+            // Opensearch on or after 3.0.0 version doesn't know about "fixed_auto_queue_size" thread pool. Convert it to RESIZABLE.
+            if (typeStr.equalsIgnoreCase("fixed_auto_queue_size")) {
+                type = ThreadPoolType.RESIZABLE;
+            } else {
+                type = ThreadPoolType.fromType(typeStr);
+            }
+            min = in.readInt32();
+            max = in.readInt32();
+            keepAlive = protobufStreamInput.readOptionalTimeValue(in);
+            queueSize = protobufStreamInput.readOptionalWriteable(ProtobufSizeValue::new, in);
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+            out.writeStringNoTag(name);
+            if (type == ThreadPoolType.RESIZABLE && protobufStreamOutput.getVersion().before(Version.V_3_0_0)) {
+                // Opensearch on older version doesn't know about "resizable" thread pool. Convert RESIZABLE to FIXED
+                // to avoid serialization/de-serization issue between nodes with different OpenSearch version
+                out.writeStringNoTag(ThreadPoolType.FIXED.getType());
+            } else {
+                out.writeStringNoTag(type.getType());
+            }
+            out.writeInt32NoTag(min);
+            out.writeInt32NoTag(max);
+            protobufStreamOutput.writeOptionalTimeValue(keepAlive, out);
+            protobufStreamOutput.writeOptionalWriteable(queueSize, out);
+        }
+
+        public String getName() {
+            return this.name;
+        }
+
+        public ThreadPoolType getThreadPoolType() {
+            return this.type;
+        }
+
+        public int getMin() {
+            return this.min;
+        }
+
+        public int getMax() {
+            return this.max;
+        }
+
+        @Nullable
+        public TimeValue getKeepAlive() {
+            return this.keepAlive;
+        }
+
+        @Nullable
+        public ProtobufSizeValue getQueueSize() {
+            return this.queueSize;
+        }
+    }
+
+    /**
+     * Returns <code>true</code> if the given service was terminated successfully. If the termination timed out,
+    * the service is <code>null</code> this method will return <code>false</code>.
+    */
+    public static boolean terminate(ExecutorService service, long timeout, TimeUnit timeUnit) {
+        if (service != null) {
+            service.shutdown();
+            if (awaitTermination(service, timeout, timeUnit)) return true;
+            service.shutdownNow();
+            return awaitTermination(service, timeout, timeUnit);
+        }
+        return false;
+    }
+
+    private static boolean awaitTermination(final ExecutorService service, final long timeout, final TimeUnit timeUnit) {
+        try {
+            if (service.awaitTermination(timeout, timeUnit)) {
+                return true;
+            }
+        } catch (final InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+        return false;
+    }
+
+    /**
+     * Returns <code>true</code> if the given pool was terminated successfully. If the termination timed out,
+    * the service is <code>null</code> this method will return <code>false</code>.
+    */
+    public static boolean terminate(ThreadPool pool, long timeout, TimeUnit timeUnit) {
+        if (pool != null) {
+            // Leverage try-with-resources to close the threadpool
+            pool.shutdown();
+            if (awaitTermination(pool, timeout, timeUnit)) {
+                return true;
+            }
+            // last resort
+            pool.shutdownNow();
+            return awaitTermination(pool, timeout, timeUnit);
+        }
+        return false;
+    }
+
+    private static boolean awaitTermination(final ThreadPool threadPool, final long timeout, final TimeUnit timeUnit) {
+        try {
+            if (threadPool.awaitTermination(timeout, timeUnit)) {
+                return true;
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+        return false;
+    }
+
+    public ThreadContext getThreadContext() {
+        return threadContext;
+    }
+
+    public static boolean assertNotScheduleThread(String reason) {
+        assert Thread.currentThread().getName().contains("scheduler") == false : "Expected current thread ["
+            + Thread.currentThread()
+            + "] to not be the scheduler thread. Reason: ["
+            + reason
+            + "]";
+        return true;
+    }
+
+    public static boolean assertCurrentMethodIsNotCalledRecursively() {
+        final StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
+        assert stackTraceElements.length >= 3 : stackTraceElements.length;
+        assert stackTraceElements[0].getMethodName().equals("getStackTrace") : stackTraceElements[0];
+        assert stackTraceElements[1].getMethodName().equals("assertCurrentMethodIsNotCalledRecursively") : stackTraceElements[1];
+        final StackTraceElement testingMethod = stackTraceElements[2];
+        for (int i = 3; i < stackTraceElements.length; i++) {
+            assert stackTraceElements[i].getClassName().equals(testingMethod.getClassName()) == false
+                || stackTraceElements[i].getMethodName().equals(testingMethod.getMethodName()) == false : testingMethod.getClassName()
+                    + "#"
+                    + testingMethod.getMethodName()
+                    + " is called recursively";
+        }
+        return true;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java b/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java
new file mode 100644
index 0000000000000..5188abedd67ca
--- /dev/null
+++ b/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java
@@ -0,0 +1,51 @@
+/*
+* 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.
+*/
+
+package org.opensearch.threadpool;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.node.ProtobufReportingService;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Information about a threadpool
+*
+* @opensearch.internal
+*/
+public class ProtobufThreadPoolInfo implements ProtobufReportingService.ProtobufInfo, Iterable<ProtobufThreadPool.Info> {
+
+    private final List<ProtobufThreadPool.Info> infos;
+
+    public ProtobufThreadPoolInfo(List<ProtobufThreadPool.Info> infos) {
+        this.infos = Collections.unmodifiableList(infos);
+    }
+
+    public ProtobufThreadPoolInfo(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        this.infos = Collections.unmodifiableList(protobufStreamInput.readList(ProtobufThreadPool.Info::new, in));
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        protobufStreamOutput.writeCollection(infos, (o, v) -> v.writeTo(o), out);
+    }
+
+    @Override
+    public Iterator<ProtobufThreadPool.Info> iterator() {
+        return infos.iterator();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufNetworkMessage.java b/server/src/main/java/org/opensearch/transport/ProtobufNetworkMessage.java
new file mode 100644
index 0000000000000..89fa327ecc0dd
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufNetworkMessage.java
@@ -0,0 +1,62 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import org.opensearch.Version;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.util.concurrent.ThreadContext;
+
+/**
+ * Represents a transport message sent over the network. Subclasses implement serialization and
+* deserialization.
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufNetworkMessage {
+
+    protected final Version version;
+    protected final ProtobufWriteable threadContext;
+    protected final long requestId;
+    protected final byte status;
+
+    ProtobufNetworkMessage(ThreadContext threadContext, Version version, byte status, long requestId) {
+        this.threadContext = (ProtobufWriteable) threadContext.captureAsWriteable();
+        this.version = version;
+        this.requestId = requestId;
+        this.status = status;
+    }
+
+    public Version getVersion() {
+        return version;
+    }
+
+    public long getRequestId() {
+        return requestId;
+    }
+
+    boolean isCompress() {
+        return TransportStatus.isCompress(status);
+    }
+
+    boolean isResponse() {
+        return TransportStatus.isRequest(status) == false;
+    }
+
+    boolean isRequest() {
+        return TransportStatus.isRequest(status);
+    }
+
+    boolean isHandshake() {
+        return TransportStatus.isHandshake(status);
+    }
+
+    boolean isError() {
+        return TransportStatus.isError(status);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java b/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
new file mode 100644
index 0000000000000..0bfc14e93d7da
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
@@ -0,0 +1,191 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.Version;
+import org.opensearch.common.bytes.BytesArray;
+import org.opensearch.common.bytes.BytesReference;
+import org.opensearch.common.bytes.CompositeBytesReference;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.StreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.util.concurrent.ThreadContext;
+
+import java.io.IOException;
+import java.util.Set;
+
+/**
+ * Outbound data as a message
+*
+* @opensearch.internal
+*/
+abstract class ProtobufOutboundMessage extends ProtobufNetworkMessage {
+
+    private final ProtobufWriteable message;
+
+    ProtobufOutboundMessage(ThreadContext threadContext, Version version, byte status, long requestId, ProtobufWriteable message) {
+        super(threadContext, version, status, requestId);
+        this.message = message;
+    }
+
+    BytesReference serialize(CodedOutputStream bytesStream) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        protobufStreamOutput.setVersion(version);
+        // bytesStream.skip(TcpHeader.headerSize(version));
+
+        // The compressible bytes stream will not close the underlying bytes stream
+        BytesReference reference;
+        int variableHeaderLength = -1;
+        final long preHeaderPosition = bytesStream.position();
+        writeVariableHeader(bytesStream);
+        variableHeaderLength = Math.toIntExact(bytesStream.position() - preHeaderPosition);
+
+        try (CompressibleBytesOutputStream stream = new CompressibleBytesOutputStream(bytesStream, TransportStatus.isCompress(status))) {
+            stream.setVersion(version);
+            stream.setFeatures(bytesStream.getFeatures());
+
+            if (variableHeaderLength == -1) {
+                writeVariableHeader(stream);
+            }
+            reference = writeMessage(stream);
+        }
+
+        bytesStream.seek(0);
+        final int contentSize = reference.length() - TcpHeader.headerSize(version);
+        TcpHeader.writeHeader(bytesStream, requestId, status, version, contentSize, variableHeaderLength);
+        return reference;
+    }
+
+    protected void writeVariableHeader(CodedOutputStream stream) throws IOException {
+        threadContext.writeTo(stream);
+    }
+
+    protected BytesReference writeMessage(CompressibleBytesOutputStream stream) throws IOException {
+        final BytesReference zeroCopyBuffer;
+        if (message instanceof BytesTransportRequest) {
+            BytesTransportRequest bRequest = (BytesTransportRequest) message;
+            bRequest.writeThin(stream);
+            zeroCopyBuffer = bRequest.bytes;
+        } else if (message instanceof RemoteTransportException) {
+            stream.writeException((RemoteTransportException) message);
+            zeroCopyBuffer = BytesArray.EMPTY;
+        } else {
+            message.writeTo(stream);
+            zeroCopyBuffer = BytesArray.EMPTY;
+        }
+        // we have to call materializeBytes() here before accessing the bytes. A CompressibleBytesOutputStream
+        // might be implementing compression. And materializeBytes() ensures that some marker bytes (EOS marker)
+        // are written. Otherwise we barf on the decompressing end when we read past EOF on purpose in the
+        // #validateRequest method. this might be a problem in deflate after all but it's important to write
+        // the marker bytes.
+        final BytesReference message = stream.materializeBytes();
+        if (zeroCopyBuffer.length() == 0) {
+            return message;
+        } else {
+            return CompositeBytesReference.of(message, zeroCopyBuffer);
+        }
+    }
+
+    /**
+     * Internal outbound message request
+    *
+    * @opensearch.internal
+    */
+    static class Request extends ProtobufOutboundMessage {
+
+        private final String[] features;
+        private final String action;
+
+        Request(
+            ThreadContext threadContext,
+            String[] features,
+            ProtobufWriteable message,
+            Version version,
+            String action,
+            long requestId,
+            boolean isHandshake,
+            boolean compress
+        ) {
+            super(threadContext, version, setStatus(compress, isHandshake, message), requestId, message);
+            this.features = features;
+            this.action = action;
+        }
+
+        @Override
+        protected void writeVariableHeader(StreamOutput stream) throws IOException {
+            super.writeVariableHeader(stream);
+            stream.writeStringArray(features);
+            stream.writeString(action);
+        }
+
+        private static byte setStatus(boolean compress, boolean isHandshake, ProtobufWriteable message) {
+            byte status = 0;
+            status = TransportStatus.setRequest(status);
+            if (compress && ProtobufOutboundMessage.canCompress(message)) {
+                status = TransportStatus.setCompress(status);
+            }
+            if (isHandshake) {
+                status = TransportStatus.setHandshake(status);
+            }
+
+            return status;
+        }
+    }
+
+    /**
+     * Internal message response
+    *
+    * @opensearch.internal
+    */
+    static class Response extends ProtobufOutboundMessage {
+
+        private final Set<String> features;
+
+        Response(
+            ThreadContext threadContext,
+            Set<String> features,
+            ProtobufWriteable message,
+            Version version,
+            long requestId,
+            boolean isHandshake,
+            boolean compress
+        ) {
+            super(threadContext, version, setStatus(compress, isHandshake, message), requestId, message);
+            this.features = features;
+        }
+
+        @Override
+        protected void writeVariableHeader(StreamOutput stream) throws IOException {
+            super.writeVariableHeader(stream);
+            stream.setFeatures(features);
+        }
+
+        private static byte setStatus(boolean compress, boolean isHandshake, ProtobufWriteable message) {
+            byte status = 0;
+            status = TransportStatus.setResponse(status);
+            if (message instanceof RemoteTransportException) {
+                status = TransportStatus.setError(status);
+            }
+            if (compress) {
+                status = TransportStatus.setCompress(status);
+            }
+            if (isHandshake) {
+                status = TransportStatus.setHandshake(status);
+            }
+
+            return status;
+        }
+    }
+
+    private static boolean canCompress(ProtobufWriteable message) {
+        return message instanceof BytesTransportRequest == false;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
new file mode 100644
index 0000000000000..1ddeb04f106a8
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
@@ -0,0 +1,125 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.lease.Releasables;
+import org.opensearch.search.internal.ShardSearchRequest;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.tasks.ProtobufCancellableTask;
+import org.opensearch.tasks.ProtobufTask;
+import org.opensearch.tasks.ProtobufTaskManager;
+
+import java.io.IOException;
+
+/**
+ * Registry for OpenSearch RequestHandlers
+*
+* @opensearch.internal
+*/
+public final class ProtobufRequestHandlerRegistry<Request extends ProtobufTransportRequest> {
+
+    private final String action;
+    private final ProtobufTransportRequestHandler<Request> handler;
+    private final boolean forceExecution;
+    private final boolean canTripCircuitBreaker;
+    private final String executor;
+    private final ProtobufTaskManager taskManager;
+    private final ProtobufWriteable.Reader<Request> requestReader;
+
+    public ProtobufRequestHandlerRegistry(
+        String action,
+        ProtobufWriteable.Reader<Request> requestReader,
+        ProtobufTaskManager taskManager,
+        ProtobufTransportRequestHandler<Request> handler,
+        String executor,
+        boolean forceExecution,
+        boolean canTripCircuitBreaker
+    ) {
+        this.action = action;
+        this.requestReader = requestReader;
+        this.handler = handler;
+        this.forceExecution = forceExecution;
+        this.canTripCircuitBreaker = canTripCircuitBreaker;
+        this.executor = executor;
+        this.taskManager = taskManager;
+    }
+
+    public String getAction() {
+        return action;
+    }
+
+    public Request newRequest(StreamInput in) throws IOException {
+        return requestReader.read(in);
+    }
+
+    public void processMessageReceived(Request request, TransportChannel channel) throws Exception {
+        final ProtobufTask task = taskManager.register(channel.getChannelType(), action, request);
+        ThreadContext.StoredContext contextToRestore = taskManager.taskExecutionStarted(task);
+
+        Releasable unregisterTask = () -> taskManager.unregister(task);
+        try {
+            if (channel instanceof TcpTransportChannel && task instanceof ProtobufCancellableTask) {
+                // if (request instanceof ShardSearchRequest) {
+                //     // on receiving request, update the inbound network time to reflect time spent in transit over the network
+                //     ((ShardSearchRequest) request).setInboundNetworkTime(
+                //         Math.max(0, System.currentTimeMillis() - ((ShardSearchRequest) request).getInboundNetworkTime())
+                //     );
+                // }
+                final TcpChannel tcpChannel = ((TcpTransportChannel) channel).getChannel();
+                final Releasable stopTracking = taskManager.startTrackingCancellableChannelTask(tcpChannel, (ProtobufCancellableTask) task);
+                unregisterTask = Releasables.wrap(unregisterTask, stopTracking);
+            }
+            final ProtobufTaskTransportChannel taskTransportChannel = new ProtobufTaskTransportChannel(channel, unregisterTask);
+            handler.messageReceived(request, taskTransportChannel, task);
+            unregisterTask = null;
+        } finally {
+            Releasables.close(unregisterTask);
+            contextToRestore.restore();
+        }
+    }
+
+    public boolean isForceExecution() {
+        return forceExecution;
+    }
+
+    public boolean canTripCircuitBreaker() {
+        return canTripCircuitBreaker;
+    }
+
+    public String getExecutor() {
+        return executor;
+    }
+
+    public ProtobufTransportRequestHandler<Request> getHandler() {
+        return handler;
+    }
+
+    @Override
+    public String toString() {
+        return handler.toString();
+    }
+
+    public static <R extends ProtobufTransportRequest> RequestHandlerRegistry<R> replaceHandler(
+        RequestHandlerRegistry<R> registry,
+        ProtobufTransportRequestHandler<R> handler
+    ) {
+        return new RequestHandlerRegistry<>(
+            registry.action,
+            registry.requestReader,
+            registry.taskManager,
+            handler,
+            registry.executor,
+            registry.forceExecution,
+            registry.canTripCircuitBreaker
+        );
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTaskTransportChannel.java b/server/src/main/java/org/opensearch/transport/ProtobufTaskTransportChannel.java
new file mode 100644
index 0000000000000..4e4851331de12
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTaskTransportChannel.java
@@ -0,0 +1,67 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import org.opensearch.Version;
+import org.opensearch.common.lease.Releasable;
+
+import java.io.IOException;
+
+/**
+ * Transport channel for tasks
+*
+* @opensearch.internal
+*/
+public class ProtobufTaskTransportChannel implements ProtobufTransportChannel {
+
+    private final ProtobufTransportChannel channel;
+    private final Releasable onTaskFinished;
+
+    ProtobufTaskTransportChannel(ProtobufTransportChannel channel, Releasable onTaskFinished) {
+        this.channel = channel;
+        this.onTaskFinished = onTaskFinished;
+    }
+
+    @Override
+    public String getProfileName() {
+        return channel.getProfileName();
+    }
+
+    @Override
+    public String getChannelType() {
+        return channel.getChannelType();
+    }
+
+    @Override
+    public void sendResponse(ProtobufTransportResponse response) throws IOException {
+        try {
+            onTaskFinished.close();
+        } finally {
+            channel.sendResponse(response);
+        }
+    }
+
+    @Override
+    public void sendResponse(Exception exception) throws IOException {
+        try {
+            onTaskFinished.close();
+        } finally {
+            channel.sendResponse(exception);
+        }
+    }
+
+    @Override
+    public Version getVersion() {
+        return channel.getVersion();
+    }
+
+    public ProtobufTransportChannel getChannel() {
+        return channel;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTcpTransportChannel.java b/server/src/main/java/org/opensearch/transport/ProtobufTcpTransportChannel.java
new file mode 100644
index 0000000000000..81aa03275d263
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTcpTransportChannel.java
@@ -0,0 +1,112 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import org.opensearch.Version;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.search.query.QuerySearchResult;
+
+import java.io.IOException;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Channel for a TCP connection
+*
+* @opensearch.internal
+*/
+public final class ProtobufTcpTransportChannel implements ProtobufTransportChannel {
+
+    private final AtomicBoolean released = new AtomicBoolean();
+    private final OutboundHandler outboundHandler;
+    private final TcpChannel channel;
+    private final String action;
+    private final long requestId;
+    private final Version version;
+    private final Set<String> features;
+    private final boolean compressResponse;
+    private final boolean isHandshake;
+    private final Releasable breakerRelease;
+
+    ProtobufTcpTransportChannel(
+        OutboundHandler outboundHandler,
+        TcpChannel channel,
+        String action,
+        long requestId,
+        Version version,
+        Set<String> features,
+        boolean compressResponse,
+        boolean isHandshake,
+        Releasable breakerRelease
+    ) {
+        this.version = version;
+        this.features = features;
+        this.channel = channel;
+        this.outboundHandler = outboundHandler;
+        this.action = action;
+        this.requestId = requestId;
+        this.compressResponse = compressResponse;
+        this.isHandshake = isHandshake;
+        this.breakerRelease = breakerRelease;
+    }
+
+    @Override
+    public String getProfileName() {
+        return channel.getProfile();
+    }
+
+    @Override
+    public void sendResponse(ProtobufTransportResponse response) throws IOException {
+        try {
+            // if (response instanceof QuerySearchResult && ((QuerySearchResult) response).getShardSearchRequest() != null) {
+            //     // update outbound network time with current time before sending response over network
+            //     ((QuerySearchResult) response).getShardSearchRequest().setOutboundNetworkTime(System.currentTimeMillis());
+            // }
+            outboundHandler.sendResponse(version, features, channel, requestId, action, response, compressResponse, isHandshake);
+        } finally {
+            release(false);
+        }
+    }
+
+    @Override
+    public void sendResponse(Exception exception) throws IOException {
+        try {
+            outboundHandler.sendErrorResponse(version, features, channel, requestId, action, exception);
+        } finally {
+            release(true);
+        }
+    }
+
+    private Exception releaseBy;
+
+    private void release(boolean isExceptionResponse) {
+        if (released.compareAndSet(false, true)) {
+            assert (releaseBy = new Exception()) != null; // easier to debug if it's already closed
+            breakerRelease.close();
+        } else if (isExceptionResponse == false) {
+            // only fail if we are not sending an error - we might send the error triggered by the previous
+            // sendResponse call
+            throw new IllegalStateException("reserved bytes are already released", releaseBy);
+        }
+    }
+
+    @Override
+    public String getChannelType() {
+        return "transport";
+    }
+
+    @Override
+    public Version getVersion() {
+        return version;
+    }
+
+    public TcpChannel getChannel() {
+        return channel;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransport.java b/server/src/main/java/org/opensearch/transport/ProtobufTransport.java
new file mode 100644
index 0000000000000..08d0ad17de49c
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransport.java
@@ -0,0 +1,274 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import org.opensearch.Version;
+import org.opensearch.action.ActionListener;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.common.collect.MapBuilder;
+import org.opensearch.common.component.LifecycleComponent;
+import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.concurrent.ConcurrentCollections;
+import org.opensearch.common.util.concurrent.ConcurrentMapLong;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Predicate;
+
+/**
+ * OpenSearch ProtobufTransport Interface
+*
+* @opensearch.internal
+*/
+public interface ProtobufTransport extends LifecycleComponent {
+
+    /**
+     * Registers a new request handler
+    */
+    default <Request extends ProtobufTransportRequest> void registerRequestHandler(RequestHandlerRegistry<Request> reg) {
+        getRequestHandlers().registerHandler(reg);
+    }
+
+    void setMessageListener(ProtobufTransportMessageListener listener);
+
+    default void setSlowLogThreshold(TimeValue slowLogThreshold) {}
+
+    default boolean isSecure() {
+        return false;
+    }
+
+    /**
+     * The address the transport is bound on.
+    */
+    ProtobufBoundTransportAddress boundAddress();
+
+    /**
+     * Further profile bound addresses
+    * @return <code>null</code> iff profiles are unsupported, otherwise a map with name of profile and its bound transport address
+    */
+    Map<String, ProtobufBoundTransportAddress> profileBoundAddresses();
+
+    /**
+     * Returns an address from its string representation.
+    */
+    TransportAddress[] addressesFromString(String address) throws UnknownHostException;
+
+    /**
+     * Returns a list of all local addresses for this transport
+    */
+    List<String> getDefaultSeedAddresses();
+
+    /**
+     * Opens a new connection to the given node. When the connection is fully connected, the listener is called.
+    * The ActionListener will be called on the calling thread or the generic thread pool.
+    */
+    void openConnection(DiscoveryNode node, ConnectionProfile profile, ActionListener<ProtobufTransport.Connection> listener);
+
+    TransportStats getStats();
+
+    ResponseHandlers getResponseHandlers();
+
+    RequestHandlers getRequestHandlers();
+
+    /**
+     * A unidirectional connection to a {@link DiscoveryNode}
+    */
+    interface Connection extends Closeable {
+        /**
+         * The node this connection is associated with
+        */
+        DiscoveryNode getNode();
+
+        /**
+         * Sends the request to the node this connection is associated with
+        * @param requestId see {@link ResponseHandlers#add(ResponseContext)} for details
+        * @param action the action to execute
+        * @param request the request to send
+        * @param options request options to apply
+        * @throws NodeNotConnectedException if the given node is not connected
+        */
+        void sendRequest(long requestId, String action, ProtobufTransportRequest request, TransportRequestOptions options) throws IOException,
+            TransportException;
+
+        /**
+         * The listener's {@link ActionListener#onResponse(Object)} method will be called when this
+        * connection is closed. No implementations currently throw an exception during close, so
+        * {@link ActionListener#onFailure(Exception)} will not be called.
+        *
+        * @param listener to be called
+        */
+        void addCloseListener(ActionListener<Void> listener);
+
+        boolean isClosed();
+
+        /**
+         * Returns the version of the node this connection was established with.
+        */
+        default Version getVersion() {
+            return getNode().getVersion();
+        }
+
+        /**
+         * Returns a key that this connection can be cached on. Delegating subclasses must delegate method call to
+        * the original connection.
+        */
+        default Object getCacheKey() {
+            return this;
+        }
+
+        @Override
+        void close();
+    }
+
+    /**
+     * This class represents a response context that encapsulates the actual response handler, the action and the connection it was
+    * executed on.
+    */
+    final class ResponseContext<T extends TransportResponse> {
+
+        private final TransportResponseHandler<T> handler;
+
+        private final Connection connection;
+
+        private final String action;
+
+        ResponseContext(TransportResponseHandler<T> handler, Connection connection, String action) {
+            this.handler = handler;
+            this.connection = connection;
+            this.action = action;
+        }
+
+        public TransportResponseHandler<T> handler() {
+            return handler;
+        }
+
+        public Connection connection() {
+            return this.connection;
+        }
+
+        public String action() {
+            return this.action;
+        }
+    }
+
+    /**
+     * This class is a registry that allows
+    */
+    final class ResponseHandlers {
+        private final ConcurrentMapLong<ResponseContext<? extends TransportResponse>> handlers = ConcurrentCollections
+            .newConcurrentMapLongWithAggressiveConcurrency();
+        private final AtomicLong requestIdGenerator = new AtomicLong();
+
+        /**
+         * Returns <code>true</code> if the give request ID has a context associated with it.
+        */
+        public boolean contains(long requestId) {
+            return handlers.containsKey(requestId);
+        }
+
+        /**
+         * Removes and return the {@link ResponseContext} for the given request ID or returns
+        * <code>null</code> if no context is associated with this request ID.
+        */
+        public ResponseContext<? extends TransportResponse> remove(long requestId) {
+            return handlers.remove(requestId);
+        }
+
+        /**
+         * Adds a new response context and associates it with a new request ID.
+        * @return the new request ID
+        * @see Connection#sendRequest(long, String, ProtobufTransportRequest, TransportRequestOptions)
+        */
+        public long add(ResponseContext<? extends TransportResponse> holder) {
+            long requestId = newRequestId();
+            ResponseContext<? extends TransportResponse> existing = handlers.put(requestId, holder);
+            assert existing == null : "request ID already in use: " + requestId;
+            return requestId;
+        }
+
+        /**
+         * Returns a new request ID to use when sending a message via {@link Connection#sendRequest(long, String,
+        * ProtobufTransportRequest, TransportRequestOptions)}
+        */
+        long newRequestId() {
+            return requestIdGenerator.incrementAndGet();
+        }
+
+        /**
+         * Removes and returns all {@link ResponseContext} instances that match the predicate
+        */
+        public List<ResponseContext<? extends TransportResponse>> prune(Predicate<ResponseContext<? extends TransportResponse>> predicate) {
+            final List<ResponseContext<? extends TransportResponse>> holders = new ArrayList<>();
+            for (Map.Entry<Long, ResponseContext<? extends TransportResponse>> entry : handlers.entrySet()) {
+                ResponseContext<? extends TransportResponse> holder = entry.getValue();
+                if (predicate.test(holder)) {
+                    ResponseContext<? extends TransportResponse> remove = handlers.remove(entry.getKey());
+                    if (remove != null) {
+                        holders.add(holder);
+                    }
+                }
+            }
+            return holders;
+        }
+
+        /**
+         * called by the {@link ProtobufTransport} implementation when a response or an exception has been received for a previously
+        * sent request (before any processing or deserialization was done). Returns the appropriate response handler or null if not
+        * found.
+        */
+        public TransportResponseHandler<? extends TransportResponse> onResponseReceived(
+            final long requestId,
+            final ProtobufTransportMessageListener listener
+        ) {
+            ResponseContext<? extends TransportResponse> context = handlers.remove(requestId);
+            listener.onResponseReceived(requestId, context);
+            if (context == null) {
+                return null;
+            } else {
+                return context.handler();
+            }
+        }
+    }
+
+    /**
+     * Request handler implementations
+    *
+    * @opensearch.internal
+    */
+    final class RequestHandlers {
+
+        private volatile Map<String, RequestHandlerRegistry<? extends ProtobufTransportRequest>> requestHandlers = Collections.emptyMap();
+
+        synchronized <Request extends ProtobufTransportRequest> void registerHandler(RequestHandlerRegistry<Request> reg) {
+            if (requestHandlers.containsKey(reg.getAction())) {
+                throw new IllegalArgumentException("transport handlers for action " + reg.getAction() + " is already registered");
+            }
+            requestHandlers = MapBuilder.newMapBuilder(requestHandlers).put(reg.getAction(), reg).immutableMap();
+        }
+
+        // TODO: Only visible for testing. Perhaps move StubbableTransport from
+        // org.opensearch.test.transport to org.opensearch.transport
+        public synchronized <Request extends ProtobufTransportRequest> void forceRegister(RequestHandlerRegistry<Request> reg) {
+            requestHandlers = MapBuilder.newMapBuilder(requestHandlers).put(reg.getAction(), reg).immutableMap();
+        }
+
+        @SuppressWarnings("unchecked")
+        public <T extends ProtobufTransportRequest> RequestHandlerRegistry<T> getHandler(String action) {
+            return (RequestHandlerRegistry<T>) requestHandlers.get(action);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportChannel.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportChannel.java
new file mode 100644
index 0000000000000..f9eac58f4e246
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportChannel.java
@@ -0,0 +1,56 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.Version;
+
+import java.io.IOException;
+
+/**
+ * A transport channel allows to send a response to a request on the channel.
+*
+* @opensearch.internal
+*/
+public interface ProtobufTransportChannel {
+
+    Logger logger = LogManager.getLogger(ProtobufTransportChannel.class);
+
+    String getProfileName();
+
+    String getChannelType();
+
+    void sendResponse(ProtobufTransportResponse response) throws IOException;
+
+    void sendResponse(Exception exception) throws IOException;
+
+    /**
+     * Returns the version of the other party that this channel will send a response to.
+    */
+    default Version getVersion() {
+        return Version.CURRENT;
+    }
+
+    /**
+     * A helper method to send an exception and handle and log a subsequent exception
+    */
+    static void sendErrorResponse(ProtobufTransportChannel channel, String actionName, ProtobufTransportRequest request, Exception e) {
+        try {
+            channel.sendResponse(e);
+        } catch (Exception sendException) {
+            sendException.addSuppressed(e);
+            logger.warn(
+                () -> new ParameterizedMessage("Failed to send error response for action [{}] and request [{}]", actionName, request),
+                sendException
+            );
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportInfo.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportInfo.java
new file mode 100644
index 0000000000000..633955d561fad
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportInfo.java
@@ -0,0 +1,138 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.logging.DeprecationLogger;
+import org.opensearch.common.network.InetAddresses;
+import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.node.ProtobufReportingService;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.opensearch.common.Booleans.parseBoolean;
+
+/**
+ * Transport information
+*
+* @opensearch.internal
+*/
+public class ProtobufTransportInfo implements ProtobufReportingService.ProtobufInfo {
+
+    private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(TransportInfo.class);
+
+    /** Whether to add hostname to publish host field when serializing. */
+    private static final boolean CNAME_IN_PUBLISH_ADDRESS = parseBoolean(
+        System.getProperty("opensearch.transport.cname_in_publish_address"),
+        false
+    );
+
+    private final ProtobufBoundTransportAddress address;
+    private Map<String, ProtobufBoundTransportAddress> profileAddresses;
+    private final boolean cnameInPublishAddress;
+
+    public ProtobufTransportInfo(
+        ProtobufBoundTransportAddress address,
+        @Nullable Map<String, ProtobufBoundTransportAddress> profileAddresses
+    ) {
+        this(address, profileAddresses, CNAME_IN_PUBLISH_ADDRESS);
+    }
+
+    public ProtobufTransportInfo(
+        ProtobufBoundTransportAddress address,
+        @Nullable Map<String, ProtobufBoundTransportAddress> profileAddresses,
+        boolean cnameInPublishAddress
+    ) {
+        this.address = address;
+        this.profileAddresses = profileAddresses;
+        this.cnameInPublishAddress = cnameInPublishAddress;
+    }
+
+    public ProtobufTransportInfo(CodedInputStream in) throws IOException {
+        address = new ProtobufBoundTransportAddress(in);
+        int size = in.readInt32();
+        if (size > 0) {
+            profileAddresses = new HashMap<>(size);
+            for (int i = 0; i < size; i++) {
+                String key = in.readString();
+                ProtobufBoundTransportAddress value = new ProtobufBoundTransportAddress(in);
+                profileAddresses.put(key, value);
+            }
+        }
+        this.cnameInPublishAddress = CNAME_IN_PUBLISH_ADDRESS;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        address.writeTo(out);
+        if (profileAddresses != null) {
+            out.writeInt32NoTag(profileAddresses.size());
+        } else {
+            out.writeInt32NoTag(0);
+        }
+        if (profileAddresses != null && profileAddresses.size() > 0) {
+            for (Map.Entry<String, ProtobufBoundTransportAddress> entry : profileAddresses.entrySet()) {
+                out.writeStringNoTag(entry.getKey());
+                entry.getValue().writeTo(out);
+            }
+        }
+    }
+
+    static final class Fields {
+        static final String TRANSPORT = "transport";
+        static final String BOUND_ADDRESS = "bound_address";
+        static final String PUBLISH_ADDRESS = "publish_address";
+        static final String PROFILES = "profiles";
+    }
+
+    private String formatPublishAddressString(String propertyName, ProtobufTransportAddress publishAddress) {
+        String publishAddressString = publishAddress.toString();
+        String hostString = publishAddress.address().getHostString();
+        if (InetAddresses.isInetAddress(hostString) == false) {
+            if (cnameInPublishAddress) {
+                publishAddressString = hostString + '/' + publishAddress.toString();
+            } else {
+                deprecationLogger.deprecate(
+                    "cname_in_publish_address_" + propertyName,
+                    propertyName
+                        + " was printed as [ip:port] instead of [hostname/ip:port]. "
+                        + "This format is deprecated and will change to [hostname/ip:port] in a future version. "
+                        + "Use -Dopensearch.transport.cname_in_publish_address=true to enforce non-deprecated formatting."
+                );
+            }
+        }
+        return publishAddressString;
+    }
+
+    public ProtobufBoundTransportAddress address() {
+        return address;
+    }
+
+    public ProtobufBoundTransportAddress getAddress() {
+        return address();
+    }
+
+    public Map<String, ProtobufBoundTransportAddress> getProfileAddresses() {
+        return profileAddresses();
+    }
+
+    public Map<String, ProtobufBoundTransportAddress> profileAddresses() {
+        return profileAddresses;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java
new file mode 100644
index 0000000000000..0d54c80512c03
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java
@@ -0,0 +1,69 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+
+/**
+ * Listens for transport messages
+*
+* @opensearch.internal
+*/
+public interface ProtobufTransportMessageListener {
+
+    ProtobufTransportMessageListener NOOP_LISTENER = new ProtobufTransportMessageListener() {
+    };
+
+    /**
+     * Called once a request is received
+    * @param requestId the internal request ID
+    * @param action the request action
+    *
+    */
+    default void onRequestReceived(long requestId, String action) {}
+
+    /**
+     * Called for every action response sent after the response has been passed to the underlying network implementation.
+    * @param requestId the request ID (unique per client)
+    * @param action the request action
+    * @param response the response send
+    */
+    default void onResponseSent(long requestId, String action, ProtobufTransportResponse response) {}
+
+    /***
+     * Called for every failed action response after the response has been passed to the underlying network implementation.
+    * @param requestId the request ID (unique per client)
+    * @param action the request action
+    * @param error the error sent back to the caller
+    */
+    default void onResponseSent(long requestId, String action, Exception error) {}
+
+    /**
+     * Called for every request sent to a server after the request has been passed to the underlying network implementation
+    * @param node the node the request was sent to
+    * @param requestId the internal request id
+    * @param action the action name
+    * @param request the actual request
+    * @param finalOptions the request options
+    */
+    default void onRequestSent(
+        ProtobufDiscoveryNode node,
+        long requestId,
+        String action,
+        ProtobufTransportRequest request,
+        TransportRequestOptions finalOptions
+    ) {}
+
+    /**
+     * Called for every response received
+    * @param requestId the request id for this reponse
+    * @param context the response context or null if the context was already processed ie. due to a timeout.
+    */
+    default void onResponseReceived(long requestId, ProtobufTransport.ResponseContext context) {}
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportRequestHandler.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportRequestHandler.java
new file mode 100644
index 0000000000000..6eb9b7fd72f4e
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportRequestHandler.java
@@ -0,0 +1,22 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import org.opensearch.tasks.ProtobufTask;
+import org.opensearch.tasks.Task;
+
+/**
+ * Handles transport requests
+*
+* @opensearch.internal
+*/
+public interface ProtobufTransportRequestHandler<T extends ProtobufTransportRequest> {
+
+    void messageReceived(T request, TransportChannel channel, ProtobufTask task) throws Exception;
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportResponse.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportResponse.java
new file mode 100644
index 0000000000000..9a5a0d90328b3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportResponse.java
@@ -0,0 +1,59 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.StreamInput;
+
+import java.io.IOException;
+
+/**
+ * Response over the transport interface
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufTransportResponse extends ProtobufTransportMessage {
+
+    /**
+     * Constructs a new empty transport response
+    */
+    public ProtobufTransportResponse() {}
+
+    /**
+     * Constructs a new transport response with the data from the {@link StreamInput}. This is
+    * currently a no-op. However, this exists to allow extenders to call <code>super(in)</code>
+    * so that reading can mirror writing where we often call <code>super.writeTo(out)</code>.
+    */
+    public ProtobufTransportResponse(CodedInputStream in) throws IOException {
+        super(in);
+    }
+
+    /**
+     * Empty transport response
+    *
+    * @opensearch.internal
+    */
+    public static class Empty extends ProtobufTransportResponse {
+        public static final Empty INSTANCE = new Empty();
+
+        @Override
+        public String toString() {
+            return "Empty{}";
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {}
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java
new file mode 100644
index 0000000000000..369419be1c8f6
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java
@@ -0,0 +1,1557 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.Version;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.ActionListenerResponseHandler;
+import org.opensearch.action.support.PlainActionFuture;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.Strings;
+import org.opensearch.common.component.AbstractLifecycleComponent;
+import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.StreamOutput;
+import org.opensearch.common.io.stream.Writeable;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.logging.Loggers;
+import org.opensearch.common.regex.Regex;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.concurrent.AbstractRunnable;
+import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.node.NodeClosedException;
+import org.opensearch.node.ProtobufReportingService;
+import org.opensearch.tasks.Task;
+import org.opensearch.tasks.TaskManager;
+import org.opensearch.threadpool.Scheduler;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.net.UnknownHostException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+/**
+ * The main OpenSearch transport service
+*
+* @opensearch.internal
+*/
+public class ProtobufTransportService extends AbstractLifecycleComponent
+    implements
+        ProtobufReportingService<ProtobufTransportInfo>,
+        TransportMessageListener,
+        TransportConnectionListener {
+    private static final Logger logger = LogManager.getLogger(ProtobufTransportService.class);
+
+    public static final String DIRECT_RESPONSE_PROFILE = ".direct";
+    public static final String HANDSHAKE_ACTION_NAME = "internal:transport/handshake";
+
+    private final AtomicBoolean handleIncomingRequests = new AtomicBoolean();
+    private final DelegatingTransportMessageListener messageListener = new DelegatingTransportMessageListener();
+    protected final Transport transport;
+    protected final ConnectionManager connectionManager;
+    protected final ThreadPool threadPool;
+    protected final ClusterName clusterName;
+    protected final TaskManager taskManager;
+    private final TransportInterceptor.AsyncSender asyncSender;
+    private final Function<ProtobufBoundTransportAddress, DiscoveryNode> localNodeFactory;
+    private final boolean remoteClusterClient;
+    private final Transport.ResponseHandlers responseHandlers;
+    private final TransportInterceptor interceptor;
+
+    // An LRU (don't really care about concurrency here) that holds the latest timed out requests so if they
+    // do show up, we can print more descriptive information about them
+    final Map<Long, TimeoutInfoHolder> timeoutInfoHandlers = Collections.synchronizedMap(
+        new LinkedHashMap<Long, TimeoutInfoHolder>(100, .75F, true) {
+            @Override
+            protected boolean removeEldestEntry(Map.Entry eldest) {
+                return size() > 100;
+            }
+        }
+    );
+
+    public static final TransportInterceptor NOOP_TRANSPORT_INTERCEPTOR = new TransportInterceptor() {
+    };
+
+    // tracer log
+
+    private final Logger tracerLog;
+
+    volatile String[] tracerLogInclude;
+    volatile String[] tracerLogExclude;
+
+    private final RemoteClusterService remoteClusterService;
+
+    /** if set will call requests sent to this id to shortcut and executed locally */
+    volatile DiscoveryNode localNode = null;
+    private final Transport.Connection localNodeConnection = new Transport.Connection() {
+        @Override
+        public DiscoveryNode getNode() {
+            return localNode;
+        }
+
+        @Override
+        public void sendRequest(long requestId, String action, TransportRequest request, TransportRequestOptions options)
+            throws TransportException {
+            sendLocalRequest(requestId, action, request, options);
+        }
+
+        @Override
+        public void addCloseListener(ActionListener<Void> listener) {}
+
+        @Override
+        public boolean isClosed() {
+            return false;
+        }
+
+        @Override
+        public void close() {}
+    };
+
+    /**
+     * Build the service.
+    *
+    * @param clusterSettings if non null, the {@linkplain ProtobufTransportService} will register with the {@link ClusterSettings} for settings
+    *   *    updates for {@link TransportSettings#TRACE_LOG_EXCLUDE_SETTING} and {@link TransportSettings#TRACE_LOG_INCLUDE_SETTING}.
+    */
+    public ProtobufTransportService(
+        Settings settings,
+        Transport transport,
+        ThreadPool threadPool,
+        TransportInterceptor transportInterceptor,
+        Function<ProtobufBoundTransportAddress, DiscoveryNode> localNodeFactory,
+        @Nullable ClusterSettings clusterSettings,
+        Set<String> taskHeaders
+    ) {
+        this(
+            settings,
+            transport,
+            threadPool,
+            transportInterceptor,
+            localNodeFactory,
+            clusterSettings,
+            taskHeaders,
+            new ClusterConnectionManager(settings, transport)
+        );
+    }
+
+    public ProtobufTransportService(
+        Settings settings,
+        Transport transport,
+        ThreadPool threadPool,
+        TransportInterceptor transportInterceptor,
+        Function<ProtobufBoundTransportAddress, DiscoveryNode> localNodeFactory,
+        @Nullable ClusterSettings clusterSettings,
+        Set<String> taskHeaders,
+        ConnectionManager connectionManager
+    ) {
+        this.transport = transport;
+        transport.setSlowLogThreshold(TransportSettings.SLOW_OPERATION_THRESHOLD_SETTING.get(settings));
+        this.threadPool = threadPool;
+        this.localNodeFactory = localNodeFactory;
+        this.connectionManager = connectionManager;
+        this.clusterName = ClusterName.CLUSTER_NAME_SETTING.get(settings);
+        setTracerLogInclude(TransportSettings.TRACE_LOG_INCLUDE_SETTING.get(settings));
+        setTracerLogExclude(TransportSettings.TRACE_LOG_EXCLUDE_SETTING.get(settings));
+        tracerLog = Loggers.getLogger(logger, ".tracer");
+        taskManager = createTaskManager(settings, clusterSettings, threadPool, taskHeaders);
+        this.interceptor = transportInterceptor;
+        this.asyncSender = interceptor.interceptSender(this::sendRequestInternal);
+        this.remoteClusterClient = DiscoveryNode.isRemoteClusterClient(settings);
+        remoteClusterService = new RemoteClusterService(settings, this);
+        responseHandlers = transport.getResponseHandlers();
+        if (clusterSettings != null) {
+            clusterSettings.addSettingsUpdateConsumer(TransportSettings.TRACE_LOG_INCLUDE_SETTING, this::setTracerLogInclude);
+            clusterSettings.addSettingsUpdateConsumer(TransportSettings.TRACE_LOG_EXCLUDE_SETTING, this::setTracerLogExclude);
+            if (remoteClusterClient) {
+                remoteClusterService.listenForUpdates(clusterSettings);
+            }
+            clusterSettings.addSettingsUpdateConsumer(TransportSettings.SLOW_OPERATION_THRESHOLD_SETTING, transport::setSlowLogThreshold);
+        }
+        registerRequestHandler(
+            HANDSHAKE_ACTION_NAME,
+            ThreadPool.Names.SAME,
+            false,
+            false,
+            HandshakeRequest::new,
+            (request, channel, task) -> channel.sendResponse(new HandshakeResponse(localNode, clusterName, localNode.getVersion()))
+        );
+    }
+
+    public RemoteClusterService getRemoteClusterService() {
+        return remoteClusterService;
+    }
+
+    public DiscoveryNode getLocalNode() {
+        return localNode;
+    }
+
+    public TaskManager getTaskManager() {
+        return taskManager;
+    }
+
+    protected TaskManager createTaskManager(
+        Settings settings,
+        ClusterSettings clusterSettings,
+        ThreadPool threadPool,
+        Set<String> taskHeaders
+    ) {
+        if (clusterSettings != null) {
+            return TaskManager.createTaskManagerWithClusterSettings(settings, clusterSettings, threadPool, taskHeaders);
+        } else {
+            return new TaskManager(settings, threadPool, taskHeaders);
+        }
+    }
+
+    /**
+     * The executor service for this transport service.
+    *
+    * @return the executor service
+    */
+    private ExecutorService getExecutorService() {
+        return threadPool.generic();
+    }
+
+    void setTracerLogInclude(List<String> tracerLogInclude) {
+        this.tracerLogInclude = tracerLogInclude.toArray(Strings.EMPTY_ARRAY);
+    }
+
+    void setTracerLogExclude(List<String> tracerLogExclude) {
+        this.tracerLogExclude = tracerLogExclude.toArray(Strings.EMPTY_ARRAY);
+    }
+
+    @Override
+    protected void doStart() {
+        transport.setMessageListener(this);
+        connectionManager.addListener(this);
+        transport.start();
+        if (transport.boundAddress() != null && logger.isInfoEnabled()) {
+            logger.info("{}", transport.boundAddress());
+            for (Map.Entry<String, ProtobufBoundTransportAddress> entry : transport.profileBoundAddresses().entrySet()) {
+                logger.info("profile [{}]: {}", entry.getKey(), entry.getValue());
+            }
+        }
+        localNode = localNodeFactory.apply(transport.boundAddress());
+
+        if (remoteClusterClient) {
+            // here we start to connect to the remote clusters
+            remoteClusterService.initializeRemoteClusters();
+        }
+    }
+
+    @Override
+    protected void doStop() {
+        try {
+            IOUtils.close(connectionManager, remoteClusterService, transport::stop);
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        } finally {
+            // in case the transport is not connected to our local node (thus cleaned on node disconnect)
+            // make sure to clean any leftover on going handles
+            for (final Transport.ResponseContext holderToNotify : responseHandlers.prune(h -> true)) {
+                // callback that an exception happened, but on a different thread since we don't
+                // want handlers to worry about stack overflows
+                getExecutorService().execute(new AbstractRunnable() {
+                    @Override
+                    public void onRejection(Exception e) {
+                        // if we get rejected during node shutdown we don't wanna bubble it up
+                        logger.debug(
+                            () -> new ParameterizedMessage(
+                                "failed to notify response handler on rejection, action: {}",
+                                holderToNotify.action()
+                            ),
+                            e
+                        );
+                    }
+
+                    @Override
+                    public void onFailure(Exception e) {
+                        logger.warn(
+                            () -> new ParameterizedMessage(
+                                "failed to notify response handler on exception, action: {}",
+                                holderToNotify.action()
+                            ),
+                            e
+                        );
+                    }
+
+                    @Override
+                    public void doRun() {
+                        TransportException ex = new SendRequestTransportException(
+                            holderToNotify.connection().getNode(),
+                            holderToNotify.action(),
+                            new NodeClosedException(localNode)
+                        );
+                        holderToNotify.handler().handleException(ex);
+                    }
+                });
+            }
+        }
+    }
+
+    @Override
+    protected void doClose() throws IOException {
+        transport.close();
+    }
+
+    /**
+     * start accepting incoming requests.
+    * when the transport layer starts up it will block any incoming requests until
+    * this method is called
+    */
+    public final void acceptIncomingRequests() {
+        handleIncomingRequests.set(true);
+    }
+
+    @Override
+    public ProtobufTransportInfo info() {
+        ProtobufBoundTransportAddress boundTransportAddress = boundAddress();
+        if (boundTransportAddress == null) {
+            return null;
+        }
+        return new ProtobufTransportInfo(boundTransportAddress, transport.profileBoundAddresses());
+    }
+
+    public TransportStats stats() {
+        return transport.getStats();
+    }
+
+    public boolean isTransportSecure() {
+        return transport.isSecure();
+    }
+
+    public ProtobufBoundTransportAddress boundAddress() {
+        return transport.boundAddress();
+    }
+
+    public List<String> getDefaultSeedAddresses() {
+        return transport.getDefaultSeedAddresses();
+    }
+
+    /**
+     * Returns <code>true</code> iff the given node is already connected.
+    */
+    public boolean nodeConnected(DiscoveryNode node) {
+        return isLocalNode(node) || connectionManager.nodeConnected(node);
+    }
+
+    /**
+     * Connect to the specified node with the default connection profile
+    *
+    * @param node the node to connect to
+    */
+    public void connectToNode(DiscoveryNode node) throws ConnectTransportException {
+        connectToNode(node, (ConnectionProfile) null);
+    }
+
+    // We are skipping node validation for extensibility as extensionNode and opensearchNode(LocalNode) will have different ephemeral id's
+    public void connectToExtensionNode(final DiscoveryNode node) {
+        PlainActionFuture.get(fut -> connectToExtensionNode(node, (ConnectionProfile) null, ActionListener.map(fut, x -> null)));
+    }
+
+    /**
+     * Connect to the specified node with the given connection profile
+    *
+    * @param node the node to connect to
+    * @param connectionProfile the connection profile to use when connecting to this node
+    */
+    public void connectToNode(final DiscoveryNode node, ConnectionProfile connectionProfile) {
+        PlainActionFuture.get(fut -> connectToNode(node, connectionProfile, ActionListener.map(fut, x -> null)));
+    }
+
+    public void connectToExtensionNode(final DiscoveryNode node, ConnectionProfile connectionProfile) {
+        PlainActionFuture.get(fut -> connectToExtensionNode(node, connectionProfile, ActionListener.map(fut, x -> null)));
+    }
+
+    /**
+     * Connect to the specified node with the given connection profile.
+    * The ActionListener will be called on the calling thread or the generic thread pool.
+    *
+    * @param node the node to connect to
+    * @param listener the action listener to notify
+    */
+    public void connectToNode(DiscoveryNode node, ActionListener<Void> listener) throws ConnectTransportException {
+        connectToNode(node, null, listener);
+    }
+
+    public void connectToExtensionNode(DiscoveryNode node, ActionListener<Void> listener) throws ConnectTransportException {
+        connectToExtensionNode(node, null, listener);
+    }
+
+    /**
+     * Connect to the specified node with the given connection profile.
+    * The ActionListener will be called on the calling thread or the generic thread pool.
+    *
+    * @param node the node to connect to
+    * @param connectionProfile the connection profile to use when connecting to this node
+    * @param listener the action listener to notify
+    */
+    public void connectToNode(final DiscoveryNode node, ConnectionProfile connectionProfile, ActionListener<Void> listener) {
+        if (isLocalNode(node)) {
+            listener.onResponse(null);
+            return;
+        }
+        connectionManager.connectToNode(node, connectionProfile, connectionValidator(node), listener);
+    }
+
+    public void connectToExtensionNode(final DiscoveryNode node, ConnectionProfile connectionProfile, ActionListener<Void> listener) {
+        if (isLocalNode(node)) {
+            listener.onResponse(null);
+            return;
+        }
+        connectionManager.connectToNode(node, connectionProfile, extensionConnectionValidator(node), listener);
+    }
+
+    public ConnectionManager.ConnectionValidator connectionValidator(DiscoveryNode node) {
+        return (newConnection, actualProfile, listener) -> {
+            // We don't validate cluster names to allow for CCS connections.
+            handshake(newConnection, actualProfile.getHandshakeTimeout().millis(), cn -> true, ActionListener.map(listener, resp -> {
+                final DiscoveryNode remote = resp.discoveryNode;
+
+                if (node.equals(remote) == false) {
+                    throw new ConnectTransportException(node, "handshake failed. unexpected remote node " + remote);
+                }
+
+                return null;
+            }));
+        };
+    }
+
+    public ConnectionManager.ConnectionValidator extensionConnectionValidator(DiscoveryNode node) {
+        return (newConnection, actualProfile, listener) -> {
+            // We don't validate cluster names to allow for CCS connections.
+            handshake(newConnection, actualProfile.getHandshakeTimeout().millis(), cn -> true, ActionListener.map(listener, resp -> {
+                final DiscoveryNode remote = resp.discoveryNode;
+                logger.info("Connection validation was skipped");
+                return null;
+            }));
+        };
+    }
+
+    /**
+     * Establishes and returns a new connection to the given node. The connection is NOT maintained by this service, it's the callers
+    * responsibility to close the connection once it goes out of scope.
+    * The ActionListener will be called on the calling thread or the generic thread pool.
+    * @param node the node to connect to
+    * @param connectionProfile the connection profile to use
+    */
+    public Transport.Connection openConnection(final DiscoveryNode node, ConnectionProfile connectionProfile) {
+        return PlainActionFuture.get(fut -> openConnection(node, connectionProfile, fut));
+    }
+
+    /**
+     * Establishes a new connection to the given node. The connection is NOT maintained by this service, it's the callers
+    * responsibility to close the connection once it goes out of scope.
+    * The ActionListener will be called on the calling thread or the generic thread pool.
+    * @param node the node to connect to
+    * @param connectionProfile the connection profile to use
+    * @param listener the action listener to notify
+    */
+    public void openConnection(
+        final DiscoveryNode node,
+        ConnectionProfile connectionProfile,
+        ActionListener<Transport.Connection> listener
+    ) {
+        if (isLocalNode(node)) {
+            listener.onResponse(localNodeConnection);
+        } else {
+            connectionManager.openConnection(node, connectionProfile, listener);
+        }
+    }
+
+    /**
+     * Executes a high-level handshake using the given connection
+    * and returns the discovery node of the node the connection
+    * was established with. The handshake will fail if the cluster
+    * name on the target node mismatches the local cluster name.
+    * The ActionListener will be called on the calling thread or the generic thread pool.
+    *
+    * @param connection       the connection to a specific node
+    * @param handshakeTimeout handshake timeout
+    * @param listener         action listener to notify
+    * @throws ConnectTransportException if the connection failed
+    * @throws IllegalStateException if the handshake failed
+    */
+    public void handshake(
+        final Transport.Connection connection,
+        final long handshakeTimeout,
+        final ActionListener<DiscoveryNode> listener
+    ) {
+        handshake(
+            connection,
+            handshakeTimeout,
+            clusterName.getEqualityPredicate(),
+            ActionListener.map(listener, HandshakeResponse::getDiscoveryNode)
+        );
+    }
+
+    /**
+     * Executes a high-level handshake using the given connection
+    * and returns the discovery node of the node the connection
+    * was established with. The handshake will fail if the cluster
+    * name on the target node doesn't match the local cluster name.
+    * The ActionListener will be called on the calling thread or the generic thread pool.
+    *
+    * @param connection       the connection to a specific node
+    * @param handshakeTimeout handshake timeout
+    * @param clusterNamePredicate cluster name validation predicate
+    * @param listener         action listener to notify
+    * @throws IllegalStateException if the handshake failed
+    */
+    public void handshake(
+        final Transport.Connection connection,
+        final long handshakeTimeout,
+        Predicate<ClusterName> clusterNamePredicate,
+        final ActionListener<HandshakeResponse> listener
+    ) {
+        final DiscoveryNode node = connection.getNode();
+        sendRequest(
+            connection,
+            HANDSHAKE_ACTION_NAME,
+            HandshakeRequest.INSTANCE,
+            TransportRequestOptions.builder().withTimeout(handshakeTimeout).build(),
+            new ActionListenerResponseHandler<>(new ActionListener<HandshakeResponse>() {
+                @Override
+                public void onResponse(HandshakeResponse response) {
+                    if (clusterNamePredicate.test(response.clusterName) == false) {
+                        listener.onFailure(
+                            new IllegalStateException(
+                                "handshake with ["
+                                    + node
+                                    + "] failed: remote cluster name ["
+                                    + response.clusterName.value()
+                                    + "] does not match "
+                                    + clusterNamePredicate
+                            )
+                        );
+                    } else if (response.version.isCompatible(localNode.getVersion()) == false) {
+                        listener.onFailure(
+                            new IllegalStateException(
+                                "handshake with ["
+                                    + node
+                                    + "] failed: remote node version ["
+                                    + response.version
+                                    + "] is incompatible with local node version ["
+                                    + localNode.getVersion()
+                                    + "]"
+                            )
+                        );
+                    } else {
+                        listener.onResponse(response);
+                    }
+                }
+
+                @Override
+                public void onFailure(Exception e) {
+                    listener.onFailure(e);
+                }
+            }, HandshakeResponse::new, ThreadPool.Names.GENERIC)
+        );
+    }
+
+    public ConnectionManager getConnectionManager() {
+        return connectionManager;
+    }
+
+    /**
+     * Internal Handshake request
+    *
+    * @opensearch.internal
+    */
+    static class HandshakeRequest extends TransportRequest {
+
+        public static final HandshakeRequest INSTANCE = new HandshakeRequest();
+
+        HandshakeRequest(StreamInput in) throws IOException {
+            super(in);
+        }
+
+        private HandshakeRequest() {}
+
+    }
+
+    /**
+     * Internal handshake response
+    *
+    * @opensearch.internal
+    */
+    public static class HandshakeResponse extends TransportResponse {
+        private final DiscoveryNode discoveryNode;
+        private final ClusterName clusterName;
+        private final Version version;
+
+        public HandshakeResponse(DiscoveryNode discoveryNode, ClusterName clusterName, Version version) {
+            this.discoveryNode = discoveryNode;
+            this.version = version;
+            this.clusterName = clusterName;
+        }
+
+        public HandshakeResponse(StreamInput in) throws IOException {
+            super(in);
+            discoveryNode = in.readOptionalWriteable(DiscoveryNode::new);
+            clusterName = new ClusterName(in);
+            version = Version.readVersion(in);
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            out.writeOptionalWriteable(discoveryNode);
+            clusterName.writeTo(out);
+            Version.writeVersion(version, out);
+        }
+
+        public DiscoveryNode getDiscoveryNode() {
+            return discoveryNode;
+        }
+
+        public ClusterName getClusterName() {
+            return clusterName;
+        }
+    }
+
+    public void disconnectFromNode(DiscoveryNode node) {
+        if (isLocalNode(node)) {
+            return;
+        }
+        connectionManager.disconnectFromNode(node);
+    }
+
+    public void addMessageListener(TransportMessageListener listener) {
+        messageListener.listeners.add(listener);
+    }
+
+    public boolean removeMessageListener(TransportMessageListener listener) {
+        return messageListener.listeners.remove(listener);
+    }
+
+    public void addConnectionListener(TransportConnectionListener listener) {
+        connectionManager.addListener(listener);
+    }
+
+    public void removeConnectionListener(TransportConnectionListener listener) {
+        connectionManager.removeListener(listener);
+    }
+
+    public <T extends TransportResponse> TransportFuture<T> submitRequest(
+        DiscoveryNode node,
+        String action,
+        TransportRequest request,
+        TransportResponseHandler<T> handler
+    ) throws TransportException {
+        return submitRequest(node, action, request, TransportRequestOptions.EMPTY, handler);
+    }
+
+    public <T extends TransportResponse> TransportFuture<T> submitRequest(
+        DiscoveryNode node,
+        String action,
+        TransportRequest request,
+        TransportRequestOptions options,
+        TransportResponseHandler<T> handler
+    ) throws TransportException {
+        PlainTransportFuture<T> futureHandler = new PlainTransportFuture<>(handler);
+        try {
+            Transport.Connection connection = getConnection(node);
+            sendRequest(connection, action, request, options, futureHandler);
+        } catch (NodeNotConnectedException ex) {
+            // the caller might not handle this so we invoke the handler
+            futureHandler.handleException(ex);
+        }
+        return futureHandler;
+    }
+
+    public <T extends TransportResponse> void sendRequest(
+        final DiscoveryNode node,
+        final String action,
+        final TransportRequest request,
+        final TransportResponseHandler<T> handler
+    ) {
+        final Transport.Connection connection;
+        try {
+            connection = getConnection(node);
+        } catch (final NodeNotConnectedException ex) {
+            // the caller might not handle this so we invoke the handler
+            handler.handleException(ex);
+            return;
+        }
+        sendRequest(connection, action, request, TransportRequestOptions.EMPTY, handler);
+    }
+
+    public final <T extends TransportResponse> void sendRequest(
+        final DiscoveryNode node,
+        final String action,
+        final TransportRequest request,
+        final TransportRequestOptions options,
+        TransportResponseHandler<T> handler
+    ) {
+        final Transport.Connection connection;
+        try {
+            connection = getConnection(node);
+        } catch (final NodeNotConnectedException ex) {
+            // the caller might not handle this so we invoke the handler
+            handler.handleException(ex);
+            return;
+        }
+        sendRequest(connection, action, request, options, handler);
+    }
+
+    /**
+     * Sends a request on the specified connection. If there is a failure sending the request, the specified handler is invoked.
+    *
+    * @param connection the connection to send the request on
+    * @param action     the name of the action
+    * @param request    the request
+    * @param options    the options for this request
+    * @param handler    the response handler
+    * @param <T>        the type of the transport response
+    */
+    public final <T extends TransportResponse> void sendRequest(
+        final Transport.Connection connection,
+        final String action,
+        final TransportRequest request,
+        final TransportRequestOptions options,
+        final TransportResponseHandler<T> handler
+    ) {
+        try {
+            logger.debug("Action: " + action);
+            final TransportResponseHandler<T> delegate;
+            if (request.getParentTask().isSet()) {
+                // TODO: capture the connection instead so that we can cancel child tasks on the remote connections.
+                final Releasable unregisterChildNode = taskManager.registerChildNode(request.getParentTask().getId(), connection.getNode());
+                delegate = new TransportResponseHandler<T>() {
+                    @Override
+                    public void handleResponse(T response) {
+                        unregisterChildNode.close();
+                        handler.handleResponse(response);
+                    }
+
+                    @Override
+                    public void handleException(TransportException exp) {
+                        unregisterChildNode.close();
+                        handler.handleException(exp);
+                    }
+
+                    @Override
+                    public String executor() {
+                        return handler.executor();
+                    }
+
+                    @Override
+                    public T read(StreamInput in) throws IOException {
+                        return handler.read(in);
+                    }
+
+                    @Override
+                    public String toString() {
+                        return getClass().getName() + "/[" + action + "]:" + handler.toString();
+                    }
+                };
+            } else {
+                delegate = handler;
+            }
+            asyncSender.sendRequest(connection, action, request, options, delegate);
+        } catch (final Exception ex) {
+            // the caller might not handle this so we invoke the handler
+            final TransportException te;
+            if (ex instanceof TransportException) {
+                te = (TransportException) ex;
+            } else {
+                te = new TransportException("failure to send", ex);
+            }
+            handler.handleException(te);
+        }
+    }
+
+    /**
+     * Returns either a real transport connection or a local node connection if we are using the local node optimization.
+    * @throws NodeNotConnectedException if the given node is not connected
+    */
+    public Transport.Connection getConnection(DiscoveryNode node) {
+        if (isLocalNode(node)) {
+            return localNodeConnection;
+        } else {
+            return connectionManager.getConnection(node);
+        }
+    }
+
+    public final <T extends TransportResponse> void sendChildRequest(
+        final DiscoveryNode node,
+        final String action,
+        final TransportRequest request,
+        final Task parentTask,
+        final TransportRequestOptions options,
+        final TransportResponseHandler<T> handler
+    ) {
+        final Transport.Connection connection;
+        try {
+            connection = getConnection(node);
+        } catch (final NodeNotConnectedException ex) {
+            // the caller might not handle this so we invoke the handler
+            handler.handleException(ex);
+            return;
+        }
+        sendChildRequest(connection, action, request, parentTask, options, handler);
+    }
+
+    public <T extends TransportResponse> void sendChildRequest(
+        final Transport.Connection connection,
+        final String action,
+        final TransportRequest request,
+        final Task parentTask,
+        final TransportResponseHandler<T> handler
+    ) {
+        sendChildRequest(connection, action, request, parentTask, TransportRequestOptions.EMPTY, handler);
+    }
+
+    public <T extends TransportResponse> void sendChildRequest(
+        final Transport.Connection connection,
+        final String action,
+        final TransportRequest request,
+        final Task parentTask,
+        final TransportRequestOptions options,
+        final TransportResponseHandler<T> handler
+    ) {
+        request.setParentTask(localNode.getId(), parentTask.getId());
+        sendRequest(connection, action, request, options, handler);
+    }
+
+    private <T extends TransportResponse> void sendRequestInternal(
+        final Transport.Connection connection,
+        final String action,
+        final TransportRequest request,
+        final TransportRequestOptions options,
+        TransportResponseHandler<T> handler
+    ) {
+        if (connection == null) {
+            throw new IllegalStateException("can't send request to a null connection");
+        }
+        DiscoveryNode node = connection.getNode();
+
+        Supplier<ThreadContext.StoredContext> storedContextSupplier = threadPool.getThreadContext().newRestorableContext(true);
+        ContextRestoreResponseHandler<T> responseHandler = new ContextRestoreResponseHandler<>(storedContextSupplier, handler);
+        // TODO we can probably fold this entire request ID dance into connection.sendReqeust but it will be a bigger refactoring
+        final long requestId = responseHandlers.add(new Transport.ResponseContext<>(responseHandler, connection, action));
+        final TimeoutHandler timeoutHandler;
+        if (options.timeout() != null) {
+            timeoutHandler = new TimeoutHandler(requestId, connection.getNode(), action);
+            responseHandler.setTimeoutHandler(timeoutHandler);
+        } else {
+            timeoutHandler = null;
+        }
+        try {
+            if (lifecycle.stoppedOrClosed()) {
+                /*
+                * If we are not started the exception handling will remove the request holder again and calls the handler to notify the
+                * caller. It will only notify if toStop hasn't done the work yet.
+                */
+                throw new NodeClosedException(localNode);
+            }
+            if (timeoutHandler != null) {
+                assert options.timeout() != null;
+                timeoutHandler.scheduleTimeout(options.timeout());
+            }
+            connection.sendRequest(requestId, action, request, options); // local node optimization happens upstream
+        } catch (final Exception e) {
+            // usually happen either because we failed to connect to the node
+            // or because we failed serializing the message
+            final Transport.ResponseContext<? extends TransportResponse> contextToNotify = responseHandlers.remove(requestId);
+            // If holderToNotify == null then handler has already been taken care of.
+            if (contextToNotify != null) {
+                if (timeoutHandler != null) {
+                    timeoutHandler.cancel();
+                }
+                // callback that an exception happened, but on a different thread since we don't
+                // want handlers to worry about stack overflows. In the special case of running into a closing node we run on the current
+                // thread on a best effort basis though.
+                final SendRequestTransportException sendRequestException = new SendRequestTransportException(node, action, e);
+                final String executor = lifecycle.stoppedOrClosed() ? ThreadPool.Names.SAME : ThreadPool.Names.GENERIC;
+                threadPool.executor(executor).execute(new AbstractRunnable() {
+                    @Override
+                    public void onRejection(Exception e) {
+                        // if we get rejected during node shutdown we don't wanna bubble it up
+                        logger.debug(
+                            () -> new ParameterizedMessage(
+                                "failed to notify response handler on rejection, action: {}",
+                                contextToNotify.action()
+                            ),
+                            e
+                        );
+                    }
+
+                    @Override
+                    public void onFailure(Exception e) {
+                        logger.warn(
+                            () -> new ParameterizedMessage(
+                                "failed to notify response handler on exception, action: {}",
+                                contextToNotify.action()
+                            ),
+                            e
+                        );
+                    }
+
+                    @Override
+                    protected void doRun() throws Exception {
+                        contextToNotify.handler().handleException(sendRequestException);
+                    }
+                });
+            } else {
+                logger.debug("Exception while sending request, handler likely already notified due to timeout", e);
+            }
+        }
+    }
+
+    private void sendLocalRequest(long requestId, final String action, final TransportRequest request, TransportRequestOptions options) {
+        final DirectResponseChannel channel = new DirectResponseChannel(localNode, action, requestId, this, threadPool);
+        try {
+            onRequestSent(localNode, requestId, action, request, options);
+            onRequestReceived(requestId, action);
+            final RequestHandlerRegistry reg = getRequestHandler(action);
+            if (reg == null) {
+                throw new ActionNotFoundTransportException("Action [" + action + "] not found");
+            }
+            final String executor = reg.getExecutor();
+            if (ThreadPool.Names.SAME.equals(executor)) {
+                // noinspection unchecked
+                reg.processMessageReceived(request, channel);
+            } else {
+                threadPool.executor(executor).execute(new AbstractRunnable() {
+                    @Override
+                    protected void doRun() throws Exception {
+                        // noinspection unchecked
+                        reg.processMessageReceived(request, channel);
+                    }
+
+                    @Override
+                    public boolean isForceExecution() {
+                        return reg.isForceExecution();
+                    }
+
+                    @Override
+                    public void onFailure(Exception e) {
+                        try {
+                            channel.sendResponse(e);
+                        } catch (Exception inner) {
+                            inner.addSuppressed(e);
+                            logger.warn(
+                                () -> new ParameterizedMessage("failed to notify channel of error message for action [{}]", action),
+                                inner
+                            );
+                        }
+                    }
+
+                    @Override
+                    public String toString() {
+                        return "processing of [" + requestId + "][" + action + "]: " + request;
+                    }
+                });
+            }
+
+        } catch (Exception e) {
+            try {
+                channel.sendResponse(e);
+            } catch (Exception inner) {
+                inner.addSuppressed(e);
+                logger.warn(() -> new ParameterizedMessage("failed to notify channel of error message for action [{}]", action), inner);
+            }
+        }
+    }
+
+    private boolean shouldTraceAction(String action) {
+        return shouldTraceAction(action, tracerLogInclude, tracerLogExclude);
+    }
+
+    public static boolean shouldTraceAction(String action, String[] include, String[] exclude) {
+        if (include.length > 0) {
+            if (Regex.simpleMatch(include, action) == false) {
+                return false;
+            }
+        }
+        if (exclude.length > 0) {
+            return !Regex.simpleMatch(exclude, action);
+        }
+        return true;
+    }
+
+    public TransportAddress[] addressesFromString(String address) throws UnknownHostException {
+        return transport.addressesFromString(address);
+    }
+
+    /**
+     * A set of all valid action prefixes.
+    */
+    public static final Set<String> VALID_ACTION_PREFIXES = Collections.unmodifiableSet(
+        new HashSet<>(
+            Arrays.asList(
+                "indices:admin",
+                "indices:monitor",
+                "indices:data/write",
+                "indices:data/read",
+                "indices:internal",
+                "cluster:admin",
+                "cluster:monitor",
+                "cluster:internal",
+                "internal:"
+            )
+        )
+    );
+
+    private void validateActionName(String actionName) {
+        // TODO we should makes this a hard validation and throw an exception but we need a good way to add backwards layer
+        // for it. Maybe start with a deprecation layer
+        if (isValidActionName(actionName) == false) {
+            logger.warn("invalid action name [" + actionName + "] must start with one of: " + ProtobufTransportService.VALID_ACTION_PREFIXES);
+        }
+    }
+
+    /**
+     * Returns <code>true</code> iff the action name starts with a valid prefix.
+    *
+    * @see #VALID_ACTION_PREFIXES
+    */
+    public static boolean isValidActionName(String actionName) {
+        for (String prefix : VALID_ACTION_PREFIXES) {
+            if (actionName.startsWith(prefix)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Registers a new request handler
+    *
+    * @param action         The action the request handler is associated with
+    * @param requestReader  a callable to be used construct new instances for streaming
+    * @param executor       The executor the request handling will be executed on
+    * @param handler        The handler itself that implements the request handling
+    */
+    public <Request extends TransportRequest> void registerRequestHandler(
+        String action,
+        String executor,
+        Writeable.Reader<Request> requestReader,
+        TransportRequestHandler<Request> handler
+    ) {
+        validateActionName(action);
+        handler = interceptor.interceptHandler(action, executor, false, handler);
+        RequestHandlerRegistry<Request> reg = new RequestHandlerRegistry<>(
+            action,
+            requestReader,
+            taskManager,
+            handler,
+            executor,
+            false,
+            true
+        );
+        transport.registerRequestHandler(reg);
+    }
+
+    /**
+     * Registers a new request handler
+    *
+    * @param action                The action the request handler is associated with
+    * @param requestReader               The request class that will be used to construct new instances for streaming
+    * @param executor              The executor the request handling will be executed on
+    * @param forceExecution        Force execution on the executor queue and never reject it
+    * @param canTripCircuitBreaker Check the request size and raise an exception in case the limit is breached.
+    * @param handler               The handler itself that implements the request handling
+    */
+    public <Request extends TransportRequest> void registerRequestHandler(
+        String action,
+        String executor,
+        boolean forceExecution,
+        boolean canTripCircuitBreaker,
+        Writeable.Reader<Request> requestReader,
+        TransportRequestHandler<Request> handler
+    ) {
+        validateActionName(action);
+        handler = interceptor.interceptHandler(action, executor, forceExecution, handler);
+        RequestHandlerRegistry<Request> reg = new RequestHandlerRegistry<>(
+            action,
+            requestReader,
+            taskManager,
+            handler,
+            executor,
+            forceExecution,
+            canTripCircuitBreaker
+        );
+        transport.registerRequestHandler(reg);
+    }
+
+    /**
+     * called by the {@link Transport} implementation when an incoming request arrives but before
+    * any parsing of it has happened (with the exception of the requestId and action)
+    */
+    @Override
+    public void onRequestReceived(long requestId, String action) {
+        if (handleIncomingRequests.get() == false) {
+            throw new IllegalStateException("transport not ready yet to handle incoming requests");
+        }
+        if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
+            tracerLog.trace("[{}][{}] received request", requestId, action);
+        }
+        messageListener.onRequestReceived(requestId, action);
+    }
+
+    /** called by the {@link Transport} implementation once a request has been sent */
+    @Override
+    public void onRequestSent(
+        DiscoveryNode node,
+        long requestId,
+        String action,
+        TransportRequest request,
+        TransportRequestOptions options
+    ) {
+        if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
+            tracerLog.trace("[{}][{}] sent to [{}] (timeout: [{}])", requestId, action, node, options.timeout());
+        }
+        messageListener.onRequestSent(node, requestId, action, request, options);
+    }
+
+    @Override
+    public void onResponseReceived(long requestId, Transport.ResponseContext holder) {
+        if (holder == null) {
+            checkForTimeout(requestId);
+        } else if (tracerLog.isTraceEnabled() && shouldTraceAction(holder.action())) {
+            tracerLog.trace("[{}][{}] received response from [{}]", requestId, holder.action(), holder.connection().getNode());
+        }
+        messageListener.onResponseReceived(requestId, holder);
+    }
+
+    /** called by the {@link Transport} implementation once a response was sent to calling node */
+    @Override
+    public void onResponseSent(long requestId, String action, TransportResponse response) {
+        if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
+            tracerLog.trace("[{}][{}] sent response", requestId, action);
+        }
+        messageListener.onResponseSent(requestId, action, response);
+    }
+
+    /** called by the {@link Transport} implementation after an exception was sent as a response to an incoming request */
+    @Override
+    public void onResponseSent(long requestId, String action, Exception e) {
+        if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
+            tracerLog.trace(() -> new ParameterizedMessage("[{}][{}] sent error response", requestId, action), e);
+        }
+        messageListener.onResponseSent(requestId, action, e);
+    }
+
+    public RequestHandlerRegistry<? extends TransportRequest> getRequestHandler(String action) {
+        return transport.getRequestHandlers().getHandler(action);
+    }
+
+    private void checkForTimeout(long requestId) {
+        // lets see if its in the timeout holder, but sync on mutex to make sure any ongoing timeout handling has finished
+        final DiscoveryNode sourceNode;
+        final String action;
+        assert responseHandlers.contains(requestId) == false;
+        TimeoutInfoHolder timeoutInfoHolder = timeoutInfoHandlers.remove(requestId);
+        if (timeoutInfoHolder != null) {
+            long time = threadPool.relativeTimeInMillis();
+            logger.warn(
+                "Received response for a request that has timed out, sent [{}ms] ago, timed out [{}ms] ago, "
+                    + "action [{}], node [{}], id [{}]",
+                time - timeoutInfoHolder.sentTime(),
+                time - timeoutInfoHolder.timeoutTime(),
+                timeoutInfoHolder.action(),
+                timeoutInfoHolder.node(),
+                requestId
+            );
+            action = timeoutInfoHolder.action();
+            sourceNode = timeoutInfoHolder.node();
+        } else {
+            logger.warn("Transport response handler not found of id [{}]", requestId);
+            action = null;
+            sourceNode = null;
+        }
+        // call tracer out of lock
+        if (tracerLog.isTraceEnabled() == false) {
+            return;
+        }
+        if (action == null) {
+            assert sourceNode == null;
+            tracerLog.trace("[{}] received response but can't resolve it to a request", requestId);
+        } else if (shouldTraceAction(action)) {
+            tracerLog.trace("[{}][{}] received response from [{}]", requestId, action, sourceNode);
+        }
+    }
+
+    @Override
+    public void onConnectionClosed(Transport.Connection connection) {
+        try {
+            List<Transport.ResponseContext<? extends TransportResponse>> pruned = responseHandlers.prune(
+                h -> h.connection().getCacheKey().equals(connection.getCacheKey())
+            );
+            // callback that an exception happened, but on a different thread since we don't
+            // want handlers to worry about stack overflows
+            getExecutorService().execute(new Runnable() {
+                @Override
+                public void run() {
+                    for (Transport.ResponseContext holderToNotify : pruned) {
+                        holderToNotify.handler()
+                            .handleException(new NodeDisconnectedException(connection.getNode(), holderToNotify.action()));
+                    }
+                }
+
+                @Override
+                public String toString() {
+                    return "onConnectionClosed(" + connection.getNode() + ")";
+                }
+            });
+        } catch (OpenSearchRejectedExecutionException ex) {
+            logger.debug("Rejected execution on onConnectionClosed", ex);
+        }
+    }
+
+    final class TimeoutHandler implements Runnable {
+
+        private final long requestId;
+        private final long sentTime = threadPool.relativeTimeInMillis();
+        private final String action;
+        private final DiscoveryNode node;
+        volatile Scheduler.Cancellable cancellable;
+
+        TimeoutHandler(long requestId, DiscoveryNode node, String action) {
+            this.requestId = requestId;
+            this.node = node;
+            this.action = action;
+        }
+
+        @Override
+        public void run() {
+            if (responseHandlers.contains(requestId)) {
+                long timeoutTime = threadPool.relativeTimeInMillis();
+                timeoutInfoHandlers.put(requestId, new TimeoutInfoHolder(node, action, sentTime, timeoutTime));
+                // now that we have the information visible via timeoutInfoHandlers, we try to remove the request id
+                final Transport.ResponseContext<? extends TransportResponse> holder = responseHandlers.remove(requestId);
+                if (holder != null) {
+                    assert holder.action().equals(action);
+                    assert holder.connection().getNode().equals(node);
+                    holder.handler()
+                        .handleException(
+                            new ReceiveTimeoutTransportException(
+                                holder.connection().getNode(),
+                                holder.action(),
+                                "request_id [" + requestId + "] timed out after [" + (timeoutTime - sentTime) + "ms]"
+                            )
+                        );
+                } else {
+                    // response was processed, remove timeout info.
+                    timeoutInfoHandlers.remove(requestId);
+                }
+            }
+        }
+
+        /**
+         * cancels timeout handling. this is a best effort only to avoid running it. remove the requestId from {@link #responseHandlers}
+        * to make sure this doesn't run.
+        */
+        public void cancel() {
+            assert responseHandlers.contains(requestId) == false : "cancel must be called after the requestId ["
+                + requestId
+                + "] has been removed from clientHandlers";
+            if (cancellable != null) {
+                cancellable.cancel();
+            }
+        }
+
+        @Override
+        public String toString() {
+            return "timeout handler for [" + requestId + "][" + action + "]";
+        }
+
+        private void scheduleTimeout(TimeValue timeout) {
+            this.cancellable = threadPool.schedule(this, timeout, ThreadPool.Names.GENERIC);
+        }
+    }
+
+    /**
+     * Holder for timeout information
+    *
+    * @opensearch.internal
+    */
+    static class TimeoutInfoHolder {
+
+        private final DiscoveryNode node;
+        private final String action;
+        private final long sentTime;
+        private final long timeoutTime;
+
+        TimeoutInfoHolder(DiscoveryNode node, String action, long sentTime, long timeoutTime) {
+            this.node = node;
+            this.action = action;
+            this.sentTime = sentTime;
+            this.timeoutTime = timeoutTime;
+        }
+
+        public DiscoveryNode node() {
+            return node;
+        }
+
+        public String action() {
+            return action;
+        }
+
+        public long sentTime() {
+            return sentTime;
+        }
+
+        public long timeoutTime() {
+            return timeoutTime;
+        }
+    }
+
+    /**
+     * This handler wrapper ensures that the response thread executes with the correct thread context. Before any of the handle methods
+    * are invoked we restore the context.
+    */
+    public static final class ContextRestoreResponseHandler<T extends TransportResponse> implements TransportResponseHandler<T> {
+
+        private final TransportResponseHandler<T> delegate;
+        private final Supplier<ThreadContext.StoredContext> contextSupplier;
+        private volatile TimeoutHandler handler;
+
+        public ContextRestoreResponseHandler(Supplier<ThreadContext.StoredContext> contextSupplier, TransportResponseHandler<T> delegate) {
+            this.delegate = delegate;
+            this.contextSupplier = contextSupplier;
+        }
+
+        @Override
+        public T read(StreamInput in) throws IOException {
+            return delegate.read(in);
+        }
+
+        @Override
+        public void handleResponse(T response) {
+            if (handler != null) {
+                handler.cancel();
+            }
+            try (ThreadContext.StoredContext ignore = contextSupplier.get()) {
+                delegate.handleResponse(response);
+            }
+        }
+
+        @Override
+        public void handleException(TransportException exp) {
+            if (handler != null) {
+                handler.cancel();
+            }
+            try (ThreadContext.StoredContext ignore = contextSupplier.get()) {
+                delegate.handleException(exp);
+            }
+        }
+
+        @Override
+        public String executor() {
+            return delegate.executor();
+        }
+
+        @Override
+        public String toString() {
+            return getClass().getName() + "/" + delegate.toString();
+        }
+
+        void setTimeoutHandler(TimeoutHandler handler) {
+            this.handler = handler;
+        }
+
+    }
+
+    /**
+     * A channel for a direct response
+    *
+    * @opensearch.internal
+    */
+    static class DirectResponseChannel implements TransportChannel {
+        final DiscoveryNode localNode;
+        private final String action;
+        private final long requestId;
+        final ProtobufTransportService service;
+        final ThreadPool threadPool;
+
+        DirectResponseChannel(DiscoveryNode localNode, String action, long requestId, ProtobufTransportService service, ThreadPool threadPool) {
+            this.localNode = localNode;
+            this.action = action;
+            this.requestId = requestId;
+            this.service = service;
+            this.threadPool = threadPool;
+        }
+
+        @Override
+        public String getProfileName() {
+            return DIRECT_RESPONSE_PROFILE;
+        }
+
+        @Override
+        public void sendResponse(TransportResponse response) throws IOException {
+            service.onResponseSent(requestId, action, response);
+            final TransportResponseHandler handler = service.responseHandlers.onResponseReceived(requestId, service);
+            // ignore if its null, the service logs it
+            if (handler != null) {
+                final String executor = handler.executor();
+                if (ThreadPool.Names.SAME.equals(executor)) {
+                    processResponse(handler, response);
+                } else {
+                    threadPool.executor(executor).execute(new Runnable() {
+                        @Override
+                        public void run() {
+                            processResponse(handler, response);
+                        }
+
+                        @Override
+                        public String toString() {
+                            return "delivery of response to [" + requestId + "][" + action + "]: " + response;
+                        }
+                    });
+                }
+            }
+        }
+
+        @SuppressWarnings("unchecked")
+        protected void processResponse(TransportResponseHandler handler, TransportResponse response) {
+            try {
+                handler.handleResponse(response);
+            } catch (Exception e) {
+                processException(handler, wrapInRemote(new ResponseHandlerFailureTransportException(e)));
+            }
+        }
+
+        @Override
+        public void sendResponse(Exception exception) throws IOException {
+            service.onResponseSent(requestId, action, exception);
+            final TransportResponseHandler handler = service.responseHandlers.onResponseReceived(requestId, service);
+            // ignore if its null, the service logs it
+            if (handler != null) {
+                final RemoteTransportException rtx = wrapInRemote(exception);
+                final String executor = handler.executor();
+                if (ThreadPool.Names.SAME.equals(executor)) {
+                    processException(handler, rtx);
+                } else {
+                    threadPool.executor(handler.executor()).execute(new Runnable() {
+                        @Override
+                        public void run() {
+                            processException(handler, rtx);
+                        }
+
+                        @Override
+                        public String toString() {
+                            return "delivery of failure response to [" + requestId + "][" + action + "]: " + exception;
+                        }
+                    });
+                }
+            }
+        }
+
+        protected RemoteTransportException wrapInRemote(Exception e) {
+            if (e instanceof RemoteTransportException) {
+                return (RemoteTransportException) e;
+            }
+            return new RemoteTransportException(localNode.getName(), localNode.getAddress(), action, e);
+        }
+
+        protected void processException(final TransportResponseHandler handler, final RemoteTransportException rtx) {
+            try {
+                handler.handleException(rtx);
+            } catch (Exception e) {
+                logger.error(
+                    () -> new ParameterizedMessage("failed to handle exception for action [{}], handler [{}]", action, handler),
+                    e
+                );
+            }
+        }
+
+        @Override
+        public String getChannelType() {
+            return "direct";
+        }
+
+        @Override
+        public Version getVersion() {
+            return localNode.getVersion();
+        }
+    }
+
+    /**
+     * Returns the internal thread pool
+    */
+    public ThreadPool getThreadPool() {
+        return threadPool;
+    }
+
+    private boolean isLocalNode(DiscoveryNode discoveryNode) {
+        return Objects.requireNonNull(discoveryNode, "discovery node must not be null").equals(localNode);
+    }
+
+    private static final class DelegatingTransportMessageListener implements TransportMessageListener {
+
+        private final List<TransportMessageListener> listeners = new CopyOnWriteArrayList<>();
+
+        @Override
+        public void onRequestReceived(long requestId, String action) {
+            for (TransportMessageListener listener : listeners) {
+                listener.onRequestReceived(requestId, action);
+            }
+        }
+
+        @Override
+        public void onResponseSent(long requestId, String action, TransportResponse response) {
+            for (TransportMessageListener listener : listeners) {
+                listener.onResponseSent(requestId, action, response);
+            }
+        }
+
+        @Override
+        public void onResponseSent(long requestId, String action, Exception error) {
+            for (TransportMessageListener listener : listeners) {
+                listener.onResponseSent(requestId, action, error);
+            }
+        }
+
+        @Override
+        public void onRequestSent(
+            DiscoveryNode node,
+            long requestId,
+            String action,
+            TransportRequest request,
+            TransportRequestOptions finalOptions
+        ) {
+            for (TransportMessageListener listener : listeners) {
+                listener.onRequestSent(node, requestId, action, request, finalOptions);
+            }
+        }
+
+        @Override
+        public void onResponseReceived(long requestId, Transport.ResponseContext holder) {
+            for (TransportMessageListener listener : listeners) {
+                listener.onResponseReceived(requestId, holder);
+            }
+        }
+    }
+}

From a1ab5891bdc32d75e8da2a58a2c9ad505ac923ba Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Thu, 25 May 2023 23:23:09 +0000
Subject: [PATCH 08/37] Fixing build and integrating protobuf for classes
 related to RestNodesAction

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../org/opensearch/core/rest/RestStatus.java  |  10 +
 .../ProtobufOpenSearchException.java          | 912 +++++++++++++++++-
 .../org/opensearch/action/ActionModule.java   |  69 ++
 ...ProtobufActionListenerResponseHandler.java |  73 ++
 .../action/ProtobufActionRequestBuilder.java  |   1 -
 .../opensearch/action/ProtobufActionType.java |   1 -
 .../cluster/node/info/ProtobufNodeInfo.java   |  47 +-
 .../node/info/ProtobufNodesInfoAction.java    |  26 +
 .../node/info/ProtobufNodesInfoRequest.java   |   8 +-
 .../info/ProtobufNodesInfoRequestBuilder.java |  65 ++
 .../node/info/ProtobufNodesInfoResponse.java  |   8 +-
 .../node/info/ProtobufPluginsAndModules.java  |  12 +-
 .../cluster/node/stats/ProtobufNodeStats.java | 322 +++++++
 .../node/stats/ProtobufNodesStatsAction.java  |  26 +
 .../node/stats/ProtobufNodesStatsRequest.java |  12 +-
 .../ProtobufNodesStatsRequestBuilder.java     |  82 ++
 .../stats/ProtobufNodesStatsResponse.java     |  84 ++
 .../state/ProtobufClusterStateAction.java     |   1 -
 .../state/ProtobufClusterStateRequest.java    |  16 +-
 .../ProtobufClusterStateRequestBuilder.java   |   2 -
 .../state/ProtobufClusterStateResponse.java   |  11 +-
 .../indices/stats/ProtobufCommonStats.java    | 460 +++++++++
 .../stats/ProtobufCommonStatsFlags.java       |  29 +-
 .../action/support/IndicesOptions.java        |  12 +-
 .../action/support/ProtobufActionFilter.java  |   8 +-
 .../support/ProtobufActionFilterChain.java    |   6 +-
 .../ProtobufChannelActionListener.java        |  48 +
 .../support/ProtobufTransportAction.java      |  47 +-
 ...terManagerNodeOperationRequestBuilder.java |  15 +-
 ...anagerNodeReadOperationRequestBuilder.java |   7 +-
 .../ProtobufClusterManagerNodeRequest.java    |   8 +-
 .../nodes/ProtobufBaseNodesRequest.java       |  20 +-
 .../nodes/ProtobufBaseNodesResponse.java      |   8 +-
 .../ProtobufNodesOperationRequestBuilder.java |  49 +
 .../opensearch/client/ClusterAdminClient.java |   4 -
 .../org/opensearch/client/ProtobufClient.java |  39 +-
 .../client/ProtobufClusterAdminClient.java    | 170 +---
 .../client/ProtobufFilterClient.java          |  74 ++
 .../client/ProtobufOpenSearchClient.java      |   4 -
 .../client/node/ProtobufNodeClient.java       |  68 +-
 .../client/support/AbstractClient.java        |  19 -
 .../support/ProtobufAbstractClient.java       | 436 +--------
 .../cluster/ProtobufAbstractDiffable.java     |  88 ++
 .../cluster/ProtobufClusterName.java          |  15 +
 .../cluster/ProtobufClusterState.java         |  62 +-
 .../cluster/ProtobufDiffableUtils.java        |  20 +-
 .../ProtobufNamedDiffableValueSerializer.java |   4 +-
 .../ProtobufPendingClusterStateStats.java     |  87 ++
 .../ProtobufPublishClusterStateStats.java     |  92 ++
 .../cluster/node/ProtobufDiscoveryNode.java   |  25 +-
 .../cluster/node/ProtobufDiscoveryNodes.java  |  14 +-
 .../cluster/routing/RoutingNodes.java         |  59 --
 .../common/ProtobufFieldMemoryStats.java      | 124 +++
 .../ProtobufNamedWriteableRegistry.java       | 121 +++
 ...otobufNotSerializableExceptionWrapper.java |  74 ++
 .../common/io/stream/ProtobufStreamInput.java | 232 +++--
 .../io/stream/ProtobufStreamOutput.java       | 265 ++++-
 .../common/util/concurrent/ThreadContext.java |  12 +-
 .../discovery/ProtobufDiscoveryStats.java     |  99 ++
 .../opensearch/http/ProtobufHttpStats.java    |  67 ++
 .../cache/query/ProtobufQueryCacheStats.java  | 151 +++
 .../request/ProtobufRequestCacheStats.java    | 107 ++
 .../index/engine/ProtobufSegmentsStats.java   | 285 ++++++
 .../fielddata/ProtobufFieldDataStats.java     | 120 +++
 .../index/flush/ProtobufFlushStats.java       | 123 +++
 .../index/get/ProtobufGetStats.java           | 151 +++
 .../index/merge/ProtobufMergeStats.java       | 262 +++++
 .../index/recovery/ProtobufRecoveryStats.java | 137 +++
 .../index/refresh/ProtobufRefreshStats.java   | 161 ++++
 .../search/stats/ProtobufSearchStats.java     | 444 +++++++++
 .../index/shard/ProtobufDocsStats.java        | 110 +++
 .../index/shard/ProtobufIndexingStats.java    | 286 ++++++
 .../index/store/ProtobufStoreStats.java       | 118 +++
 .../index/translog/ProtobufTranslogStats.java | 137 +++
 .../index/warmer/ProtobufWarmerStats.java     | 118 +++
 .../indices/ProtobufNodeIndicesStats.java     | 165 ++++
 .../ProtobufAllCircuitBreakerStats.java       |  78 ++
 .../breaker/ProtobufCircuitBreakerStats.java  | 124 +++
 .../ingest/ProtobufIngestStats.java           | 351 +++++++
 .../opensearch/monitor/fs/ProtobufFsInfo.java | 554 +++++++++++
 .../monitor/jvm/ProtobufJvmInfo.java          |  18 +-
 .../monitor/jvm/ProtobufJvmStats.java         | 755 +++++++++++++++
 .../opensearch/monitor/os/ProtobufOsInfo.java |  20 +-
 .../monitor/os/ProtobufOsStats.java           | 610 ++++++++++++
 .../monitor/process/ProtobufProcessStats.java | 193 ++++
 .../node/ProtobufAdaptiveSelectionStats.java  | 121 +++
 .../node/ProtobufNodeClosedException.java     |  31 +
 .../node/ResponseCollectorService.java        | 130 ++-
 .../plugins/ProtobufPluginInfo.java           |   8 +-
 .../rest/ClientAgnosticRestHandler.java       |  27 +
 .../rest/ProtobufBaseRestHandler.java         | 309 ++++++
 .../opensearch/rest/ProtobufRestHandler.java  | 259 +++++
 .../java/org/opensearch/rest/RestHandler.java |   2 +-
 .../action/cat/ProtobufAbstractCatAction.java |  78 ++
 .../action/cat/ProtobufRestNodesAction.java   | 545 +++++++++++
 .../rest/action/cat/RestNodesAction.java      |  36 +-
 .../script/ProtobufScriptCacheStats.java      | 152 +++
 .../script/ProtobufScriptContextStats.java    |  91 ++
 .../script/ProtobufScriptStats.java           | 127 +++
 .../completion/ProtobufCompletionStats.java   |  96 ++
 .../ProtobufTaskCancellationService.java      | 118 +--
 .../opensearch/tasks/ProtobufTaskInfo.java    |  14 +-
 .../tasks/ProtobufTaskListener.java           |  40 +
 .../opensearch/tasks/ProtobufTaskManager.java |  31 +-
 .../ProtobufTaskResourceTrackingService.java  |   3 +-
 .../opensearch/tasks/ProtobufTaskResult.java  |   6 +-
 .../threadpool/ProtobufThreadPool.java        |  12 +-
 .../threadpool/ProtobufThreadPoolInfo.java    |   8 +-
 .../threadpool/ProtobufThreadPoolStats.java   | 191 ++++
 .../ProtobufActionTransportException.java     |  88 ++
 .../ProtobufBytesTransportRequest.java        |  66 ++
 .../ProtobufClusterConnectionManager.java     | 290 ++++++
 .../ProtobufConnectTransportException.java    |  61 ++
 .../transport/ProtobufConnectionManager.java  | 114 +++
 .../transport/ProtobufConnectionProfile.java  | 362 +++++++
 ...ProtobufEmptyTransportResponseHandler.java |  46 +
 .../transport/ProtobufNetworkMessage.java     |   2 +-
 .../ProtobufNodeDisconnectedException.java    |  37 +
 .../ProtobufNodeNotConnectedException.java    |  30 +
 .../transport/ProtobufOutboundHandler.java    | 281 ++++++
 .../transport/ProtobufOutboundMessage.java    |  80 +-
 .../ProtobufPlainTransportFuture.java         | 103 ++
 .../ProtobufProxyConnectionStrategy.java      | 414 ++++++++
 ...tobufReceiveTimeoutTransportException.java |  31 +
 .../ProtobufRemoteClusterAwareClient.java     |  78 ++
 .../ProtobufRemoteClusterAwareRequest.java    |  29 +
 .../ProtobufRemoteClusterConnection.java      | 229 +++++
 .../ProtobufRemoteClusterService.java         | 454 +++++++++
 .../ProtobufRemoteConnectionInfo.java         | 132 +++
 .../ProtobufRemoteConnectionManager.java      | 217 +++++
 .../ProtobufRemoteConnectionStrategy.java     | 484 ++++++++++
 .../ProtobufRemoteTransportException.java     |  42 +
 .../ProtobufRequestHandlerRegistry.java       |  25 +-
 ...ProtobufSendRequestTransportException.java |  31 +
 .../ProtobufSniffConnectionStrategy.java      | 628 ++++++++++++
 .../ProtobufTcpTransportChannel.java          |  10 +-
 .../transport/ProtobufTransport.java          |  65 +-
 .../ProtobufTransportActionProxy.java         | 226 +++++
 .../ProtobufTransportConnectionListener.java  |  43 +
 .../transport/ProtobufTransportException.java |  37 +
 .../ProtobufTransportInterceptor.java         |  59 ++
 .../ProtobufTransportRequestHandler.java      |   3 +-
 .../ProtobufTransportResponseHandler.java     |  57 ++
 .../transport/ProtobufTransportService.java   | 512 +++++-----
 .../transport/ProtobufTransportStats.java     | 126 +++
 .../org/opensearch/transport/TcpHeader.java   |  19 +
 146 files changed, 16824 insertions(+), 1479 deletions(-)
 create mode 100644 server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoAction.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequestBuilder.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsAction.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequestBuilder.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStats.java
 create mode 100644 server/src/main/java/org/opensearch/action/support/ProtobufChannelActionListener.java
 create mode 100644 server/src/main/java/org/opensearch/action/support/nodes/ProtobufNodesOperationRequestBuilder.java
 create mode 100644 server/src/main/java/org/opensearch/client/ProtobufFilterClient.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufAbstractDiffable.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/coordination/ProtobufPendingClusterStateStats.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/coordination/ProtobufPublishClusterStateStats.java
 create mode 100644 server/src/main/java/org/opensearch/common/ProtobufFieldMemoryStats.java
 create mode 100644 server/src/main/java/org/opensearch/common/io/stream/ProtobufNamedWriteableRegistry.java
 create mode 100644 server/src/main/java/org/opensearch/common/io/stream/ProtobufNotSerializableExceptionWrapper.java
 create mode 100644 server/src/main/java/org/opensearch/discovery/ProtobufDiscoveryStats.java
 create mode 100644 server/src/main/java/org/opensearch/http/ProtobufHttpStats.java
 create mode 100644 server/src/main/java/org/opensearch/index/cache/query/ProtobufQueryCacheStats.java
 create mode 100644 server/src/main/java/org/opensearch/index/cache/request/ProtobufRequestCacheStats.java
 create mode 100644 server/src/main/java/org/opensearch/index/engine/ProtobufSegmentsStats.java
 create mode 100644 server/src/main/java/org/opensearch/index/fielddata/ProtobufFieldDataStats.java
 create mode 100644 server/src/main/java/org/opensearch/index/flush/ProtobufFlushStats.java
 create mode 100644 server/src/main/java/org/opensearch/index/get/ProtobufGetStats.java
 create mode 100644 server/src/main/java/org/opensearch/index/merge/ProtobufMergeStats.java
 create mode 100644 server/src/main/java/org/opensearch/index/recovery/ProtobufRecoveryStats.java
 create mode 100644 server/src/main/java/org/opensearch/index/refresh/ProtobufRefreshStats.java
 create mode 100644 server/src/main/java/org/opensearch/index/search/stats/ProtobufSearchStats.java
 create mode 100644 server/src/main/java/org/opensearch/index/shard/ProtobufDocsStats.java
 create mode 100644 server/src/main/java/org/opensearch/index/shard/ProtobufIndexingStats.java
 create mode 100644 server/src/main/java/org/opensearch/index/store/ProtobufStoreStats.java
 create mode 100644 server/src/main/java/org/opensearch/index/translog/ProtobufTranslogStats.java
 create mode 100644 server/src/main/java/org/opensearch/index/warmer/ProtobufWarmerStats.java
 create mode 100644 server/src/main/java/org/opensearch/indices/ProtobufNodeIndicesStats.java
 create mode 100644 server/src/main/java/org/opensearch/indices/breaker/ProtobufAllCircuitBreakerStats.java
 create mode 100644 server/src/main/java/org/opensearch/indices/breaker/ProtobufCircuitBreakerStats.java
 create mode 100644 server/src/main/java/org/opensearch/ingest/ProtobufIngestStats.java
 create mode 100644 server/src/main/java/org/opensearch/monitor/fs/ProtobufFsInfo.java
 create mode 100644 server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmStats.java
 create mode 100644 server/src/main/java/org/opensearch/monitor/os/ProtobufOsStats.java
 create mode 100644 server/src/main/java/org/opensearch/monitor/process/ProtobufProcessStats.java
 create mode 100644 server/src/main/java/org/opensearch/node/ProtobufAdaptiveSelectionStats.java
 create mode 100644 server/src/main/java/org/opensearch/node/ProtobufNodeClosedException.java
 create mode 100644 server/src/main/java/org/opensearch/rest/ClientAgnosticRestHandler.java
 create mode 100644 server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java
 create mode 100644 server/src/main/java/org/opensearch/rest/ProtobufRestHandler.java
 create mode 100644 server/src/main/java/org/opensearch/rest/action/cat/ProtobufAbstractCatAction.java
 create mode 100644 server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
 create mode 100644 server/src/main/java/org/opensearch/script/ProtobufScriptCacheStats.java
 create mode 100644 server/src/main/java/org/opensearch/script/ProtobufScriptContextStats.java
 create mode 100644 server/src/main/java/org/opensearch/script/ProtobufScriptStats.java
 create mode 100644 server/src/main/java/org/opensearch/search/suggest/completion/ProtobufCompletionStats.java
 create mode 100644 server/src/main/java/org/opensearch/tasks/ProtobufTaskListener.java
 create mode 100644 server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolStats.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufActionTransportException.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufBytesTransportRequest.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufConnectTransportException.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufConnectionProfile.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufNodeDisconnectedException.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufNodeNotConnectedException.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufPlainTransportFuture.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufProxyConnectionStrategy.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufReceiveTimeoutTransportException.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareRequest.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionInfo.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufRemoteTransportException.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufSendRequestTransportException.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportException.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportResponseHandler.java
 create mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportStats.java

diff --git a/libs/core/src/main/java/org/opensearch/core/rest/RestStatus.java b/libs/core/src/main/java/org/opensearch/core/rest/RestStatus.java
index ae4f4c65b28d2..466d550938505 100644
--- a/libs/core/src/main/java/org/opensearch/core/rest/RestStatus.java
+++ b/libs/core/src/main/java/org/opensearch/core/rest/RestStatus.java
@@ -32,6 +32,8 @@
 
 package org.opensearch.core.rest;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
 import org.opensearch.core.action.ShardOperationFailedException;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
@@ -533,6 +535,14 @@ public static void writeTo(StreamOutput out, RestStatus status) throws IOExcepti
         out.writeString(status.name());
     }
 
+    public static RestStatus readFromProtobuf(CodedInputStream in) throws IOException {
+        return RestStatus.valueOf(in.readString());
+    }
+
+    public static void writeToProtobuf(CodedOutputStream out, RestStatus status) throws IOException {
+        out.writeStringNoTag(status.name());
+    }
+
     public static RestStatus status(int successfulShards, int totalShards, ShardOperationFailedException... failures) {
         if (failures.length == 0) {
             if (successfulShards == 0 && totalShards > 0) {
diff --git a/server/src/main/java/org/opensearch/ProtobufOpenSearchException.java b/server/src/main/java/org/opensearch/ProtobufOpenSearchException.java
index 30c9e8be2cfb6..572ae2efc6d47 100644
--- a/server/src/main/java/org/opensearch/ProtobufOpenSearchException.java
+++ b/server/src/main/java/org/opensearch/ProtobufOpenSearchException.java
@@ -10,36 +10,926 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.CheckedFunction;
+import org.opensearch.common.Nullable;
+import org.opensearch.core.ParseField;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.logging.LoggerMessageFormat;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParseException;
+import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.index.Index;
+import org.opensearch.index.shard.ShardId;
+import org.opensearch.rest.RestStatus;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import static java.util.Collections.emptyMap;
+import static java.util.Collections.singletonMap;
+import static java.util.Collections.unmodifiableMap;
+import static org.opensearch.cluster.metadata.IndexMetadata.INDEX_UUID_NA_VALUE;
+import static org.opensearch.common.xcontent.XContentParserUtils.ensureExpectedToken;
+import static org.opensearch.common.xcontent.XContentParserUtils.ensureFieldName;
 
 /**
- * Base exception for a failed node
+ * A base class for all opensearch exceptions.
 *
 * @opensearch.internal
 */
-public class ProtobufOpenSearchException extends RuntimeException implements ProtobufWriteable {
+public class ProtobufOpenSearchException extends RuntimeException implements ToXContentFragment, ProtobufWriteable {
+
+    private static final Version UNKNOWN_VERSION_ADDED = Version.fromId(0);
+
+    /**
+     * Setting a higher base exception id to avoid conflicts.
+    */
+    private static final int CUSTOM_ELASTICSEARCH_EXCEPTIONS_BASE_ID = 10000;
+
+    /**
+     * Passed in the {@link Params} of {@link #generateThrowableXContent(XContentBuilder, Params, Throwable)}
+    * to control if the {@code caused_by} element should render. Unlike most parameters to {@code toXContent} methods this parameter is
+    * internal only and not available as a URL parameter.
+    */
+    private static final String REST_EXCEPTION_SKIP_CAUSE = "rest.exception.cause.skip";
+    /**
+     * Passed in the {@link Params} of {@link #generateThrowableXContent(XContentBuilder, Params, Throwable)}
+    * to control if the {@code stack_trace} element should render. Unlike most parameters to {@code toXContent} methods this parameter is
+    * internal only and not available as a URL parameter. Use the {@code error_trace} parameter instead.
+    */
+    public static final String REST_EXCEPTION_SKIP_STACK_TRACE = "rest.exception.stacktrace.skip";
+    public static final boolean REST_EXCEPTION_SKIP_STACK_TRACE_DEFAULT = true;
+    private static final boolean REST_EXCEPTION_SKIP_CAUSE_DEFAULT = false;
+    private static final String INDEX_METADATA_KEY = "opensearch.index";
+    private static final String INDEX_METADATA_KEY_UUID = "opensearch.index_uuid";
+    private static final String SHARD_METADATA_KEY = "opensearch.shard";
+    private static final String RESOURCE_METADATA_TYPE_KEY = "opensearch.resource.type";
+    private static final String RESOURCE_METADATA_ID_KEY = "opensearch.resource.id";
+
+    private static final String TYPE = "type";
+    private static final String REASON = "reason";
+    private static final String CAUSED_BY = "caused_by";
+    private static final ParseField SUPPRESSED = new ParseField("suppressed");
+    public static final String STACK_TRACE = "stack_trace";
+    private static final String HEADER = "header";
+    private static final String ERROR = "error";
+    private static final String ROOT_CAUSE = "root_cause";
+
+    private static final Map<Integer, CheckedFunction<CodedInputStream, ? extends ProtobufOpenSearchException, IOException>> ID_TO_SUPPLIER;
+    private static final Map<Class<? extends ProtobufOpenSearchException>, OpenSearchExceptionHandle> CLASS_TO_OPENSEARCH_EXCEPTION_HANDLE;
+
+    private static final Pattern OS_METADATA = Pattern.compile("^opensearch\\.");
+
+    private final Map<String, List<String>> metadata = new HashMap<>();
+    private final Map<String, List<String>> headers = new HashMap<>();
 
-    private String message;
+    /**
+     * Construct a <code>ProtobufOpenSearchException</code> with the specified cause exception.
+    */
+    public ProtobufOpenSearchException(Throwable cause) {
+        super(cause);
+    }
+
+    /**
+     * Construct a <code>ProtobufOpenSearchException</code> with the specified detail message.
+    *
+    * The message can be parameterized using <code>{}</code> as placeholders for the given
+    * arguments
+    *
+    * @param msg  the detail message
+    * @param args the arguments for the message
+    */
+    public ProtobufOpenSearchException(String msg, Object... args) {
+        super(LoggerMessageFormat.format(msg, args));
+    }
 
-    public ProtobufOpenSearchException(String message) {
-        super(message);
-        this.message = message;
+    /**
+     * Construct a <code>ProtobufOpenSearchException</code> with the specified detail message
+    * and nested exception.
+    *
+    * The message can be parameterized using <code>{}</code> as placeholders for the given
+    * arguments
+    *
+    * @param msg   the detail message
+    * @param cause the nested exception
+    * @param args  the arguments for the message
+    */
+    public ProtobufOpenSearchException(String msg, Throwable cause, Object... args) {
+        super(LoggerMessageFormat.format(msg, args), cause);
     }
 
     public ProtobufOpenSearchException(CodedInputStream in) throws IOException {
-        super(in.readString());
-        this.message = in.readString();
+        super(new ProtobufStreamInput(in).readOptionalString(), new ProtobufStreamInput(in).readException());
+        readStackTrace(this, in);
+        // headers.putAll(in.readMapOfLists(StreamInput::readString, StreamInput::readString));
+        // metadata.putAll(in.readMapOfLists(StreamInput::readString, StreamInput::readString));
+    }
+
+    /**
+     * Adds a new piece of metadata with the given key.
+    * If the provided key is already present, the corresponding metadata will be replaced
+    */
+    public void addMetadata(String key, String... values) {
+        addMetadata(key, Arrays.asList(values));
+    }
+
+    /**
+     * Adds a new piece of metadata with the given key.
+    * If the provided key is already present, the corresponding metadata will be replaced
+    */
+    public void addMetadata(String key, List<String> values) {
+        // we need to enforce this otherwise bw comp doesn't work properly, as "opensearch."
+        // was the previous criteria to split headers in two sets
+        if (key.startsWith("opensearch.") == false) {
+            throw new IllegalArgumentException("exception metadata must start with [opensearch.], found [" + key + "] instead");
+        }
+        this.metadata.put(key, values);
+    }
+
+    /**
+     * Returns a set of all metadata keys on this exception
+    */
+    public Set<String> getMetadataKeys() {
+        return metadata.keySet();
+    }
+
+    /**
+     * Returns the list of metadata values for the given key or {@code null} if no metadata for the
+    * given key exists.
+    */
+    public List<String> getMetadata(String key) {
+        return metadata.get(key);
+    }
+
+    protected Map<String, List<String>> getMetadata() {
+        return metadata;
+    }
+
+    /**
+     * Adds a new header with the given key.
+    * This method will replace existing header if a header with the same key already exists
+    */
+    public void addHeader(String key, List<String> value) {
+        // we need to enforce this otherwise bw comp doesn't work properly, as "opensearch."
+        // was the previous criteria to split headers in two sets
+        if (key.startsWith("opensearch.")) {
+            throw new IllegalArgumentException("exception headers must not start with [opensearch.], found [" + key + "] instead");
+        }
+        this.headers.put(key, value);
+    }
+
+    /**
+     * Adds a new header with the given key.
+    * This method will replace existing header if a header with the same key already exists
+    */
+    public void addHeader(String key, String... value) {
+        addHeader(key, Arrays.asList(value));
+    }
+
+    /**
+     * Returns a set of all header keys on this exception
+    */
+    public Set<String> getHeaderKeys() {
+        return headers.keySet();
+    }
+
+    /**
+     * Returns the list of header values for the given key or {@code null} if no header for the
+    * given key exists.
+    */
+    public List<String> getHeader(String key) {
+        return headers.get(key);
+    }
+
+    protected Map<String, List<String>> getHeaders() {
+        return headers;
+    }
+
+    /**
+     * Returns the rest status code associated with this exception.
+    */
+    public RestStatus status() {
+        Throwable cause = unwrapCause();
+        if (cause == this) {
+            return RestStatus.INTERNAL_SERVER_ERROR;
+        } else {
+            return ExceptionsHelper.status(cause);
+        }
+    }
+
+    /**
+     * Unwraps the actual cause from the exception for cases when the exception is a
+    * {@link OpenSearchWrapperException}.
+    *
+    * @see ExceptionsHelper#unwrapCause(Throwable)
+    */
+    public Throwable unwrapCause() {
+        return ExceptionsHelper.unwrapCause(this);
+    }
+
+    /**
+     * Return the detail message, including the message from the nested exception
+    * if there is one.
+    */
+    public String getDetailedMessage() {
+        if (getCause() != null) {
+            StringBuilder sb = new StringBuilder();
+            sb.append(toString()).append("; ");
+            if (getCause() instanceof ProtobufOpenSearchException) {
+                sb.append(((ProtobufOpenSearchException) getCause()).getDetailedMessage());
+            } else {
+                sb.append(getCause());
+            }
+            return sb.toString();
+        } else {
+            return super.toString();
+        }
+    }
+
+    /**
+     * Retrieve the innermost cause of this exception, if none, returns the current exception.
+    */
+    public Throwable getRootCause() {
+        Throwable rootCause = this;
+        Throwable cause = getCause();
+        while (cause != null && cause != rootCause) {
+            rootCause = cause;
+            cause = cause.getCause();
+        }
+        return rootCause;
     }
 
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeStringNoTag(this.getMessage());
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeOptionalString(this.getMessage());
+        protobufStreamOutput.writeException(this.getCause());
+        writeStackTraces(this, out, protobufStreamOutput);
+        // out.writeMapOfLists(headers, StreamOutput::writeString, StreamOutput::writeString);
+        // out.writeMapOfLists(metadata, StreamOutput::writeString, StreamOutput::writeString);
+    }
+
+    public static ProtobufOpenSearchException readException(CodedInputStream input, int id) throws IOException {
+        CheckedFunction<CodedInputStream, ? extends ProtobufOpenSearchException, IOException> opensearchException = ID_TO_SUPPLIER.get(id);
+        if (opensearchException == null) {
+            throw new IllegalStateException("unknown exception for id: " + id);
+        }
+        return opensearchException.apply(input);
+    }
+
+    /**
+     * Returns <code>true</code> iff the given class is a registered for an exception to be read.
+    */
+    public static boolean isRegistered(Class<? extends Throwable> exception, Version version) {
+        OpenSearchExceptionHandle openSearchExceptionHandle = CLASS_TO_OPENSEARCH_EXCEPTION_HANDLE.get(exception);
+        if (openSearchExceptionHandle != null) {
+            return version.onOrAfter(openSearchExceptionHandle.versionAdded);
+        }
+        return false;
+    }
+
+    static Set<Class<? extends ProtobufOpenSearchException>> getRegisteredKeys() { // for testing
+        return CLASS_TO_OPENSEARCH_EXCEPTION_HANDLE.keySet();
+    }
+
+    /**
+     * Returns the serialization id the given exception.
+    */
+    public static int getId(Class<? extends ProtobufOpenSearchException> exception) {
+        return CLASS_TO_OPENSEARCH_EXCEPTION_HANDLE.get(exception).id;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        Throwable ex = ExceptionsHelper.unwrapCause(this);
+        if (ex != this) {
+            generateThrowableXContent(builder, params, this);
+        } else {
+            innerToXContent(builder, params, this, getExceptionName(), getMessage(), headers, metadata, getCause());
+        }
+        return builder;
+    }
+
+    protected static void innerToXContent(
+        XContentBuilder builder,
+        Params params,
+        Throwable throwable,
+        String type,
+        String message,
+        Map<String, List<String>> headers,
+        Map<String, List<String>> metadata,
+        Throwable cause
+    ) throws IOException {
+        builder.field(TYPE, type);
+        builder.field(REASON, message);
+
+        for (Map.Entry<String, List<String>> entry : metadata.entrySet()) {
+            headerToXContent(builder, entry.getKey().substring("opensearch.".length()), entry.getValue());
+        }
+
+        if (throwable instanceof ProtobufOpenSearchException) {
+            ProtobufOpenSearchException exception = (ProtobufOpenSearchException) throwable;
+            exception.metadataToXContent(builder, params);
+        }
+
+        if (params.paramAsBoolean(REST_EXCEPTION_SKIP_CAUSE, REST_EXCEPTION_SKIP_CAUSE_DEFAULT) == false) {
+            if (cause != null) {
+                builder.field(CAUSED_BY);
+                builder.startObject();
+                generateThrowableXContent(builder, params, cause);
+                builder.endObject();
+            }
+        }
+
+        if (headers.isEmpty() == false) {
+            builder.startObject(HEADER);
+            for (Map.Entry<String, List<String>> entry : headers.entrySet()) {
+                headerToXContent(builder, entry.getKey(), entry.getValue());
+            }
+            builder.endObject();
+        }
+
+        if (params.paramAsBoolean(REST_EXCEPTION_SKIP_STACK_TRACE, REST_EXCEPTION_SKIP_STACK_TRACE_DEFAULT) == false) {
+            builder.field(STACK_TRACE, ExceptionsHelper.stackTrace(throwable));
+        }
+
+        Throwable[] allSuppressed = throwable.getSuppressed();
+        if (allSuppressed.length > 0) {
+            builder.startArray(SUPPRESSED.getPreferredName());
+            for (Throwable suppressed : allSuppressed) {
+                builder.startObject();
+                generateThrowableXContent(builder, params, suppressed);
+                builder.endObject();
+            }
+            builder.endArray();
+        }
+    }
+
+    private static void headerToXContent(XContentBuilder builder, String key, List<String> values) throws IOException {
+        if (values != null && values.isEmpty() == false) {
+            if (values.size() == 1) {
+                builder.field(key, values.get(0));
+            } else {
+                builder.startArray(key);
+                for (String value : values) {
+                    builder.value(value);
+                }
+                builder.endArray();
+            }
+        }
+    }
+
+    /**
+     * Renders additional per exception information into the XContent
+    */
+    protected void metadataToXContent(XContentBuilder builder, Params params) throws IOException {}
+
+    /**
+     * Generate a {@link ProtobufOpenSearchException} from a {@link XContentParser}. This does not
+    * return the original exception type (ie NodeClosedException for example) but just wraps
+    * the type, the reason and the cause of the exception. It also recursively parses the
+    * tree structure of the cause, returning it as a tree structure of {@link ProtobufOpenSearchException}
+    * instances.
+    */
+    public static ProtobufOpenSearchException fromXContent(XContentParser parser) throws IOException {
+        XContentParser.Token token = parser.nextToken();
+        ensureExpectedToken(XContentParser.Token.FIELD_NAME, token, parser);
+        return innerFromXContent(parser, false);
+    }
+
+    public static ProtobufOpenSearchException innerFromXContent(XContentParser parser, boolean parseRootCauses) throws IOException {
+        XContentParser.Token token = parser.currentToken();
+        ensureExpectedToken(XContentParser.Token.FIELD_NAME, token, parser);
+
+        String type = null, reason = null, stack = null;
+        ProtobufOpenSearchException cause = null;
+        Map<String, List<String>> metadata = new HashMap<>();
+        Map<String, List<String>> headers = new HashMap<>();
+        List<ProtobufOpenSearchException> rootCauses = new ArrayList<>();
+        List<ProtobufOpenSearchException> suppressed = new ArrayList<>();
+
+        for (; token == XContentParser.Token.FIELD_NAME; token = parser.nextToken()) {
+            String currentFieldName = parser.currentName();
+            token = parser.nextToken();
+
+            if (token.isValue()) {
+                if (TYPE.equals(currentFieldName)) {
+                    type = parser.text();
+                } else if (REASON.equals(currentFieldName)) {
+                    reason = parser.text();
+                } else if (STACK_TRACE.equals(currentFieldName)) {
+                    stack = parser.text();
+                } else if (token == XContentParser.Token.VALUE_STRING) {
+                    metadata.put(currentFieldName, Collections.singletonList(parser.text()));
+                }
+            } else if (token == XContentParser.Token.START_OBJECT) {
+                if (CAUSED_BY.equals(currentFieldName)) {
+                    cause = fromXContent(parser);
+                } else if (HEADER.equals(currentFieldName)) {
+                    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
+                        if (token == XContentParser.Token.FIELD_NAME) {
+                            currentFieldName = parser.currentName();
+                        } else {
+                            List<String> values = headers.getOrDefault(currentFieldName, new ArrayList<>());
+                            if (token == XContentParser.Token.VALUE_STRING) {
+                                values.add(parser.text());
+                            } else if (token == XContentParser.Token.START_ARRAY) {
+                                while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
+                                    if (token == XContentParser.Token.VALUE_STRING) {
+                                        values.add(parser.text());
+                                    } else {
+                                        parser.skipChildren();
+                                    }
+                                }
+                            } else if (token == XContentParser.Token.START_OBJECT) {
+                                parser.skipChildren();
+                            }
+                            headers.put(currentFieldName, values);
+                        }
+                    }
+                } else {
+                    // Any additional metadata object added by the metadataToXContent method is ignored
+                    // and skipped, so that the parser does not fail on unknown fields. The parser only
+                    // support metadata key-pairs and metadata arrays of values.
+                    parser.skipChildren();
+                }
+            } else if (token == XContentParser.Token.START_ARRAY) {
+                if (parseRootCauses && ROOT_CAUSE.equals(currentFieldName)) {
+                    while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
+                        rootCauses.add(fromXContent(parser));
+                    }
+                } else if (SUPPRESSED.match(currentFieldName, parser.getDeprecationHandler())) {
+                    while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
+                        suppressed.add(fromXContent(parser));
+                    }
+                } else {
+                    // Parse the array and add each item to the corresponding list of metadata.
+                    // Arrays of objects are not supported yet and just ignored and skipped.
+                    List<String> values = new ArrayList<>();
+                    while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
+                        if (token == XContentParser.Token.VALUE_STRING) {
+                            values.add(parser.text());
+                        } else {
+                            parser.skipChildren();
+                        }
+                    }
+                    if (values.size() > 0) {
+                        if (metadata.containsKey(currentFieldName)) {
+                            values.addAll(metadata.get(currentFieldName));
+                        }
+                        metadata.put(currentFieldName, values);
+                    }
+                }
+            }
+        }
+
+        ProtobufOpenSearchException e = new ProtobufOpenSearchException(buildMessage(type, reason, stack), cause);
+        for (Map.Entry<String, List<String>> entry : metadata.entrySet()) {
+            // subclasses can print out additional metadata through the metadataToXContent method. Simple key-value pairs will be
+            // parsed back and become part of this metadata set, while objects and arrays are not supported when parsing back.
+            // Those key-value pairs become part of the metadata set and inherit the "opensearch." prefix as that is currently required
+            // by addMetadata. The prefix will get stripped out when printing metadata out so it will be effectively invisible.
+            // TODO move subclasses that print out simple metadata to using addMetadata directly and support also numbers and booleans.
+            // TODO rename metadataToXContent and have only SearchPhaseExecutionException use it, which prints out complex objects
+            e.addMetadata("opensearch." + entry.getKey(), entry.getValue());
+        }
+        for (Map.Entry<String, List<String>> header : headers.entrySet()) {
+            e.addHeader(header.getKey(), header.getValue());
+        }
+
+        // Adds root causes as suppressed exception. This way they are not lost
+        // after parsing and can be retrieved using getSuppressed() method.
+        for (ProtobufOpenSearchException rootCause : rootCauses) {
+            e.addSuppressed(rootCause);
+        }
+        for (ProtobufOpenSearchException s : suppressed) {
+            e.addSuppressed(s);
+        }
+        return e;
+    }
+
+    /**
+     * Static toXContent helper method that renders {@link ProtobufOpenSearchException} or {@link Throwable} instances
+    * as XContent, delegating the rendering to {@link #toXContent(XContentBuilder, Params)}
+    * or {@link #innerToXContent(XContentBuilder, Params, Throwable, String, String, Map, Map, Throwable)}.
+    *
+    * This method is usually used when the {@link Throwable} is rendered as a part of another XContent object, and its result can
+    * be parsed back using the {@link #fromXContent(XContentParser)} method.
+    */
+    public static void generateThrowableXContent(XContentBuilder builder, Params params, Throwable t) throws IOException {
+        t = ExceptionsHelper.unwrapCause(t);
+
+        if (t instanceof ProtobufOpenSearchException) {
+            ((ProtobufOpenSearchException) t).toXContent(builder, params);
+        } else {
+            innerToXContent(builder, params, t, getExceptionName(t), t.getMessage(), emptyMap(), emptyMap(), t.getCause());
+        }
+    }
+
+    /**
+     * Render any exception as a xcontent, encapsulated within a field or object named "error". The level of details that are rendered
+    * depends on the value of the "detailed" parameter: when it's false only a simple message based on the type and message of the
+    * exception is rendered. When it's true all detail are provided including guesses root causes, cause and potentially stack
+    * trace.
+    *
+    * This method is usually used when the {@link Exception} is rendered as a full XContent object, and its output can be parsed
+    * by the {@link #failureFromXContent(XContentParser)} method.
+    */
+    public static void generateFailureXContent(XContentBuilder builder, Params params, @Nullable Exception e, boolean detailed)
+        throws IOException {
+        // No exception to render as an error
+        if (e == null) {
+            builder.field(ERROR, "unknown");
+            return;
+        }
+
+        // Render the exception with a simple message
+        if (detailed == false) {
+            Throwable t = e;
+            for (int counter = 0; counter < 10 && t != null; counter++) {
+                if (t instanceof ProtobufOpenSearchException) {
+                    break;
+                }
+                t = t.getCause();
+            }
+            builder.field(ERROR, ExceptionsHelper.summaryMessage(t != null ? t : e));
+            return;
+        }
+
+        // Render the exception with all details
+        final ProtobufOpenSearchException[] rootCauses = ProtobufOpenSearchException.guessRootCauses(e);
+        builder.startObject(ERROR);
+        {
+            builder.startArray(ROOT_CAUSE);
+            for (ProtobufOpenSearchException rootCause : rootCauses) {
+                builder.startObject();
+                rootCause.toXContent(builder, new DelegatingMapParams(singletonMap(REST_EXCEPTION_SKIP_CAUSE, "true"), params));
+                builder.endObject();
+            }
+            builder.endArray();
+        }
+        generateThrowableXContent(builder, params, e);
+        builder.endObject();
+    }
+
+    /**
+     * Parses the output of {@link #generateFailureXContent(XContentBuilder, Params, Exception, boolean)}
+    */
+    public static ProtobufOpenSearchException failureFromXContent(XContentParser parser) throws IOException {
+        XContentParser.Token token = parser.currentToken();
+        ensureFieldName(parser, token, ERROR);
+
+        token = parser.nextToken();
+        if (token.isValue()) {
+            return new ProtobufOpenSearchException(buildMessage("exception", parser.text(), null));
+        }
+
+        ensureExpectedToken(XContentParser.Token.START_OBJECT, token, parser);
+        token = parser.nextToken();
+
+        // Root causes are parsed in the innerFromXContent() and are added as suppressed exceptions.
+        return innerFromXContent(parser, true);
+    }
+
+    /**
+     * Returns the root cause of this exception or multiple if different shards caused different exceptions
+    */
+    public ProtobufOpenSearchException[] guessRootCauses() {
+        final Throwable cause = getCause();
+        if (cause != null && cause instanceof ProtobufOpenSearchException) {
+            return ((ProtobufOpenSearchException) cause).guessRootCauses();
+        }
+        return new ProtobufOpenSearchException[] { this };
+    }
+
+    /**
+     * Returns the root cause of this exception or multiple if different shards caused different exceptions.
+    * If the given exception is not an instance of {@link ProtobufOpenSearchException} an empty array
+    * is returned.
+    */
+    public static ProtobufOpenSearchException[] guessRootCauses(Throwable t) {
+        Throwable ex = ExceptionsHelper.unwrapCause(t);
+        if (ex instanceof ProtobufOpenSearchException) {
+            // ProtobufOpenSearchException knows how to guess its own root cause
+            return ((ProtobufOpenSearchException) ex).guessRootCauses();
+        }
+        if (ex instanceof XContentParseException) {
+            /*
+            * We'd like to unwrap parsing exceptions to the inner-most
+            * parsing exception because that is generally the most interesting
+            * exception to return to the user. If that exception is caused by
+            * an ProtobufOpenSearchException we'd like to keep unwrapping because
+            * ProtobufOpenSearchException instances tend to contain useful information
+            * for the user.
+            */
+            Throwable cause = ex.getCause();
+            if (cause != null) {
+                if (cause instanceof XContentParseException || cause instanceof ProtobufOpenSearchException) {
+                    return guessRootCauses(ex.getCause());
+                }
+            }
+        }
+        return new ProtobufOpenSearchException[] { new ProtobufOpenSearchException(ex.getMessage(), ex) {
+            @Override
+            protected String getExceptionName() {
+                return getExceptionName(getCause());
+            }
+        } };
+    }
+
+    protected String getExceptionName() {
+        return getExceptionName(this);
+    }
+
+    /**
+     * Returns an underscore case name for the given exception. This method strips {@code OpenSearch} prefixes from exception names.
+    */
+    public static String getExceptionName(Throwable ex) {
+        String simpleName = ex.getClass().getSimpleName();
+        if (simpleName.startsWith("OpenSearch")) {
+            simpleName = simpleName.substring("OpenSearch".length());
+        }
+        // TODO: do we really need to make the exception name in underscore casing?
+        return toUnderscoreCase(simpleName);
+    }
+
+    static String buildMessage(String type, String reason, String stack) {
+        StringBuilder message = new StringBuilder("OpenSearch exception [");
+        message.append(TYPE).append('=').append(type).append(", ");
+        message.append(REASON).append('=').append(reason);
+        if (stack != null) {
+            message.append(", ").append(STACK_TRACE).append('=').append(stack);
+        }
+        message.append(']');
+        return message.toString();
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder();
+        if (metadata.containsKey(INDEX_METADATA_KEY)) {
+            builder.append(getIndex());
+            if (metadata.containsKey(SHARD_METADATA_KEY)) {
+                builder.append('[').append(getShardId()).append(']');
+            }
+            builder.append(' ');
+        }
+        return builder.append(ExceptionsHelper.detailedMessage(this).trim()).toString();
+    }
+
+    /**
+     * Deserializes stacktrace elements as well as suppressed exceptions from the given output stream and
+    * adds it to the given exception.
+    */
+    public static <T extends Throwable> T readStackTrace(T throwable, CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        throwable.setStackTrace(protobufStreamInput.readArray(i -> {
+            final String declaringClasss = i.readString();
+            final String fileName = protobufStreamInput.readOptionalString();
+            final String methodName = i.readString();
+            final int lineNumber = i.readInt32();
+            return new StackTraceElement(declaringClasss, methodName, fileName, lineNumber);
+        }, StackTraceElement[]::new));
+
+        int numSuppressed = protobufStreamInput.readVInt();
+        for (int i = 0; i < numSuppressed; i++) {
+            throwable.addSuppressed(protobufStreamInput.readException());
+        }
+        return throwable;
+    }
+
+    /**
+     * Serializes the given exceptions stacktrace elements as well as it's suppressed exceptions to the given output stream.
+    */
+    public static <T extends Throwable> T writeStackTraces(T throwable, CodedOutputStream out, ProtobufStreamOutput protobufStreamOutput)
+        throws IOException {
+        protobufStreamOutput.writeArray((o, v) -> {
+            o.writeStringNoTag(v.getClassName());
+            protobufStreamOutput.writeOptionalString(v.getFileName());
+            o.writeStringNoTag(v.getMethodName());
+            o.writeInt32NoTag(v.getLineNumber());
+        }, throwable.getStackTrace());
+        protobufStreamOutput.writeArray((o, v) -> { o.writeStringNoTag(v.toString()); }, throwable.getSuppressed());
+        return throwable;
+    }
+
+    /**
+     * This is the list of Exceptions OpenSearch can throw over the wire or save into a corruption marker. Each value in the enum is a
+    * single exception tying the Class to an id for use of the encode side and the id back to a constructor for use on the decode side. As
+    * such its ok if the exceptions to change names so long as their constructor can still read the exception. Each exception is listed
+    * in id order below. If you want to remove an exception leave a tombstone comment and mark the id as null in
+    * ExceptionSerializationTests.testIds.ids.
+    */
+    private enum OpenSearchExceptionHandle {
+        NODE_CLOSED_EXCEPTION(
+            org.opensearch.node.ProtobufNodeClosedException.class,
+            org.opensearch.node.ProtobufNodeClosedException::new,
+            9,
+            UNKNOWN_VERSION_ADDED
+        ),
+        CONNECT_TRANSPORT_EXCEPTION(
+            org.opensearch.transport.ProtobufConnectTransportException.class,
+            org.opensearch.transport.ProtobufConnectTransportException::new,
+            12,
+            UNKNOWN_VERSION_ADDED
+        ),
+        ACTION_TRANSPORT_EXCEPTION(
+            org.opensearch.transport.ProtobufActionTransportException.class,
+            org.opensearch.transport.ProtobufActionTransportException::new,
+            20,
+            UNKNOWN_VERSION_ADDED
+        ),
+        TRANSPORT_EXCEPTION(
+            org.opensearch.transport.ProtobufTransportException.class,
+            org.opensearch.transport.ProtobufTransportException::new,
+            34,
+            UNKNOWN_VERSION_ADDED
+        ),
+        FAILED_NODE_EXCEPTION(
+            org.opensearch.action.ProtobufFailedNodeException.class,
+            org.opensearch.action.ProtobufFailedNodeException::new,
+            71,
+            UNKNOWN_VERSION_ADDED
+        ),
+        RECEIVE_TIMEOUT_TRANSPORT_EXCEPTION(
+            org.opensearch.transport.ProtobufReceiveTimeoutTransportException.class,
+            org.opensearch.transport.ProtobufReceiveTimeoutTransportException::new,
+            83,
+            UNKNOWN_VERSION_ADDED
+        ),
+        NODE_DISCONNECTED_EXCEPTION(
+            org.opensearch.transport.ProtobufNodeDisconnectedException.class,
+            org.opensearch.transport.ProtobufNodeDisconnectedException::new,
+            84,
+            UNKNOWN_VERSION_ADDED
+        ),
+        REMOTE_TRANSPORT_EXCEPTION(
+            org.opensearch.transport.ProtobufRemoteTransportException.class,
+            org.opensearch.transport.ProtobufRemoteTransportException::new,
+            103,
+            UNKNOWN_VERSION_ADDED
+        ),
+        NODE_NOT_CONNECTED_EXCEPTION(
+            org.opensearch.transport.ProtobufNodeNotConnectedException.class,
+            org.opensearch.transport.ProtobufNodeNotConnectedException::new,
+            134,
+            UNKNOWN_VERSION_ADDED
+        );
+
+        final Class<? extends ProtobufOpenSearchException> exceptionClass;
+        final CheckedFunction<CodedInputStream, ? extends ProtobufOpenSearchException, IOException> constructor;
+        final int id;
+        final Version versionAdded;
+
+        <E extends ProtobufOpenSearchException> OpenSearchExceptionHandle(
+            Class<E> exceptionClass,
+            CheckedFunction<CodedInputStream, E, IOException> constructor,
+            int id,
+            Version versionAdded
+        ) {
+            // We need the exceptionClass because you can't dig it out of the constructor reliably.
+            this.exceptionClass = exceptionClass;
+            this.constructor = constructor;
+            this.versionAdded = versionAdded;
+            this.id = id;
+        }
+    }
+
+    /**
+     * Returns an array of all registered handle IDs. These are the IDs for every registered
+    * exception.
+    *
+    * @return an array of all registered handle IDs
+    */
+    static int[] ids() {
+        return Arrays.stream(OpenSearchExceptionHandle.values()).mapToInt(h -> h.id).toArray();
+    }
+
+    /**
+     * Returns an array of all registered pairs of handle IDs and exception classes. These pairs are
+    * provided for every registered exception.
+    *
+    * @return an array of all registered pairs of handle IDs and exception classes
+    */
+    static Tuple<Integer, Class<? extends ProtobufOpenSearchException>>[] classes() {
+        @SuppressWarnings("unchecked")
+        final Tuple<Integer, Class<? extends ProtobufOpenSearchException>>[] ts = Arrays.stream(OpenSearchExceptionHandle.values())
+            .map(h -> Tuple.tuple(h.id, h.exceptionClass))
+            .toArray(Tuple[]::new);
+        return ts;
+    }
+
+    static {
+        ID_TO_SUPPLIER = unmodifiableMap(
+            Arrays.stream(OpenSearchExceptionHandle.values()).collect(Collectors.toMap(e -> e.id, e -> e.constructor))
+        );
+        CLASS_TO_OPENSEARCH_EXCEPTION_HANDLE = unmodifiableMap(
+            Arrays.stream(OpenSearchExceptionHandle.values()).collect(Collectors.toMap(e -> e.exceptionClass, e -> e))
+        );
+    }
+
+    public Index getIndex() {
+        List<String> index = getMetadata(INDEX_METADATA_KEY);
+        if (index != null && index.isEmpty() == false) {
+            List<String> index_uuid = getMetadata(INDEX_METADATA_KEY_UUID);
+            return new Index(index.get(0), index_uuid.get(0));
+        }
+
+        return null;
+    }
+
+    public ShardId getShardId() {
+        List<String> shard = getMetadata(SHARD_METADATA_KEY);
+        if (shard != null && shard.isEmpty() == false) {
+            return new ShardId(getIndex(), Integer.parseInt(shard.get(0)));
+        }
+        return null;
+    }
+
+    public void setIndex(Index index) {
+        if (index != null) {
+            addMetadata(INDEX_METADATA_KEY, index.getName());
+            addMetadata(INDEX_METADATA_KEY_UUID, index.getUUID());
+        }
+    }
+
+    public void setIndex(String index) {
+        if (index != null) {
+            setIndex(new Index(index, INDEX_UUID_NA_VALUE));
+        }
+    }
+
+    public void setShard(ShardId shardId) {
+        if (shardId != null) {
+            setIndex(shardId.getIndex());
+            addMetadata(SHARD_METADATA_KEY, Integer.toString(shardId.id()));
+        }
+    }
+
+    public void setResources(String type, String... id) {
+        assert type != null;
+        addMetadata(RESOURCE_METADATA_ID_KEY, id);
+        addMetadata(RESOURCE_METADATA_TYPE_KEY, type);
+    }
+
+    public List<String> getResourceId() {
+        return getMetadata(RESOURCE_METADATA_ID_KEY);
+    }
+
+    public String getResourceType() {
+        List<String> header = getMetadata(RESOURCE_METADATA_TYPE_KEY);
+        if (header != null && header.isEmpty() == false) {
+            assert header.size() == 1;
+            return header.get(0);
+        }
+        return null;
     }
 
-    public String getMessage() {
-        return this.message;
+    // lower cases and adds underscores to transitions in a name
+    private static String toUnderscoreCase(String value) {
+        StringBuilder sb = new StringBuilder();
+        boolean changed = false;
+        for (int i = 0; i < value.length(); i++) {
+            char c = value.charAt(i);
+            if (Character.isUpperCase(c)) {
+                if (!changed) {
+                    // copy it over here
+                    for (int j = 0; j < i; j++) {
+                        sb.append(value.charAt(j));
+                    }
+                    changed = true;
+                    if (i == 0) {
+                        sb.append(Character.toLowerCase(c));
+                    } else {
+                        sb.append('_');
+                        sb.append(Character.toLowerCase(c));
+                    }
+                } else {
+                    sb.append('_');
+                    sb.append(Character.toLowerCase(c));
+                }
+            } else {
+                if (changed) {
+                    sb.append(c);
+                }
+            }
+        }
+        if (!changed) {
+            return value;
+        }
+        return sb.toString();
     }
 
 }
diff --git a/server/src/main/java/org/opensearch/action/ActionModule.java b/server/src/main/java/org/opensearch/action/ActionModule.java
index b775095861150..0a6ba0dae57ca 100644
--- a/server/src/main/java/org/opensearch/action/ActionModule.java
+++ b/server/src/main/java/org/opensearch/action/ActionModule.java
@@ -274,6 +274,7 @@
 import org.opensearch.action.support.ActionFilters;
 import org.opensearch.action.support.AutoCreateIndex;
 import org.opensearch.action.support.DestructiveOperations;
+import org.opensearch.action.support.ProtobufTransportAction;
 import org.opensearch.action.support.TransportAction;
 import org.opensearch.action.termvectors.MultiTermVectorsAction;
 import org.opensearch.action.termvectors.TermVectorsAction;
@@ -1169,4 +1170,72 @@ public RestSendToExtensionAction get(RestHandler.Route route) {
             return routeRegistry.get(route);
         }
     }
+
+    /**
+     * The DynamicActionRegistry maintains a registry mapping {@link ActionType} instances to {@link TransportAction} instances.
+     * <p>
+     * This class is modeled after {@link NamedRegistry} but provides both register and unregister capabilities.
+     *
+     * @opensearch.internal
+     */
+    public static class ProtobufDynamicActionRegistry {
+        // This is the unmodifiable actions map created during node bootstrap, which
+        // will continue to link ActionType and TransportAction pairs from core and plugin
+        // action handler registration.
+        private Map<ProtobufActionType, ProtobufTransportAction> actions = Collections.emptyMap();
+        // A dynamic registry to add or remove ActionType / TransportAction pairs
+        // at times other than node bootstrap.
+        private final Map<ProtobufActionType<?>, ProtobufTransportAction<?, ?>> registry = new ConcurrentHashMap<>();
+
+        /**
+         * Register the immutable actions in the registry.
+         *
+         * @param actions The injected map of {@link ProtobufActionType} to {@link ProtobufTransportAction}
+         */
+        public void registerUnmodifiableActionMap(Map<ProtobufActionType, ProtobufTransportAction> actions) {
+            this.actions = actions;
+        }
+
+        /**
+         * Add a dynamic action to the registry.
+         *
+         * @param action The action instance to add
+         * @param transportAction The corresponding instance of transportAction to execute
+         */
+        public void registerDynamicAction(ProtobufActionType<?> action, ProtobufTransportAction<?, ?> transportAction) {
+            requireNonNull(action, "action is required");
+            requireNonNull(transportAction, "transportAction is required");
+            if (actions.containsKey(action) || registry.putIfAbsent(action, transportAction) != null) {
+                throw new IllegalArgumentException("action [" + action.name() + "] already registered");
+            }
+        }
+
+        /**
+         * Remove a dynamic action from the registry.
+         *
+         * @param action The action to remove
+         */
+        public void unregisterDynamicAction(ProtobufActionType<?> action) {
+            requireNonNull(action, "action is required");
+            if (registry.remove(action) == null) {
+                throw new IllegalArgumentException("action [" + action.name() + "] was not registered");
+            }
+        }
+
+        /**
+         * Gets the {@link ProtobufTransportAction} instance corresponding to the {@link ProtobufActionType} instance.
+         *
+         * @param action The {@link ProtobufActionType}.
+         * @return the corresponding {@link ProtobufTransportAction} if it is registered, null otherwise.
+         */
+        @SuppressWarnings("unchecked")
+        public ProtobufTransportAction<? extends ProtobufActionRequest, ? extends ProtobufActionResponse> get(
+            ProtobufActionType<?> action
+        ) {
+            if (actions.containsKey(action)) {
+                return actions.get(action);
+            }
+            return registry.get(action);
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java b/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
new file mode 100644
index 0000000000000..4bae1f6c3bb04
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
@@ -0,0 +1,73 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action;
+
+import com.google.protobuf.CodedInputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.transport.ProtobufTransportResponseHandler;
+import org.opensearch.transport.ProtobufTransportException;
+import org.opensearch.transport.ProtobufTransportResponse;
+
+import java.io.IOException;
+import java.util.Objects;
+
+/**
+ * A simple base class for action response listeners, defaulting to using the SAME executor (as its
+* very common on response handlers).
+*
+* @opensearch.api
+*/
+public class ProtobufActionListenerResponseHandler<Response extends ProtobufTransportResponse>
+    implements
+        ProtobufTransportResponseHandler<Response> {
+
+    private final ActionListener<? super Response> listener;
+    private final ProtobufWriteable.Reader<Response> reader;
+    private final String executor;
+
+    public ProtobufActionListenerResponseHandler(
+        ActionListener<? super Response> listener,
+        ProtobufWriteable.Reader<Response> reader,
+        String executor
+    ) {
+        this.listener = Objects.requireNonNull(listener);
+        this.reader = Objects.requireNonNull(reader);
+        this.executor = Objects.requireNonNull(executor);
+    }
+
+    public ProtobufActionListenerResponseHandler(ActionListener<? super Response> listener, ProtobufWriteable.Reader<Response> reader) {
+        this(listener, reader, ProtobufThreadPool.Names.SAME);
+    }
+
+    @Override
+    public void handleResponse(Response response) {
+        listener.onResponse(response);
+    }
+
+    @Override
+    public void handleException(ProtobufTransportException e) {
+        listener.onFailure(e);
+    }
+
+    @Override
+    public String executor() {
+        return executor;
+    }
+
+    @Override
+    public Response read(CodedInputStream in) throws IOException {
+        return reader.read(in);
+    }
+
+    @Override
+    public String toString() {
+        return super.toString() + "/" + listener;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionRequestBuilder.java b/server/src/main/java/org/opensearch/action/ProtobufActionRequestBuilder.java
index 33c0e46f5fc92..6c752e24c4f2c 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionRequestBuilder.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionRequestBuilder.java
@@ -8,7 +8,6 @@
 
 package org.opensearch.action;
 
-import org.opensearch.client.OpenSearchClient;
 import org.opensearch.client.ProtobufOpenSearchClient;
 import org.opensearch.common.unit.TimeValue;
 
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionType.java b/server/src/main/java/org/opensearch/action/ProtobufActionType.java
index 911419fb67677..c8fc92a3e9f35 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionType.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionType.java
@@ -9,7 +9,6 @@
 package org.opensearch.action;
 
 import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.io.stream.Writeable;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.transport.TransportRequestOptions;
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
index 0d1b03ae29d07..df059711196cd 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
@@ -66,7 +66,7 @@ public class ProtobufNodeInfo extends ProtobufBaseNodeResponse {
 
     public ProtobufNodeInfo(CodedInputStream in) throws IOException {
         super(in);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
         version = Version.readVersionProtobuf(in);
         build = Build.readBuildProtobuf(in);
         if (in.readBool()) {
@@ -77,20 +77,17 @@ public ProtobufNodeInfo(CodedInputStream in) throws IOException {
         if (in.readBool()) {
             settings = Settings.readSettingsFromStreamProtobuf(in);
         }
-        addInfoIfNonNull(ProtobufOsInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufOsInfo::new, in));
-        addInfoIfNonNull(ProtobufProcessInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufProcessInfo::new, in));
-        addInfoIfNonNull(ProtobufJvmInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufJvmInfo::new, in));
-        addInfoIfNonNull(ProtobufThreadPoolInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufThreadPoolInfo::new, in));
-        addInfoIfNonNull(ProtobufTransportInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufTransportInfo::new, in));
-        addInfoIfNonNull(ProtobufHttpInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufHttpInfo::new, in));
-        addInfoIfNonNull(ProtobufPluginsAndModules.class, protobufStreamInput.readOptionalWriteable(ProtobufPluginsAndModules::new, in));
-        addInfoIfNonNull(ProtobufIngestInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufIngestInfo::new, in));
-        addInfoIfNonNull(ProtobufAggregationInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufAggregationInfo::new, in));
+        addInfoIfNonNull(ProtobufOsInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufOsInfo::new));
+        addInfoIfNonNull(ProtobufProcessInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufProcessInfo::new));
+        addInfoIfNonNull(ProtobufJvmInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufJvmInfo::new));
+        addInfoIfNonNull(ProtobufThreadPoolInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufThreadPoolInfo::new));
+        addInfoIfNonNull(ProtobufTransportInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufTransportInfo::new));
+        addInfoIfNonNull(ProtobufHttpInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufHttpInfo::new));
+        addInfoIfNonNull(ProtobufPluginsAndModules.class, protobufStreamInput.readOptionalWriteable(ProtobufPluginsAndModules::new));
+        addInfoIfNonNull(ProtobufIngestInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufIngestInfo::new));
+        addInfoIfNonNull(ProtobufAggregationInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufAggregationInfo::new));
         if (protobufStreamInput.getVersion().onOrAfter(Version.V_2_7_0)) {
-            addInfoIfNonNull(
-                ProtobufSearchPipelineInfo.class,
-                protobufStreamInput.readOptionalWriteable(ProtobufSearchPipelineInfo::new, in)
-            );
+            addInfoIfNonNull(ProtobufSearchPipelineInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufSearchPipelineInfo::new));
         }
     }
 
@@ -190,7 +187,7 @@ private <T extends ProtobufReportingService.ProtobufInfo> void addInfoIfNonNull(
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
         super.writeTo(out);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         out.writeInt32NoTag(version.id);
         Build.writeBuildProtobuf(build, out);
         if (totalIndexingBuffer == null) {
@@ -205,17 +202,17 @@ public void writeTo(CodedOutputStream out) throws IOException {
             out.writeBoolNoTag(true);
             Settings.writeSettingsToStreamProtobuf(settings, out);
         }
-        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufOsInfo.class), out);
-        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufProcessInfo.class), out);
-        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufJvmInfo.class), out);
-        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufThreadPoolInfo.class), out);
-        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufTransportInfo.class), out);
-        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufHttpInfo.class), out);
-        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufPluginsAndModules.class), out);
-        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufIngestInfo.class), out);
-        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufAggregationInfo.class), out);
+        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufOsInfo.class));
+        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufProcessInfo.class));
+        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufJvmInfo.class));
+        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufThreadPoolInfo.class));
+        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufTransportInfo.class));
+        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufHttpInfo.class));
+        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufPluginsAndModules.class));
+        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufIngestInfo.class));
+        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufAggregationInfo.class));
         if (protobufStreamOutput.getVersion().onOrAfter(Version.V_2_7_0)) {
-            protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufSearchPipelineInfo.class), out);
+            protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufSearchPipelineInfo.class));
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoAction.java
new file mode 100644
index 0000000000000..7cb1201f2ccef
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoAction.java
@@ -0,0 +1,26 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.admin.cluster.node.info;
+
+import org.opensearch.action.ProtobufActionType;
+
+/**
+ * Transport action for OpenSearch Node Information
+*
+* @opensearch.internal
+*/
+public class ProtobufNodesInfoAction extends ProtobufActionType<ProtobufNodesInfoResponse> {
+
+    public static final ProtobufNodesInfoAction INSTANCE = new ProtobufNodesInfoAction();
+    public static final String NAME = "cluster:monitor/nodes/info";
+
+    private ProtobufNodesInfoAction() {
+        super(NAME, ProtobufNodesInfoResponse::new);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
index 04de76bb281fe..2fb3c3319822b 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
@@ -45,9 +45,9 @@ public class ProtobufNodesInfoRequest extends ProtobufBaseNodesRequest<ProtobufN
      */
     public ProtobufNodesInfoRequest(CodedInputStream in) throws IOException {
         super(in);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
         requestedMetrics.clear();
-        requestedMetrics.addAll(Arrays.asList(protobufStreamInput.readStringArray(in)));
+        requestedMetrics.addAll(Arrays.asList(protobufStreamInput.readStringArray()));
     }
 
     /**
@@ -121,8 +121,8 @@ public ProtobufNodesInfoRequest removeMetric(String metric) {
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
         super.writeTo(out);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
-        protobufStreamOutput.writeStringArray(requestedMetrics.toArray(new String[0]), out);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeStringArray(requestedMetrics.toArray(new String[0]));
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequestBuilder.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequestBuilder.java
new file mode 100644
index 0000000000000..e751bfe25c47f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequestBuilder.java
@@ -0,0 +1,65 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.admin.cluster.node.info;
+
+import org.opensearch.action.support.nodes.ProtobufNodesOperationRequestBuilder;
+import org.opensearch.client.ProtobufOpenSearchClient;
+
+/**
+ * Transport action for OpenSearch Node Information
+*
+* @opensearch.internal
+*/
+public class ProtobufNodesInfoRequestBuilder extends ProtobufNodesOperationRequestBuilder<
+    ProtobufNodesInfoRequest,
+    ProtobufNodesInfoResponse,
+    ProtobufNodesInfoRequestBuilder> {
+
+    public ProtobufNodesInfoRequestBuilder(ProtobufOpenSearchClient client, ProtobufNodesInfoAction action) {
+        super(client, action, new ProtobufNodesInfoRequest());
+    }
+
+    /**
+     * Clears all info flags.
+    */
+    public ProtobufNodesInfoRequestBuilder clear() {
+        request.clear();
+        return this;
+    }
+
+    /**
+     * Sets to return all the data.
+    */
+    public ProtobufNodesInfoRequestBuilder all() {
+        request.all();
+        return this;
+    }
+
+    /**
+     * Add a single metric to the request.
+    *
+    * @param metric Name of metric as a string.
+    * @return This, for request chaining.
+    */
+    public ProtobufNodesInfoRequestBuilder addMetric(String metric) {
+        request.addMetric(metric);
+        return this;
+    }
+
+    /**
+     * Add an array of metrics to the request.
+    *
+    * @param metrics Metric names as strings.
+    * @return This, for request chaining.
+    */
+    public ProtobufNodesInfoRequestBuilder addMetrics(String... metrics) {
+        request.addMetrics(metrics);
+        return this;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
index a7d5274fcf09a..2f82367e0c9e7 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
@@ -64,13 +64,13 @@ public ProtobufNodesInfoResponse(
 
     @Override
     protected List<ProtobufNodeInfo> readNodesFrom(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
-        return protobufStreamInput.readList(ProtobufNodeInfo::new, in);
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        return protobufStreamInput.readList(ProtobufNodeInfo::new);
     }
 
     @Override
     protected void writeNodesTo(CodedOutputStream out, List<ProtobufNodeInfo> nodes) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
-        protobufStreamOutput.writeCollection(nodes, (o, v) -> v.writeTo(o), out);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeCollection(nodes, (o, v) -> v.writeTo(o));
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufPluginsAndModules.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufPluginsAndModules.java
index 1df8383a78736..c1117c4321544 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufPluginsAndModules.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufPluginsAndModules.java
@@ -37,16 +37,16 @@ public ProtobufPluginsAndModules(List<ProtobufPluginInfo> plugins, List<Protobuf
     }
 
     public ProtobufPluginsAndModules(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
-        this.plugins = Collections.unmodifiableList(protobufStreamInput.readList(ProtobufPluginInfo::new, in));
-        this.modules = Collections.unmodifiableList(protobufStreamInput.readList(ProtobufPluginInfo::new, in));
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        this.plugins = Collections.unmodifiableList(protobufStreamInput.readList(ProtobufPluginInfo::new));
+        this.modules = Collections.unmodifiableList(protobufStreamInput.readList(ProtobufPluginInfo::new));
     }
 
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
-        protobufStreamOutput.writeCollection(plugins, (o, v) -> v.writeTo(o), out);
-        protobufStreamOutput.writeCollection(modules, (o, v) -> v.writeTo(o), out);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeCollection(plugins, (o, v) -> v.writeTo(o));
+        protobufStreamOutput.writeCollection(modules, (o, v) -> v.writeTo(o));
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
new file mode 100644
index 0000000000000..8a96eb41bb1b7
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
@@ -0,0 +1,322 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.admin.cluster.node.stats;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.action.support.nodes.ProtobufBaseNodeResponse;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.discovery.ProtobufDiscoveryStats;
+import org.opensearch.http.ProtobufHttpStats;
+import org.opensearch.indices.ProtobufNodeIndicesStats;
+import org.opensearch.indices.breaker.ProtobufAllCircuitBreakerStats;
+import org.opensearch.ingest.ProtobufIngestStats;
+import org.opensearch.monitor.fs.ProtobufFsInfo;
+import org.opensearch.monitor.jvm.ProtobufJvmStats;
+import org.opensearch.monitor.os.ProtobufOsStats;
+import org.opensearch.monitor.process.ProtobufProcessStats;
+import org.opensearch.node.ProtobufAdaptiveSelectionStats;
+import org.opensearch.script.ProtobufScriptStats;
+import org.opensearch.threadpool.ProtobufThreadPoolStats;
+import org.opensearch.transport.ProtobufTransportStats;
+
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * Node statistics (dynamic, changes depending on when created).
+*
+* @opensearch.internal
+*/
+public class ProtobufNodeStats extends ProtobufBaseNodeResponse implements ToXContentFragment {
+
+    private long timestamp;
+
+    @Nullable
+    private ProtobufNodeIndicesStats indices;
+
+    @Nullable
+    private ProtobufOsStats os;
+
+    @Nullable
+    private ProtobufProcessStats process;
+
+    @Nullable
+    private ProtobufJvmStats jvm;
+
+    @Nullable
+    private ProtobufThreadPoolStats threadPool;
+
+    @Nullable
+    private ProtobufFsInfo fs;
+
+    @Nullable
+    private ProtobufTransportStats transport;
+
+    @Nullable
+    private ProtobufHttpStats http;
+
+    @Nullable
+    private ProtobufAllCircuitBreakerStats breaker;
+
+    @Nullable
+    private ProtobufScriptStats scriptStats;
+
+    @Nullable
+    private ProtobufDiscoveryStats discoveryStats;
+
+    @Nullable
+    private ProtobufIngestStats ingestStats;
+
+    @Nullable
+    private ProtobufAdaptiveSelectionStats adaptiveSelectionStats;
+
+    public ProtobufNodeStats(CodedInputStream in) throws IOException {
+        super(in);
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        timestamp = in.readInt64();
+        if (in.readBool()) {
+            indices = new ProtobufNodeIndicesStats(in);
+        }
+        os = protobufStreamInput.readOptionalWriteable(ProtobufOsStats::new);
+        process = protobufStreamInput.readOptionalWriteable(ProtobufProcessStats::new);
+        jvm = protobufStreamInput.readOptionalWriteable(ProtobufJvmStats::new);
+        threadPool = protobufStreamInput.readOptionalWriteable(ProtobufThreadPoolStats::new);
+        fs = protobufStreamInput.readOptionalWriteable(ProtobufFsInfo::new);
+        transport = protobufStreamInput.readOptionalWriteable(ProtobufTransportStats::new);
+        http = protobufStreamInput.readOptionalWriteable(ProtobufHttpStats::new);
+        breaker = protobufStreamInput.readOptionalWriteable(ProtobufAllCircuitBreakerStats::new);
+        scriptStats = protobufStreamInput.readOptionalWriteable(ProtobufScriptStats::new);
+        discoveryStats = protobufStreamInput.readOptionalWriteable(ProtobufDiscoveryStats::new);
+        ingestStats = protobufStreamInput.readOptionalWriteable(ProtobufIngestStats::new);
+        adaptiveSelectionStats = protobufStreamInput.readOptionalWriteable(ProtobufAdaptiveSelectionStats::new);
+    }
+
+    public ProtobufNodeStats(
+        ProtobufDiscoveryNode node,
+        long timestamp,
+        @Nullable ProtobufNodeIndicesStats indices,
+        @Nullable ProtobufOsStats os,
+        @Nullable ProtobufProcessStats process,
+        @Nullable ProtobufJvmStats jvm,
+        @Nullable ProtobufThreadPoolStats threadPool,
+        @Nullable ProtobufFsInfo fs,
+        @Nullable ProtobufTransportStats transport,
+        @Nullable ProtobufHttpStats http,
+        @Nullable ProtobufAllCircuitBreakerStats breaker,
+        @Nullable ProtobufScriptStats scriptStats,
+        @Nullable ProtobufDiscoveryStats discoveryStats,
+        @Nullable ProtobufIngestStats ingestStats,
+        @Nullable ProtobufAdaptiveSelectionStats adaptiveSelectionStats
+    ) {
+        super(node);
+        this.timestamp = timestamp;
+        this.indices = indices;
+        this.os = os;
+        this.process = process;
+        this.jvm = jvm;
+        this.threadPool = threadPool;
+        this.fs = fs;
+        this.transport = transport;
+        this.http = http;
+        this.breaker = breaker;
+        this.scriptStats = scriptStats;
+        this.discoveryStats = discoveryStats;
+        this.ingestStats = ingestStats;
+        this.adaptiveSelectionStats = adaptiveSelectionStats;
+    }
+
+    public long getTimestamp() {
+        return this.timestamp;
+    }
+
+    @Nullable
+    public String getHostname() {
+        return getNode().getHostName();
+    }
+
+    /**
+     * Indices level stats.
+    */
+    @Nullable
+    public ProtobufNodeIndicesStats getIndices() {
+        return this.indices;
+    }
+
+    /**
+     * Operating System level statistics.
+    */
+    @Nullable
+    public ProtobufOsStats getOs() {
+        return this.os;
+    }
+
+    /**
+     * Process level statistics.
+    */
+    @Nullable
+    public ProtobufProcessStats getProcess() {
+        return process;
+    }
+
+    /**
+     * JVM level statistics.
+    */
+    @Nullable
+    public ProtobufJvmStats getJvm() {
+        return jvm;
+    }
+
+    /**
+     * Thread Pool level statistics.
+    */
+    @Nullable
+    public ProtobufThreadPoolStats getThreadPool() {
+        return this.threadPool;
+    }
+
+    /**
+     * File system level stats.
+    */
+    @Nullable
+    public ProtobufFsInfo getFs() {
+        return fs;
+    }
+
+    @Nullable
+    public ProtobufTransportStats getTransport() {
+        return this.transport;
+    }
+
+    @Nullable
+    public ProtobufHttpStats getHttp() {
+        return this.http;
+    }
+
+    @Nullable
+    public ProtobufAllCircuitBreakerStats getBreaker() {
+        return this.breaker;
+    }
+
+    @Nullable
+    public ProtobufScriptStats getScriptStats() {
+        return this.scriptStats;
+    }
+
+    @Nullable
+    public ProtobufDiscoveryStats getDiscoveryStats() {
+        return this.discoveryStats;
+    }
+
+    @Nullable
+    public ProtobufIngestStats getIngestStats() {
+        return ingestStats;
+    }
+
+    @Nullable
+    public ProtobufAdaptiveSelectionStats getAdaptiveSelectionStats() {
+        return adaptiveSelectionStats;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        super.writeTo(out);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        out.writeInt64NoTag(timestamp);
+        if (indices == null) {
+            out.writeBoolNoTag(false);
+        } else {
+            out.writeBoolNoTag(true);
+            indices.writeTo(out);
+        }
+        protobufStreamOutput.writeOptionalWriteable(os);
+        protobufStreamOutput.writeOptionalWriteable(process);
+        protobufStreamOutput.writeOptionalWriteable(jvm);
+        protobufStreamOutput.writeOptionalWriteable(threadPool);
+        protobufStreamOutput.writeOptionalWriteable(fs);
+        protobufStreamOutput.writeOptionalWriteable(transport);
+        protobufStreamOutput.writeOptionalWriteable(http);
+        protobufStreamOutput.writeOptionalWriteable(breaker);
+        protobufStreamOutput.writeOptionalWriteable(scriptStats);
+        protobufStreamOutput.writeOptionalWriteable(discoveryStats);
+        protobufStreamOutput.writeOptionalWriteable(ingestStats);
+        protobufStreamOutput.writeOptionalWriteable(adaptiveSelectionStats);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+
+        builder.field("name", getNode().getName());
+        builder.field("transport_address", getNode().getAddress().toString());
+        builder.field("host", getNode().getHostName());
+        builder.field("ip", getNode().getAddress());
+
+        builder.startArray("roles");
+        for (DiscoveryNodeRole role : getNode().getRoles()) {
+            builder.value(role.roleName());
+        }
+        builder.endArray();
+
+        if (!getNode().getAttributes().isEmpty()) {
+            builder.startObject("attributes");
+            for (Map.Entry<String, String> attrEntry : getNode().getAttributes().entrySet()) {
+                builder.field(attrEntry.getKey(), attrEntry.getValue());
+            }
+            builder.endObject();
+        }
+
+        if (getIndices() != null) {
+            getIndices().toXContent(builder, params);
+        }
+        if (getOs() != null) {
+            getOs().toXContent(builder, params);
+        }
+        if (getProcess() != null) {
+            getProcess().toXContent(builder, params);
+        }
+        if (getJvm() != null) {
+            getJvm().toXContent(builder, params);
+        }
+        if (getThreadPool() != null) {
+            getThreadPool().toXContent(builder, params);
+        }
+        if (getFs() != null) {
+            getFs().toXContent(builder, params);
+        }
+        if (getTransport() != null) {
+            getTransport().toXContent(builder, params);
+        }
+        if (getHttp() != null) {
+            getHttp().toXContent(builder, params);
+        }
+        if (getBreaker() != null) {
+            getBreaker().toXContent(builder, params);
+        }
+        if (getScriptStats() != null) {
+            getScriptStats().toXContent(builder, params);
+        }
+        if (getDiscoveryStats() != null) {
+            getDiscoveryStats().toXContent(builder, params);
+        }
+        if (getIngestStats() != null) {
+            getIngestStats().toXContent(builder, params);
+        }
+        if (getAdaptiveSelectionStats() != null) {
+            getAdaptiveSelectionStats().toXContent(builder, params);
+        }
+
+        return builder;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsAction.java
new file mode 100644
index 0000000000000..a03ee6119f0b2
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsAction.java
@@ -0,0 +1,26 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.admin.cluster.node.stats;
+
+import org.opensearch.action.ProtobufActionType;
+
+/**
+ * Transport action for obtaining OpenSearch Node Stats
+*
+* @opensearch.internal
+*/
+public class ProtobufNodesStatsAction extends ProtobufActionType<ProtobufNodesStatsResponse> {
+
+    public static final ProtobufNodesStatsAction INSTANCE = new ProtobufNodesStatsAction();
+    public static final String NAME = "cluster:monitor/nodes/stats";
+
+    private ProtobufNodesStatsAction() {
+        super(NAME, ProtobufNodesStatsResponse::new);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
index d55b511eb0170..c61deaf87c413 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
@@ -10,12 +10,10 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
-import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
 import org.opensearch.action.admin.indices.stats.ProtobufCommonStatsFlags;
-import org.opensearch.action.support.nodes.BaseNodesRequest;
 import org.opensearch.action.support.nodes.ProtobufBaseNodesRequest;
-import org.opensearch.common.io.stream.StreamInput;
-import org.opensearch.common.io.stream.StreamOutput;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.HashSet;
@@ -43,7 +41,8 @@ public ProtobufNodesStatsRequest(CodedInputStream in) throws IOException {
 
         indices = new ProtobufCommonStatsFlags(in);
         requestedMetrics.clear();
-        requestedMetrics.addAll(in.readStringList());
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        requestedMetrics.addAll(protobufStreamInput.readList(CodedInputStream::readString));
     }
 
     /**
@@ -153,7 +152,8 @@ public ProtobufNodesStatsRequest removeMetric(String metric) {
     public void writeTo(CodedOutputStream out) throws IOException {
         super.writeTo(out);
         indices.writeTo(out);
-        out.writeStringArray(requestedMetrics.toArray(new String[0]));
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeStringArray(requestedMetrics.toArray(new String[0]));
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequestBuilder.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequestBuilder.java
new file mode 100644
index 0000000000000..3c6d14ad478d5
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequestBuilder.java
@@ -0,0 +1,82 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.admin.cluster.node.stats;
+
+import org.opensearch.action.admin.indices.stats.ProtobufCommonStatsFlags;
+import org.opensearch.action.support.nodes.ProtobufNodesOperationRequestBuilder;
+import org.opensearch.client.ProtobufOpenSearchClient;
+
+/**
+ * Transport builder for obtaining OpenSearch Node Stats
+*
+* @opensearch.internal
+*/
+public class ProtobufNodesStatsRequestBuilder extends ProtobufNodesOperationRequestBuilder<
+    ProtobufNodesStatsRequest,
+    ProtobufNodesStatsResponse,
+    ProtobufNodesStatsRequestBuilder> {
+
+    public ProtobufNodesStatsRequestBuilder(ProtobufOpenSearchClient client, ProtobufNodesStatsAction action) {
+        super(client, action, new ProtobufNodesStatsRequest());
+    }
+
+    /**
+     * Sets all the request flags.
+    */
+    public ProtobufNodesStatsRequestBuilder all() {
+        request.all();
+        return this;
+    }
+
+    /**
+     * Clears all stats flags.
+    */
+    public ProtobufNodesStatsRequestBuilder clear() {
+        request.clear();
+        return this;
+    }
+
+    /**
+     * Add a single metric to the request.
+    *
+    * @param metric Name of metric as a string.
+    * @return This, for request chaining.
+    */
+    public ProtobufNodesStatsRequestBuilder addMetric(String metric) {
+        request.addMetric(metric);
+        return this;
+    }
+
+    /**
+     * Add an array of metrics to the request.
+    *
+    * @param metrics Metric names as strings.
+    * @return This, for request chaining.
+    */
+    public ProtobufNodesStatsRequestBuilder addMetrics(String... metrics) {
+        request.addMetrics(metrics);
+        return this;
+    }
+
+    /**
+     * Should the node indices stats be returned.
+    */
+    public ProtobufNodesStatsRequestBuilder setIndices(boolean indices) {
+        request.indices(indices);
+        return this;
+    }
+
+    /**
+     * Should the node indices stats be returned.
+    */
+    public ProtobufNodesStatsRequestBuilder setIndices(ProtobufCommonStatsFlags indices) {
+        request.indices(indices);
+        return this;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
new file mode 100644
index 0000000000000..248608203dc79
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
@@ -0,0 +1,84 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.admin.cluster.node.stats;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.action.ProtobufFailedNodeException;
+import org.opensearch.action.support.nodes.ProtobufBaseNodesResponse;
+import org.opensearch.cluster.ProtobufClusterName;
+import org.opensearch.common.Strings;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.common.xcontent.XContentFactory;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * Transport response for obtaining OpenSearch Node Stats
+*
+* @opensearch.internal
+*/
+public class ProtobufNodesStatsResponse extends ProtobufBaseNodesResponse<ProtobufNodeStats> implements ToXContentFragment {
+
+    public ProtobufNodesStatsResponse(CodedInputStream in) throws IOException {
+        super(in);
+    }
+
+    public ProtobufNodesStatsResponse(
+        ProtobufClusterName clusterName,
+        List<ProtobufNodeStats> nodes,
+        List<ProtobufFailedNodeException> failures
+    ) {
+        super(clusterName, nodes, failures);
+    }
+
+    @Override
+    protected List<ProtobufNodeStats> readNodesFrom(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        return protobufStreamInput.readList(ProtobufNodeStats::new);
+    }
+
+    @Override
+    protected void writeNodesTo(CodedOutputStream out, List<ProtobufNodeStats> nodes) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeCollection(nodes, (o, v) -> v.writeTo(o));
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject("nodes");
+        for (ProtobufNodeStats nodeStats : getNodes()) {
+            builder.startObject(nodeStats.getNode().getId());
+            builder.field("timestamp", nodeStats.getTimestamp());
+            nodeStats.toXContent(builder, params);
+
+            builder.endObject();
+        }
+        builder.endObject();
+
+        return builder;
+    }
+
+    @Override
+    public String toString() {
+        try {
+            XContentBuilder builder = XContentFactory.jsonBuilder().prettyPrint();
+            builder.startObject();
+            toXContent(builder, EMPTY_PARAMS);
+            builder.endObject();
+            return Strings.toString(builder);
+        } catch (IOException e) {
+            return "{ \"error\" : \"" + e.getMessage() + "\"}";
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateAction.java
index 5ab9aa023a298..3f3c2a4d80d0e 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateAction.java
@@ -8,7 +8,6 @@
 
 package org.opensearch.action.admin.cluster.state;
 
-import org.opensearch.action.ActionType;
 import org.opensearch.action.ProtobufActionType;
 
 /**
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
index 6798c3b8c46e5..75c9ab839ba45 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
@@ -51,31 +51,31 @@ public ProtobufClusterStateRequest() {}
 
     public ProtobufClusterStateRequest(CodedInputStream in) throws IOException {
         super(in);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
         routingTable = in.readBool();
         nodes = in.readBool();
         metadata = in.readBool();
         blocks = in.readBool();
         customs = in.readBool();
-        indices = protobufStreamInput.readStringArray(in);
+        indices = protobufStreamInput.readStringArray();
         indicesOptions = IndicesOptions.readIndicesOptionsProtobuf(in);
-        waitForTimeout = protobufStreamInput.readTimeValue(in);
-        waitForMetadataVersion = protobufStreamInput.readOptionalLong(in);
+        waitForTimeout = protobufStreamInput.readTimeValue();
+        waitForMetadataVersion = protobufStreamInput.readOptionalLong();
     }
 
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
         super.writeTo(out);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         out.writeBoolNoTag(routingTable);
         out.writeBoolNoTag(nodes);
         out.writeBoolNoTag(metadata);
         out.writeBoolNoTag(blocks);
         out.writeBoolNoTag(customs);
-        protobufStreamOutput.writeStringArray(indices, out);
+        protobufStreamOutput.writeStringArray(indices);
         indicesOptions.writeIndicesOptionsProtobuf(out);
-        protobufStreamOutput.writeTimeValue(waitForTimeout, out);
-        protobufStreamOutput.writeOptionalLong(waitForMetadataVersion, out);
+        protobufStreamOutput.writeTimeValue(waitForTimeout);
+        protobufStreamOutput.writeOptionalLong(waitForMetadataVersion);
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequestBuilder.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequestBuilder.java
index 6255d47b9bd66..93c45eccd89a4 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequestBuilder.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequestBuilder.java
@@ -9,9 +9,7 @@
 package org.opensearch.action.admin.cluster.state;
 
 import org.opensearch.action.support.IndicesOptions;
-import org.opensearch.action.support.clustermanager.ClusterManagerNodeReadOperationRequestBuilder;
 import org.opensearch.action.support.clustermanager.ProtobufClusterManagerNodeReadOperationRequestBuilder;
-import org.opensearch.client.OpenSearchClient;
 import org.opensearch.client.ProtobufOpenSearchClient;
 import org.opensearch.common.unit.TimeValue;
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
index a88e42d78c66a..60892290c94a5 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
@@ -35,13 +35,11 @@ public class ProtobufClusterStateResponse extends ProtobufActionResponse {
     private ProtobufClusterState clusterState;
     private boolean waitForTimedOut = false;
 
-    private final ProtobufStreamInput protobufStreamInput;
-
     public ProtobufClusterStateResponse(CodedInputStream in) throws IOException {
         super(in);
-        protobufStreamInput = new ProtobufStreamInput();
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
         clusterName = new ProtobufClusterName(in);
-        clusterState = protobufStreamInput.readOptionalWriteable(innerIn -> ProtobufClusterState.readFrom(innerIn, null), in);
+        clusterState = protobufStreamInput.readOptionalWriteable(innerIn -> ProtobufClusterState.readFrom(innerIn, null));
         waitForTimedOut = in.readBool();
     }
 
@@ -49,7 +47,6 @@ public ProtobufClusterStateResponse(ProtobufClusterName clusterName, ProtobufClu
         this.clusterName = clusterName;
         this.clusterState = clusterState;
         this.waitForTimedOut = waitForTimedOut;
-        protobufStreamInput = new ProtobufStreamInput();
     }
 
     /**
@@ -77,9 +74,9 @@ public boolean isWaitForTimedOut() {
 
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         clusterName.writeTo(out);
-        protobufStreamOutput.writeOptionalWriteable(clusterState, out);
+        protobufStreamOutput.writeOptionalWriteable(clusterState);
         out.writeBoolNoTag(waitForTimedOut);
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStats.java b/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStats.java
new file mode 100644
index 0000000000000..89200608328dc
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStats.java
@@ -0,0 +1,460 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.admin.indices.stats;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.cache.query.ProtobufQueryCacheStats;
+import org.opensearch.index.cache.request.ProtobufRequestCacheStats;
+import org.opensearch.index.engine.ProtobufSegmentsStats;
+import org.opensearch.index.fielddata.ProtobufFieldDataStats;
+import org.opensearch.index.flush.ProtobufFlushStats;
+import org.opensearch.index.get.ProtobufGetStats;
+import org.opensearch.index.merge.ProtobufMergeStats;
+import org.opensearch.index.recovery.ProtobufRecoveryStats;
+import org.opensearch.index.refresh.ProtobufRefreshStats;
+import org.opensearch.index.search.stats.ProtobufSearchStats;
+import org.opensearch.index.shard.ProtobufDocsStats;
+import org.opensearch.index.shard.ProtobufIndexingStats;
+import org.opensearch.index.store.ProtobufStoreStats;
+import org.opensearch.index.translog.ProtobufTranslogStats;
+import org.opensearch.index.warmer.ProtobufWarmerStats;
+import org.opensearch.search.suggest.completion.ProtobufCompletionStats;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+/**
+ * Common Stats for OpenSearch
+*
+* @opensearch.internal
+*/
+public class ProtobufCommonStats implements ProtobufWriteable, ToXContentFragment {
+
+    @Nullable
+    public ProtobufDocsStats docs;
+
+    @Nullable
+    public ProtobufStoreStats store;
+
+    @Nullable
+    public ProtobufIndexingStats indexing;
+
+    @Nullable
+    public ProtobufGetStats get;
+
+    @Nullable
+    public ProtobufSearchStats search;
+
+    @Nullable
+    public ProtobufMergeStats merge;
+
+    @Nullable
+    public ProtobufRefreshStats refresh;
+
+    @Nullable
+    public ProtobufFlushStats flush;
+
+    @Nullable
+    public ProtobufWarmerStats warmer;
+
+    @Nullable
+    public ProtobufQueryCacheStats queryCache;
+
+    @Nullable
+    public ProtobufFieldDataStats fieldData;
+
+    @Nullable
+    public ProtobufCompletionStats completion;
+
+    @Nullable
+    public ProtobufSegmentsStats segments;
+
+    @Nullable
+    public ProtobufTranslogStats translog;
+
+    @Nullable
+    public ProtobufRequestCacheStats requestCache;
+
+    @Nullable
+    public ProtobufRecoveryStats recoveryStats;
+
+    public ProtobufCommonStats() {
+        this(ProtobufCommonStatsFlags.NONE);
+    }
+
+    public ProtobufCommonStats(ProtobufCommonStatsFlags flags) {
+        ProtobufCommonStatsFlags.Flag[] setFlags = flags.getFlags();
+
+        for (ProtobufCommonStatsFlags.Flag flag : setFlags) {
+            switch (flag) {
+                case Docs:
+                    docs = new ProtobufDocsStats();
+                    break;
+                case Store:
+                    store = new ProtobufStoreStats();
+                    break;
+                case Indexing:
+                    indexing = new ProtobufIndexingStats();
+                    break;
+                case Get:
+                    get = new ProtobufGetStats();
+                    break;
+                case Search:
+                    search = new ProtobufSearchStats();
+                    break;
+                case Merge:
+                    merge = new ProtobufMergeStats();
+                    break;
+                case Refresh:
+                    refresh = new ProtobufRefreshStats();
+                    break;
+                case Flush:
+                    flush = new ProtobufFlushStats();
+                    break;
+                case Warmer:
+                    warmer = new ProtobufWarmerStats();
+                    break;
+                case QueryCache:
+                    queryCache = new ProtobufQueryCacheStats();
+                    break;
+                case FieldData:
+                    fieldData = new ProtobufFieldDataStats();
+                    break;
+                case Completion:
+                    completion = new ProtobufCompletionStats();
+                    break;
+                case Segments:
+                    segments = new ProtobufSegmentsStats();
+                    break;
+                case Translog:
+                    translog = new ProtobufTranslogStats();
+                    break;
+                case RequestCache:
+                    requestCache = new ProtobufRequestCacheStats();
+                    break;
+                case Recovery:
+                    recoveryStats = new ProtobufRecoveryStats();
+                    break;
+                default:
+                    throw new IllegalStateException("Unknown Flag: " + flag);
+            }
+        }
+    }
+
+    public ProtobufCommonStats(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        docs = protobufStreamInput.readOptionalWriteable(ProtobufDocsStats::new);
+        store = protobufStreamInput.readOptionalWriteable(ProtobufStoreStats::new);
+        indexing = protobufStreamInput.readOptionalWriteable(ProtobufIndexingStats::new);
+        get = protobufStreamInput.readOptionalWriteable(ProtobufGetStats::new);
+        search = protobufStreamInput.readOptionalWriteable(ProtobufSearchStats::new);
+        merge = protobufStreamInput.readOptionalWriteable(ProtobufMergeStats::new);
+        refresh = protobufStreamInput.readOptionalWriteable(ProtobufRefreshStats::new);
+        flush = protobufStreamInput.readOptionalWriteable(ProtobufFlushStats::new);
+        warmer = protobufStreamInput.readOptionalWriteable(ProtobufWarmerStats::new);
+        queryCache = protobufStreamInput.readOptionalWriteable(ProtobufQueryCacheStats::new);
+        fieldData = protobufStreamInput.readOptionalWriteable(ProtobufFieldDataStats::new);
+        completion = protobufStreamInput.readOptionalWriteable(ProtobufCompletionStats::new);
+        segments = protobufStreamInput.readOptionalWriteable(ProtobufSegmentsStats::new);
+        translog = protobufStreamInput.readOptionalWriteable(ProtobufTranslogStats::new);
+        requestCache = protobufStreamInput.readOptionalWriteable(ProtobufRequestCacheStats::new);
+        recoveryStats = protobufStreamInput.readOptionalWriteable(ProtobufRecoveryStats::new);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeOptionalWriteable(docs);
+        protobufStreamOutput.writeOptionalWriteable(store);
+        protobufStreamOutput.writeOptionalWriteable(indexing);
+        protobufStreamOutput.writeOptionalWriteable(get);
+        protobufStreamOutput.writeOptionalWriteable(search);
+        protobufStreamOutput.writeOptionalWriteable(merge);
+        protobufStreamOutput.writeOptionalWriteable(refresh);
+        protobufStreamOutput.writeOptionalWriteable(flush);
+        protobufStreamOutput.writeOptionalWriteable(warmer);
+        protobufStreamOutput.writeOptionalWriteable(queryCache);
+        protobufStreamOutput.writeOptionalWriteable(fieldData);
+        protobufStreamOutput.writeOptionalWriteable(completion);
+        protobufStreamOutput.writeOptionalWriteable(segments);
+        protobufStreamOutput.writeOptionalWriteable(translog);
+        protobufStreamOutput.writeOptionalWriteable(requestCache);
+        protobufStreamOutput.writeOptionalWriteable(recoveryStats);
+    }
+
+    public void add(ProtobufCommonStats stats) {
+        if (docs == null) {
+            if (stats.getDocs() != null) {
+                docs = new ProtobufDocsStats();
+                docs.add(stats.getDocs());
+            }
+        } else {
+            docs.add(stats.getDocs());
+        }
+        if (store == null) {
+            if (stats.getStore() != null) {
+                store = new ProtobufStoreStats();
+                store.add(stats.getStore());
+            }
+        } else {
+            store.add(stats.getStore());
+        }
+        if (indexing == null) {
+            if (stats.getIndexing() != null) {
+                indexing = new ProtobufIndexingStats();
+                indexing.add(stats.getIndexing());
+            }
+        } else {
+            indexing.add(stats.getIndexing());
+        }
+        if (get == null) {
+            if (stats.getGet() != null) {
+                get = new ProtobufGetStats();
+                get.add(stats.getGet());
+            }
+        } else {
+            get.add(stats.getGet());
+        }
+        if (search == null) {
+            if (stats.getSearch() != null) {
+                search = new ProtobufSearchStats();
+                search.add(stats.getSearch());
+            }
+        } else {
+            search.add(stats.getSearch());
+        }
+        if (merge == null) {
+            if (stats.getMerge() != null) {
+                merge = new ProtobufMergeStats();
+                merge.add(stats.getMerge());
+            }
+        } else {
+            merge.add(stats.getMerge());
+        }
+        if (refresh == null) {
+            if (stats.getRefresh() != null) {
+                refresh = new ProtobufRefreshStats();
+                refresh.add(stats.getRefresh());
+            }
+        } else {
+            refresh.add(stats.getRefresh());
+        }
+        if (flush == null) {
+            if (stats.getFlush() != null) {
+                flush = new ProtobufFlushStats();
+                flush.add(stats.getFlush());
+            }
+        } else {
+            flush.add(stats.getFlush());
+        }
+        if (warmer == null) {
+            if (stats.getWarmer() != null) {
+                warmer = new ProtobufWarmerStats();
+                warmer.add(stats.getWarmer());
+            }
+        } else {
+            warmer.add(stats.getWarmer());
+        }
+        if (queryCache == null) {
+            if (stats.getQueryCache() != null) {
+                queryCache = new ProtobufQueryCacheStats();
+                queryCache.add(stats.getQueryCache());
+            }
+        } else {
+            queryCache.add(stats.getQueryCache());
+        }
+
+        if (fieldData == null) {
+            if (stats.getFieldData() != null) {
+                fieldData = new ProtobufFieldDataStats();
+                fieldData.add(stats.getFieldData());
+            }
+        } else {
+            fieldData.add(stats.getFieldData());
+        }
+        if (completion == null) {
+            if (stats.getCompletion() != null) {
+                completion = new ProtobufCompletionStats();
+                completion.add(stats.getCompletion());
+            }
+        } else {
+            completion.add(stats.getCompletion());
+        }
+        if (segments == null) {
+            if (stats.getSegments() != null) {
+                segments = new ProtobufSegmentsStats();
+                segments.add(stats.getSegments());
+            }
+        } else {
+            segments.add(stats.getSegments());
+        }
+        if (translog == null) {
+            if (stats.getTranslog() != null) {
+                translog = new ProtobufTranslogStats();
+                translog.add(stats.getTranslog());
+            }
+        } else {
+            translog.add(stats.getTranslog());
+        }
+        if (requestCache == null) {
+            if (stats.getRequestCache() != null) {
+                requestCache = new ProtobufRequestCacheStats();
+                requestCache.add(stats.getRequestCache());
+            }
+        } else {
+            requestCache.add(stats.getRequestCache());
+        }
+        if (recoveryStats == null) {
+            if (stats.getRecoveryStats() != null) {
+                recoveryStats = new ProtobufRecoveryStats();
+                recoveryStats.add(stats.getRecoveryStats());
+            }
+        } else {
+            recoveryStats.add(stats.getRecoveryStats());
+        }
+    }
+
+    @Nullable
+    public ProtobufDocsStats getDocs() {
+        return this.docs;
+    }
+
+    @Nullable
+    public ProtobufStoreStats getStore() {
+        return store;
+    }
+
+    @Nullable
+    public ProtobufIndexingStats getIndexing() {
+        return indexing;
+    }
+
+    @Nullable
+    public ProtobufGetStats getGet() {
+        return get;
+    }
+
+    @Nullable
+    public ProtobufSearchStats getSearch() {
+        return search;
+    }
+
+    @Nullable
+    public ProtobufMergeStats getMerge() {
+        return merge;
+    }
+
+    @Nullable
+    public ProtobufRefreshStats getRefresh() {
+        return refresh;
+    }
+
+    @Nullable
+    public ProtobufFlushStats getFlush() {
+        return flush;
+    }
+
+    @Nullable
+    public ProtobufWarmerStats getWarmer() {
+        return this.warmer;
+    }
+
+    @Nullable
+    public ProtobufQueryCacheStats getQueryCache() {
+        return this.queryCache;
+    }
+
+    @Nullable
+    public ProtobufFieldDataStats getFieldData() {
+        return this.fieldData;
+    }
+
+    @Nullable
+    public ProtobufCompletionStats getCompletion() {
+        return completion;
+    }
+
+    @Nullable
+    public ProtobufSegmentsStats getSegments() {
+        return segments;
+    }
+
+    @Nullable
+    public ProtobufTranslogStats getTranslog() {
+        return translog;
+    }
+
+    @Nullable
+    public ProtobufRequestCacheStats getRequestCache() {
+        return requestCache;
+    }
+
+    @Nullable
+    public ProtobufRecoveryStats getRecoveryStats() {
+        return recoveryStats;
+    }
+
+    /**
+     * Utility method which computes total memory by adding
+    * FieldData, PercolatorCache, Segments (index writer, version map)
+    */
+    public ByteSizeValue getTotalMemory() {
+        long size = 0;
+        if (this.getFieldData() != null) {
+            size += this.getFieldData().getMemorySizeInBytes();
+        }
+        if (this.getQueryCache() != null) {
+            size += this.getQueryCache().getMemorySizeInBytes();
+        }
+        if (this.getSegments() != null) {
+            size += this.getSegments().getIndexWriterMemoryInBytes() + this.getSegments().getVersionMapMemoryInBytes();
+        }
+
+        return new ByteSizeValue(size);
+    }
+
+    // note, requires a wrapping object
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        final Stream<ToXContent> stream = Arrays.stream(
+            new ToXContent[] {
+                docs,
+                store,
+                indexing,
+                get,
+                search,
+                merge,
+                refresh,
+                flush,
+                warmer,
+                queryCache,
+                fieldData,
+                completion,
+                segments,
+                translog,
+                requestCache,
+                recoveryStats }
+        ).filter(Objects::nonNull);
+        for (ToXContent toXContent : ((Iterable<ToXContent>) stream::iterator)) {
+            toXContent.toXContent(builder, params);
+        }
+        return builder;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStatsFlags.java b/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStatsFlags.java
index 82df111cceda4..d4a306d7a79ea 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStatsFlags.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStatsFlags.java
@@ -15,9 +15,6 @@
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.io.stream.StreamInput;
-import org.opensearch.common.io.stream.StreamOutput;
-import org.opensearch.common.io.stream.Writeable;
 
 import java.io.IOException;
 import java.util.Collections;
@@ -30,8 +27,8 @@
 */
 public class ProtobufCommonStatsFlags implements ProtobufWriteable, Cloneable {
 
-    public static final CommonStatsFlags ALL = new CommonStatsFlags().all();
-    public static final CommonStatsFlags NONE = new CommonStatsFlags().clear();
+    public static final ProtobufCommonStatsFlags ALL = new ProtobufCommonStatsFlags().all();
+    public static final ProtobufCommonStatsFlags NONE = new ProtobufCommonStatsFlags().clear();
 
     private EnumSet<Flag> flags = EnumSet.allOf(Flag.class);
     private String[] groups = null;
@@ -53,8 +50,8 @@ public ProtobufCommonStatsFlags(Flag... flags) {
     }
 
     public ProtobufCommonStatsFlags(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
-        final long longFlags = in.readLong();
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        final long longFlags = in.readInt64();
         flags.clear();
         for (Flag flag : Flag.values()) {
             if ((longFlags & (1 << flag.getIndex())) != 0) {
@@ -62,11 +59,11 @@ public ProtobufCommonStatsFlags(CodedInputStream in) throws IOException {
             }
         }
         if (protobufStreamInput.getVersion().before(Version.V_2_0_0)) {
-            protobufStreamInput.readStringArray(in);
+            protobufStreamInput.readStringArray();
         }
-        groups = protobufStreamInput.readStringArray(in);
-        fieldDataFields = protobufStreamInput.readStringArray(in);
-        completionDataFields = protobufStreamInput.readStringArray(in);
+        groups = protobufStreamInput.readStringArray();
+        fieldDataFields = protobufStreamInput.readStringArray();
+        completionDataFields = protobufStreamInput.readStringArray();
         includeSegmentFileSizes = in.readBool();
         includeUnloadedSegments = in.readBool();
         includeAllShardIndexingPressureTrackers = in.readBool();
@@ -75,7 +72,7 @@ public ProtobufCommonStatsFlags(CodedInputStream in) throws IOException {
 
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         long longFlags = 0;
         for (Flag flag : flags) {
             longFlags |= (1 << flag.getIndex());
@@ -83,11 +80,11 @@ public void writeTo(CodedOutputStream out) throws IOException {
         out.writeInt64NoTag(longFlags);
 
         if (protobufStreamOutput.getVersion().before(Version.V_2_0_0)) {
-            protobufStreamOutput.writeStringArrayNullable(Strings.EMPTY_ARRAY, out);
+            protobufStreamOutput.writeStringArrayNullable(Strings.EMPTY_ARRAY);
         }
-        protobufStreamOutput.writeStringArrayNullable(groups, out);
-        protobufStreamOutput.writeStringArrayNullable(fieldDataFields, out);
-        protobufStreamOutput.writeStringArrayNullable(completionDataFields, out);
+        protobufStreamOutput.writeStringArrayNullable(groups);
+        protobufStreamOutput.writeStringArrayNullable(fieldDataFields);
+        protobufStreamOutput.writeStringArrayNullable(completionDataFields);
         out.writeBoolNoTag(includeSegmentFileSizes);
         out.writeBoolNoTag(includeUnloadedSegments);
         out.writeBoolNoTag(includeAllShardIndexingPressureTrackers);
diff --git a/server/src/main/java/org/opensearch/action/support/IndicesOptions.java b/server/src/main/java/org/opensearch/action/support/IndicesOptions.java
index 32da5e6002f55..82a7fc82e5f5f 100644
--- a/server/src/main/java/org/opensearch/action/support/IndicesOptions.java
+++ b/server/src/main/java/org/opensearch/action/support/IndicesOptions.java
@@ -283,10 +283,10 @@ public void writeIndicesOptions(StreamOutput out) throws IOException {
     }
 
     public void writeIndicesOptionsProtobuf(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         EnumSet<Option> options = this.options;
-        protobufStreamOutput.writeEnumSet(options, out);
-        protobufStreamOutput.writeEnumSet(expandWildcards, out);
+        protobufStreamOutput.writeEnumSet(options);
+        protobufStreamOutput.writeEnumSet(expandWildcards);
     }
 
     public static IndicesOptions readIndicesOptions(StreamInput in) throws IOException {
@@ -296,9 +296,9 @@ public static IndicesOptions readIndicesOptions(StreamInput in) throws IOExcepti
     }
 
     public static IndicesOptions readIndicesOptionsProtobuf(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
-        EnumSet<Option> options = protobufStreamInput.readEnumSet(Option.class, in);
-        EnumSet<WildcardStates> states = protobufStreamInput.readEnumSet(WildcardStates.class, in);
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        EnumSet<Option> options = protobufStreamInput.readEnumSet(Option.class);
+        EnumSet<WildcardStates> states = protobufStreamInput.readEnumSet(WildcardStates.class);
         return new IndicesOptions(options, states);
     }
 
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufActionFilter.java b/server/src/main/java/org/opensearch/action/support/ProtobufActionFilter.java
index 45cad3065d607..bf20ddae5fbce 100644
--- a/server/src/main/java/org/opensearch/action/support/ProtobufActionFilter.java
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufActionFilter.java
@@ -9,11 +9,9 @@
 package org.opensearch.action.support;
 
 import org.opensearch.action.ActionListener;
-import org.opensearch.action.ActionRequest;
-import org.opensearch.action.ActionResponse;
 import org.opensearch.action.ProtobufActionRequest;
 import org.opensearch.action.ProtobufActionResponse;
-import org.opensearch.tasks.Task;
+import org.opensearch.tasks.ProtobufTask;
 
 /**
  * A filter allowing to filter transport actions
@@ -32,7 +30,7 @@ public interface ProtobufActionFilter {
     * {@link ActionListener} or by continuing the execution through the given {@link ActionFilterChain chain}
     */
     <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> void apply(
-        Task task,
+        ProtobufTask task,
         String action,
         Request request,
         ActionListener<Response> listener,
@@ -47,7 +45,7 @@ <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse>
     abstract class Simple implements ProtobufActionFilter {
         @Override
         public final <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> void apply(
-            Task task,
+            ProtobufTask task,
             String action,
             Request request,
             ActionListener<Response> listener,
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufActionFilterChain.java b/server/src/main/java/org/opensearch/action/support/ProtobufActionFilterChain.java
index 54de493efede3..216797f1ea1a0 100644
--- a/server/src/main/java/org/opensearch/action/support/ProtobufActionFilterChain.java
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufActionFilterChain.java
@@ -9,11 +9,9 @@
 package org.opensearch.action.support;
 
 import org.opensearch.action.ActionListener;
-import org.opensearch.action.ActionRequest;
-import org.opensearch.action.ActionResponse;
 import org.opensearch.action.ProtobufActionRequest;
 import org.opensearch.action.ProtobufActionResponse;
-import org.opensearch.tasks.Task;
+import org.opensearch.tasks.ProtobufTask;
 
 /**
  * A filter chain allowing to continue and process the transport action request
@@ -26,5 +24,5 @@ public interface ProtobufActionFilterChain<Request extends ProtobufActionRequest
      * Continue processing the request. Should only be called if a response has not been sent through
     * the given {@link ActionListener listener}
     */
-    void proceed(Task task, String action, Request request, ActionListener<Response> listener);
+    void proceed(ProtobufTask task, String action, Request request, ActionListener<Response> listener);
 }
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufChannelActionListener.java b/server/src/main/java/org/opensearch/action/support/ProtobufChannelActionListener.java
new file mode 100644
index 0000000000000..217ce15684361
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufChannelActionListener.java
@@ -0,0 +1,48 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.support;
+
+import org.opensearch.action.ActionListener;
+import org.opensearch.transport.ProtobufTransportChannel;
+import org.opensearch.transport.ProtobufTransportRequest;
+import org.opensearch.transport.ProtobufTransportResponse;
+
+/**
+ * Listener for transport channel actions
+*
+* @opensearch.internal
+*/
+public final class ProtobufChannelActionListener<Response extends ProtobufTransportResponse, Request extends ProtobufTransportRequest>
+    implements
+        ActionListener<Response> {
+
+    private final ProtobufTransportChannel channel;
+    private final Request request;
+    private final String actionName;
+
+    public ProtobufChannelActionListener(ProtobufTransportChannel channel, String actionName, Request request) {
+        this.channel = channel;
+        this.request = request;
+        this.actionName = actionName;
+    }
+
+    @Override
+    public void onResponse(Response response) {
+        try {
+            channel.sendResponse(response);
+        } catch (Exception e) {
+            onFailure(e);
+        }
+    }
+
+    @Override
+    public void onFailure(Exception e) {
+        ProtobufTransportChannel.sendErrorResponse(channel, actionName, request, e);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java b/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
index 1225fbd403b04..72e4ac90403b0 100644
--- a/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
@@ -11,22 +11,17 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.opensearch.action.ActionListener;
-import org.opensearch.action.ActionRequest;
-import org.opensearch.action.ActionRequestValidationException;
-import org.opensearch.action.ActionResponse;
 import org.opensearch.action.ProtobufActionRequest;
+import org.opensearch.action.ActionRequestValidationException;
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.lease.Releasables;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.tasks.ProtobufTask;
 import org.opensearch.tasks.ProtobufTaskId;
-import org.opensearch.tasks.Task;
+import org.opensearch.tasks.ProtobufTaskManager;
 import org.opensearch.tasks.TaskCancelledException;
-import org.opensearch.tasks.TaskId;
-import org.opensearch.tasks.TaskListener;
-import org.opensearch.tasks.TaskManager;
-
+import org.opensearch.tasks.ProtobufTaskListener;
 import java.util.concurrent.atomic.AtomicInteger;
 
 /**
@@ -38,14 +33,14 @@ public abstract class ProtobufTransportAction<Request extends ProtobufActionRequ
 
     public final String actionName;
     private final ProtobufActionFilter[] filters;
-    protected final TaskManager taskManager;
+    protected final ProtobufTaskManager taskManager;
     /**
      * @deprecated declare your own logger.
     */
     @Deprecated
     protected Logger logger = LogManager.getLogger(getClass());
 
-    protected ProtobufTransportAction(String actionName, ProtobufActionFilters actionFilters, TaskManager taskManager) {
+    protected ProtobufTransportAction(String actionName, ProtobufActionFilters actionFilters, ProtobufTaskManager taskManager) {
         this.actionName = actionName;
         this.filters = actionFilters.filters();
         this.taskManager = taskManager;
@@ -66,7 +61,7 @@ private Releasable registerChildNode(ProtobufTaskId parentTask) {
     */
     public final ProtobufTask execute(Request request, ActionListener<Response> listener) {
         /*
-        * While this version of execute could delegate to the TaskListener
+        * While this version of execute could delegate to the ProtobufTaskListener
         * version of execute that'd add yet another layer of wrapping on the
         * listener and prevent us from using the listener bare if there isn't a
         * task. That just seems like too many objects. Thus the two versions of
@@ -111,12 +106,12 @@ public void onFailure(Exception e) {
     }
 
     /**
-     * Execute the transport action on the local node, returning the {@link Task} used to track its execution and accepting a
-    * {@link TaskListener} which listens for the completion of the action.
+     * Execute the transport action on the local node, returning the {@link ProtobufTask} used to track its execution and accepting a
+    * {@link ProtobufTaskListener} which listens for the completion of the action.
     */
-    public final Task execute(Request request, TaskListener<Response> listener) {
+    public final ProtobufTask execute(Request request, ProtobufTaskListener<Response> listener) {
         final Releasable unregisterChildNode = registerChildNode(request.getParentTask());
-        final Task task;
+        final ProtobufTask task;
         try {
             task = taskManager.register("transport", actionName, request);
         } catch (TaskCancelledException e) {
@@ -153,7 +148,7 @@ public void onFailure(Exception e) {
     /**
      * Use this method when the transport action should continue to run in the context of the current task
     */
-    public final void execute(Task task, Request request, ActionListener<Response> listener) {
+    public final void execute(ProtobufTask task, Request request, ActionListener<Response> listener) {
         ActionRequestValidationException validationException = request.validate();
         if (validationException != null) {
             listener.onFailure(validationException);
@@ -168,28 +163,28 @@ public final void execute(Task task, Request request, ActionListener<Response> l
         requestFilterChain.proceed(task, actionName, request, listener);
     }
 
-    protected abstract void doExecute(Task task, Request request, ActionListener<Response> listener);
+    protected abstract void doExecute(ProtobufTask task, Request request, ActionListener<Response> listener);
 
     /**
      * A request filter chain
     *
     * @opensearch.internal
     */
-    private static class RequestFilterChain<Request extends ActionRequest, Response extends ActionResponse>
+    private static class RequestFilterChain<Request extends ProtobufActionRequest, Response extends ProtobufActionResponse>
         implements
-            ActionFilterChain<Request, Response> {
+            ProtobufActionFilterChain<Request, Response> {
 
-        private final TransportAction<Request, Response> action;
+        private final ProtobufTransportAction<Request, Response> action;
         private final AtomicInteger index = new AtomicInteger();
         private final Logger logger;
 
-        private RequestFilterChain(TransportAction<Request, Response> action, Logger logger) {
+        private RequestFilterChain(ProtobufTransportAction<Request, Response> action, Logger logger) {
             this.action = action;
             this.logger = logger;
         }
 
         @Override
-        public void proceed(Task task, String actionName, Request request, ActionListener<Response> listener) {
+        public void proceed(ProtobufTask task, String actionName, Request request, ActionListener<Response> listener) {
             int i = index.getAndIncrement();
             try {
                 if (i < this.action.filters.length) {
@@ -212,12 +207,12 @@ public void proceed(Task task, String actionName, Request request, ActionListene
     *
     * @opensearch.internal
     */
-    private static class TaskResultStoringActionListener<Response extends ActionResponse> implements ActionListener<Response> {
+    private static class TaskResultStoringActionListener<Response extends ProtobufActionResponse> implements ActionListener<Response> {
         private final ActionListener<Response> delegate;
-        private final Task task;
-        private final TaskManager taskManager;
+        private final ProtobufTask task;
+        private final ProtobufTaskManager taskManager;
 
-        private TaskResultStoringActionListener(TaskManager taskManager, Task task, ActionListener<Response> delegate) {
+        private TaskResultStoringActionListener(ProtobufTaskManager taskManager, ProtobufTask task, ActionListener<Response> delegate) {
             this.taskManager = taskManager;
             this.task = task;
             this.delegate = delegate;
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeOperationRequestBuilder.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeOperationRequestBuilder.java
index 570d21cdc32f8..99713bdc02969 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeOperationRequestBuilder.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeOperationRequestBuilder.java
@@ -8,13 +8,9 @@
 
 package org.opensearch.action.support.clustermanager;
 
-import org.opensearch.action.ActionType;
 import org.opensearch.action.ProtobufActionRequestBuilder;
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.action.ProtobufActionType;
-import org.opensearch.action.ActionRequestBuilder;
-import org.opensearch.action.ActionResponse;
-import org.opensearch.client.OpenSearchClient;
 import org.opensearch.client.ProtobufOpenSearchClient;
 import org.opensearch.common.unit.TimeValue;
 
@@ -26,11 +22,14 @@
 public abstract class ProtobufClusterManagerNodeOperationRequestBuilder<
     Request extends ProtobufClusterManagerNodeRequest<Request>,
     Response extends ProtobufActionResponse,
-    RequestBuilder extends ProtobufClusterManagerNodeOperationRequestBuilder<Request, Response, RequestBuilder>> extends ProtobufActionRequestBuilder<
-        Request,
-        Response> {
+    RequestBuilder extends ProtobufClusterManagerNodeOperationRequestBuilder<Request, Response, RequestBuilder>> extends
+    ProtobufActionRequestBuilder<Request, Response> {
 
-    protected ProtobufClusterManagerNodeOperationRequestBuilder(ProtobufOpenSearchClient client, ProtobufActionType<Response> action, Request request) {
+    protected ProtobufClusterManagerNodeOperationRequestBuilder(
+        ProtobufOpenSearchClient client,
+        ProtobufActionType<Response> action,
+        Request request
+    ) {
         super(client, action, request);
     }
 
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadOperationRequestBuilder.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadOperationRequestBuilder.java
index d98b95451352e..18c270292d135 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadOperationRequestBuilder.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadOperationRequestBuilder.java
@@ -10,7 +10,6 @@
 
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.action.ProtobufActionType;
-import org.opensearch.client.OpenSearchClient;
 import org.opensearch.client.ProtobufOpenSearchClient;
 
 /**
@@ -24,7 +23,11 @@ public abstract class ProtobufClusterManagerNodeReadOperationRequestBuilder<
     RequestBuilder extends ProtobufClusterManagerNodeReadOperationRequestBuilder<Request, Response, RequestBuilder>> extends
     ProtobufClusterManagerNodeOperationRequestBuilder<Request, Response, RequestBuilder> {
 
-    protected ProtobufClusterManagerNodeReadOperationRequestBuilder(ProtobufOpenSearchClient client, ProtobufActionType<Response> action, Request request) {
+    protected ProtobufClusterManagerNodeReadOperationRequestBuilder(
+        ProtobufOpenSearchClient client,
+        ProtobufActionType<Response> action,
+        Request request
+    ) {
         super(client, action, request);
     }
 
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeRequest.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeRequest.java
index 83c04c161cb15..aef155bd9e9da 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeRequest.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeRequest.java
@@ -46,15 +46,15 @@ protected ProtobufClusterManagerNodeRequest() {}
 
     protected ProtobufClusterManagerNodeRequest(CodedInputStream in) throws IOException {
         super(in);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
-        clusterManagerNodeTimeout = protobufStreamInput.readTimeValue(in);
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        clusterManagerNodeTimeout = protobufStreamInput.readTimeValue();
     }
 
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
         super.writeTo(out);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
-        protobufStreamOutput.writeTimeValue(clusterManagerNodeTimeout, out);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeTimeValue(clusterManagerNodeTimeout);
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
index 283b792fc26e2..3cdb26be01c1e 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
@@ -54,10 +54,10 @@ public abstract class ProtobufBaseNodesRequest<Request extends ProtobufBaseNodes
 
     protected ProtobufBaseNodesRequest(CodedInputStream in) throws IOException {
         super(in);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
-        nodesIds = protobufStreamInput.readStringArray(in);
-        concreteNodes = protobufStreamInput.readOptionalArray(ProtobufDiscoveryNode::new, ProtobufDiscoveryNode[]::new, in);
-        timeout = protobufStreamInput.readOptionalTimeValue(in);
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        nodesIds = protobufStreamInput.readStringArray();
+        concreteNodes = protobufStreamInput.readOptionalArray(ProtobufDiscoveryNode::new, ProtobufDiscoveryNode[]::new);
+        timeout = protobufStreamInput.readOptionalTimeValue();
     }
 
     protected ProtobufBaseNodesRequest(String... nodesIds) {
@@ -109,11 +109,11 @@ public ActionRequestValidationException validate() {
     }
 
     @Override
-    public void writeTo(CodedOutputStream output) throws IOException {
-        super.writeTo(output);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
-        protobufStreamOutput.writeStringArrayNullable(nodesIds, output);
-        protobufStreamOutput.writeOptionalArray((out, value) -> value.writeTo(out), concreteNodes, output);
-        protobufStreamOutput.writeOptionalTimeValue(timeout, output);
+    public void writeTo(CodedOutputStream out) throws IOException {
+        super.writeTo(out);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeStringArrayNullable(nodesIds);
+        protobufStreamOutput.writeOptionalArray((o, v) -> v.writeTo(o), concreteNodes);
+        protobufStreamOutput.writeOptionalTimeValue(timeout);
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java
index 7a9ae34aa4ed6..e51aa2e27251f 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java
@@ -41,10 +41,10 @@ public abstract class ProtobufBaseNodesResponse<TNodeResponse extends ProtobufBa
 
     protected ProtobufBaseNodesResponse(CodedInputStream in) throws IOException {
         super(in);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
         clusterName = new ProtobufClusterName(in);
         nodes = readNodesFrom(in);
-        failures = protobufStreamInput.readList(ProtobufFailedNodeException::new, in);
+        failures = protobufStreamInput.readList(ProtobufFailedNodeException::new);
     }
 
     protected ProtobufBaseNodesResponse(
@@ -112,10 +112,10 @@ public Map<String, TNodeResponse> getNodesMap() {
 
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         clusterName.writeTo(out);
         writeNodesTo(out, nodes);
-        protobufStreamOutput.writeCollection(failures, (o, v) -> v.writeTo(o), out);
+        protobufStreamOutput.writeCollection(failures, (o, v) -> v.writeTo(o));
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufNodesOperationRequestBuilder.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufNodesOperationRequestBuilder.java
new file mode 100644
index 0000000000000..aacc551e41100
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufNodesOperationRequestBuilder.java
@@ -0,0 +1,49 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.support.nodes;
+
+import org.opensearch.action.ProtobufActionType;
+import org.opensearch.action.ProtobufActionRequestBuilder;
+import org.opensearch.client.ProtobufOpenSearchClient;
+import org.opensearch.common.unit.TimeValue;
+
+/**
+ * Builder for Operation Requests
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufNodesOperationRequestBuilder<
+    Request extends ProtobufBaseNodesRequest<Request>,
+    Response extends ProtobufBaseNodesResponse,
+    RequestBuilder extends ProtobufNodesOperationRequestBuilder<Request, Response, RequestBuilder>> extends ProtobufActionRequestBuilder<
+        Request,
+        Response> {
+
+    protected ProtobufNodesOperationRequestBuilder(ProtobufOpenSearchClient client, ProtobufActionType<Response> action, Request request) {
+        super(client, action, request);
+    }
+
+    @SuppressWarnings("unchecked")
+    public final RequestBuilder setNodesIds(String... nodesIds) {
+        request.nodesIds(nodesIds);
+        return (RequestBuilder) this;
+    }
+
+    @SuppressWarnings("unchecked")
+    public final RequestBuilder setTimeout(TimeValue timeout) {
+        request.timeout(timeout);
+        return (RequestBuilder) this;
+    }
+
+    @SuppressWarnings("unchecked")
+    public final RequestBuilder setTimeout(String timeout) {
+        request.timeout(timeout);
+        return (RequestBuilder) this;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/client/ClusterAdminClient.java b/server/src/main/java/org/opensearch/client/ClusterAdminClient.java
index 13fb74dbb265e..f3c04b23dfd54 100644
--- a/server/src/main/java/org/opensearch/client/ClusterAdminClient.java
+++ b/server/src/main/java/org/opensearch/client/ClusterAdminClient.java
@@ -55,8 +55,6 @@
 import org.opensearch.action.admin.cluster.node.info.NodesInfoRequest;
 import org.opensearch.action.admin.cluster.node.info.NodesInfoRequestBuilder;
 import org.opensearch.action.admin.cluster.node.info.NodesInfoResponse;
-import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequest;
-import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoResponse;
 import org.opensearch.action.admin.cluster.node.reload.NodesReloadSecureSettingsRequestBuilder;
 import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
 import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequestBuilder;
@@ -128,8 +126,6 @@
 import org.opensearch.action.admin.cluster.state.ClusterStateRequest;
 import org.opensearch.action.admin.cluster.state.ClusterStateRequestBuilder;
 import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
-import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
-import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
 import org.opensearch.action.admin.cluster.stats.ClusterStatsRequest;
 import org.opensearch.action.admin.cluster.stats.ClusterStatsRequestBuilder;
 import org.opensearch.action.admin.cluster.stats.ClusterStatsResponse;
diff --git a/server/src/main/java/org/opensearch/client/ProtobufClient.java b/server/src/main/java/org/opensearch/client/ProtobufClient.java
index 4b34b3460385c..ca5a7889f2939 100644
--- a/server/src/main/java/org/opensearch/client/ProtobufClient.java
+++ b/server/src/main/java/org/opensearch/client/ProtobufClient.java
@@ -9,6 +9,12 @@
 package org.opensearch.client;
 
 import org.opensearch.action.ActionListener;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Setting.Property;
+import org.opensearch.common.settings.Settings;
+
+import java.util.Map;
 
 /**
  * A client provides a one stop interface for performing actions/operations against the cluster.
@@ -23,10 +29,41 @@
 *
 * @opensearch.internal
 */
-public interface ProtobufClient extends ProtobufOpenSearchClient {
+public interface ProtobufClient extends ProtobufOpenSearchClient, Releasable {
+
+    Setting<String> CLIENT_TYPE_SETTING_S = new Setting<>("client.type", "node", (s) -> {
+        switch (s) {
+            case "node":
+            case "transport":
+                return s;
+            default:
+                throw new IllegalArgumentException("Can't parse [client.type] must be one of [node, transport]");
+        }
+    }, Property.NodeScope);
 
     /**
      * The admin client that can be used to perform administrative operations.
     */
     ProtobufAdminClient admin();
+
+    /**
+     * Returns this clients settings
+    */
+    Settings settings();
+
+    /**
+     * Returns a new lightweight ProtobufClient that applies all given headers to each of the requests
+    * issued from it.
+    */
+    ProtobufClient filterWithHeader(Map<String, String> headers);
+
+    /**
+     * Returns a client to a remote cluster with the given cluster alias.
+    *
+    * @throws IllegalArgumentException if the given clusterAlias doesn't exist
+    * @throws UnsupportedOperationException if this functionality is not available on this client.
+    */
+    default ProtobufClient getRemoteClusterClient(String clusterAlias) {
+        throw new UnsupportedOperationException("this client doesn't support remote cluster connections");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/client/ProtobufClusterAdminClient.java b/server/src/main/java/org/opensearch/client/ProtobufClusterAdminClient.java
index dfc638cc2a65c..ad07cd7a6b697 100644
--- a/server/src/main/java/org/opensearch/client/ProtobufClusterAdminClient.java
+++ b/server/src/main/java/org/opensearch/client/ProtobufClusterAdminClient.java
@@ -10,135 +10,15 @@
 
 import org.opensearch.action.ActionFuture;
 import org.opensearch.action.ActionListener;
-import org.opensearch.action.admin.cluster.allocation.ClusterAllocationExplainRequest;
-import org.opensearch.action.admin.cluster.allocation.ClusterAllocationExplainRequestBuilder;
-import org.opensearch.action.admin.cluster.allocation.ClusterAllocationExplainResponse;
-import org.opensearch.action.admin.cluster.decommission.awareness.delete.DeleteDecommissionStateRequest;
-import org.opensearch.action.admin.cluster.decommission.awareness.delete.DeleteDecommissionStateRequestBuilder;
-import org.opensearch.action.admin.cluster.decommission.awareness.delete.DeleteDecommissionStateResponse;
-import org.opensearch.action.admin.cluster.decommission.awareness.get.GetDecommissionStateRequest;
-import org.opensearch.action.admin.cluster.decommission.awareness.get.GetDecommissionStateRequestBuilder;
-import org.opensearch.action.admin.cluster.decommission.awareness.get.GetDecommissionStateResponse;
-import org.opensearch.action.admin.cluster.decommission.awareness.put.DecommissionRequest;
-import org.opensearch.action.admin.cluster.decommission.awareness.put.DecommissionRequestBuilder;
-import org.opensearch.action.admin.cluster.decommission.awareness.put.DecommissionResponse;
-import org.opensearch.action.admin.cluster.health.ClusterHealthRequest;
-import org.opensearch.action.admin.cluster.health.ClusterHealthRequestBuilder;
-import org.opensearch.action.admin.cluster.health.ClusterHealthResponse;
-import org.opensearch.action.admin.cluster.node.hotthreads.NodesHotThreadsRequest;
-import org.opensearch.action.admin.cluster.node.hotthreads.NodesHotThreadsRequestBuilder;
-import org.opensearch.action.admin.cluster.node.hotthreads.NodesHotThreadsResponse;
-import org.opensearch.action.admin.cluster.node.info.NodesInfoRequest;
-import org.opensearch.action.admin.cluster.node.info.NodesInfoRequestBuilder;
-import org.opensearch.action.admin.cluster.node.info.NodesInfoResponse;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequestBuilder;
 import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequest;
 import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoResponse;
-import org.opensearch.action.admin.cluster.node.reload.NodesReloadSecureSettingsRequestBuilder;
-import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
-import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequestBuilder;
-import org.opensearch.action.admin.cluster.node.stats.NodesStatsResponse;
-import org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksRequest;
-import org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksRequestBuilder;
-import org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksResponse;
-import org.opensearch.action.admin.cluster.node.tasks.get.GetTaskRequest;
-import org.opensearch.action.admin.cluster.node.tasks.get.GetTaskRequestBuilder;
-import org.opensearch.action.admin.cluster.node.tasks.get.GetTaskResponse;
-import org.opensearch.action.admin.cluster.node.tasks.list.ListTasksRequest;
-import org.opensearch.action.admin.cluster.node.tasks.list.ListTasksRequestBuilder;
-import org.opensearch.action.admin.cluster.node.tasks.list.ListTasksResponse;
-import org.opensearch.action.admin.cluster.node.usage.NodesUsageRequest;
-import org.opensearch.action.admin.cluster.node.usage.NodesUsageRequestBuilder;
-import org.opensearch.action.admin.cluster.node.usage.NodesUsageResponse;
-import org.opensearch.action.admin.cluster.remotestore.restore.RestoreRemoteStoreRequest;
-import org.opensearch.action.admin.cluster.remotestore.restore.RestoreRemoteStoreResponse;
-import org.opensearch.action.admin.cluster.repositories.cleanup.CleanupRepositoryRequest;
-import org.opensearch.action.admin.cluster.repositories.cleanup.CleanupRepositoryRequestBuilder;
-import org.opensearch.action.admin.cluster.repositories.cleanup.CleanupRepositoryResponse;
-import org.opensearch.action.admin.cluster.repositories.delete.DeleteRepositoryRequest;
-import org.opensearch.action.admin.cluster.repositories.delete.DeleteRepositoryRequestBuilder;
-import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesRequest;
-import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesRequestBuilder;
-import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesResponse;
-import org.opensearch.action.admin.cluster.repositories.put.PutRepositoryRequest;
-import org.opensearch.action.admin.cluster.repositories.put.PutRepositoryRequestBuilder;
-import org.opensearch.action.admin.cluster.repositories.verify.VerifyRepositoryRequest;
-import org.opensearch.action.admin.cluster.repositories.verify.VerifyRepositoryRequestBuilder;
-import org.opensearch.action.admin.cluster.repositories.verify.VerifyRepositoryResponse;
-import org.opensearch.action.admin.cluster.reroute.ClusterRerouteRequest;
-import org.opensearch.action.admin.cluster.reroute.ClusterRerouteRequestBuilder;
-import org.opensearch.action.admin.cluster.reroute.ClusterRerouteResponse;
-import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
-import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequestBuilder;
-import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsResponse;
-import org.opensearch.action.admin.cluster.shards.ClusterSearchShardsRequest;
-import org.opensearch.action.admin.cluster.shards.ClusterSearchShardsRequestBuilder;
-import org.opensearch.action.admin.cluster.shards.ClusterSearchShardsResponse;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.delete.ClusterDeleteWeightedRoutingRequest;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.delete.ClusterDeleteWeightedRoutingRequestBuilder;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.delete.ClusterDeleteWeightedRoutingResponse;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.get.ClusterGetWeightedRoutingRequest;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.get.ClusterGetWeightedRoutingRequestBuilder;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.get.ClusterGetWeightedRoutingResponse;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.put.ClusterPutWeightedRoutingRequest;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.put.ClusterPutWeightedRoutingRequestBuilder;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.put.ClusterPutWeightedRoutingResponse;
-import org.opensearch.action.admin.cluster.snapshots.clone.CloneSnapshotRequest;
-import org.opensearch.action.admin.cluster.snapshots.clone.CloneSnapshotRequestBuilder;
-import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotRequest;
-import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotRequestBuilder;
-import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotResponse;
-import org.opensearch.action.admin.cluster.snapshots.delete.DeleteSnapshotRequest;
-import org.opensearch.action.admin.cluster.snapshots.delete.DeleteSnapshotRequestBuilder;
-import org.opensearch.action.admin.cluster.snapshots.get.GetSnapshotsRequest;
-import org.opensearch.action.admin.cluster.snapshots.get.GetSnapshotsRequestBuilder;
-import org.opensearch.action.admin.cluster.snapshots.get.GetSnapshotsResponse;
-import org.opensearch.action.admin.cluster.snapshots.restore.RestoreSnapshotRequest;
-import org.opensearch.action.admin.cluster.snapshots.restore.RestoreSnapshotRequestBuilder;
-import org.opensearch.action.admin.cluster.snapshots.restore.RestoreSnapshotResponse;
-import org.opensearch.action.admin.cluster.snapshots.status.SnapshotsStatusRequest;
-import org.opensearch.action.admin.cluster.snapshots.status.SnapshotsStatusRequestBuilder;
-import org.opensearch.action.admin.cluster.snapshots.status.SnapshotsStatusResponse;
-import org.opensearch.action.admin.cluster.state.ClusterStateRequest;
-import org.opensearch.action.admin.cluster.state.ClusterStateRequestBuilder;
-import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
+import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsRequest;
+import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsRequestBuilder;
+import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsResponse;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequestBuilder;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
-import org.opensearch.action.admin.cluster.stats.ClusterStatsRequest;
-import org.opensearch.action.admin.cluster.stats.ClusterStatsRequestBuilder;
-import org.opensearch.action.admin.cluster.stats.ClusterStatsResponse;
-import org.opensearch.action.admin.cluster.storedscripts.DeleteStoredScriptRequest;
-import org.opensearch.action.admin.cluster.storedscripts.DeleteStoredScriptRequestBuilder;
-import org.opensearch.action.admin.cluster.storedscripts.GetStoredScriptRequest;
-import org.opensearch.action.admin.cluster.storedscripts.GetStoredScriptRequestBuilder;
-import org.opensearch.action.admin.cluster.storedscripts.GetStoredScriptResponse;
-import org.opensearch.action.admin.cluster.storedscripts.PutStoredScriptRequest;
-import org.opensearch.action.admin.cluster.storedscripts.PutStoredScriptRequestBuilder;
-import org.opensearch.action.admin.cluster.tasks.PendingClusterTasksRequest;
-import org.opensearch.action.admin.cluster.tasks.PendingClusterTasksRequestBuilder;
-import org.opensearch.action.admin.cluster.tasks.PendingClusterTasksResponse;
-import org.opensearch.action.admin.indices.dangling.delete.DeleteDanglingIndexRequest;
-import org.opensearch.action.admin.indices.dangling.import_index.ImportDanglingIndexRequest;
-import org.opensearch.action.admin.indices.dangling.list.ListDanglingIndicesRequest;
-import org.opensearch.action.admin.indices.dangling.list.ListDanglingIndicesResponse;
-import org.opensearch.action.ingest.DeletePipelineRequest;
-import org.opensearch.action.ingest.DeletePipelineRequestBuilder;
-import org.opensearch.action.ingest.GetPipelineRequest;
-import org.opensearch.action.ingest.GetPipelineRequestBuilder;
-import org.opensearch.action.ingest.GetPipelineResponse;
-import org.opensearch.action.ingest.PutPipelineRequest;
-import org.opensearch.action.ingest.PutPipelineRequestBuilder;
-import org.opensearch.action.ingest.SimulatePipelineRequest;
-import org.opensearch.action.ingest.SimulatePipelineRequestBuilder;
-import org.opensearch.action.ingest.SimulatePipelineResponse;
-import org.opensearch.action.search.DeleteSearchPipelineRequest;
-import org.opensearch.action.search.GetSearchPipelineRequest;
-import org.opensearch.action.search.GetSearchPipelineResponse;
-import org.opensearch.action.search.PutSearchPipelineRequest;
-import org.opensearch.action.support.master.AcknowledgedResponse;
-import org.opensearch.common.bytes.BytesReference;
-import org.opensearch.common.xcontent.XContentType;
-import org.opensearch.tasks.TaskId;
 
 /**
  * Administrative actions/operations against indices.
@@ -193,28 +73,28 @@ public interface ProtobufClusterAdminClient extends ProtobufOpenSearchClient {
     /**
      * Nodes info of the cluster.
     */
-    NodesInfoRequestBuilder prepareNodesInfo(String... nodesIds);
+    ProtobufNodesInfoRequestBuilder prepareNodesInfo(String... nodesIds);
 
-    // /**
-    //  * Nodes stats of the cluster.
-    // *
-    // * @param request The nodes stats request
-    // * @return The result future
-    // * @see org.opensearch.client.Requests#nodesStatsRequest(String...)
-    // */
-    // ActionFuture<NodesStatsResponse> nodesStats(NodesStatsRequest request);
+    /**
+     * Nodes stats of the cluster.
+    *
+    * @param request The nodes stats request
+    * @return The result future
+    * @see org.opensearch.client.Requests#nodesStatsRequest(String...)
+    */
+    ActionFuture<ProtobufNodesStatsResponse> nodesStats(ProtobufNodesStatsRequest request);
 
-    // /**
-    //  * Nodes stats of the cluster.
-    // *
-    // * @param request  The nodes info request
-    // * @param listener A listener to be notified with a result
-    // * @see org.opensearch.client.Requests#nodesStatsRequest(String...)
-    // */
-    // void nodesStats(NodesStatsRequest request, ActionListener<NodesStatsResponse> listener);
+    /**
+     * Nodes stats of the cluster.
+    *
+    * @param request  The nodes info request
+    * @param listener A listener to be notified with a result
+    * @see org.opensearch.client.Requests#nodesStatsRequest(String...)
+    */
+    void nodesStats(ProtobufNodesStatsRequest request, ActionListener<ProtobufNodesStatsResponse> listener);
 
-    // /**
-    //  * Nodes stats of the cluster.
-    // */
-    // NodesStatsRequestBuilder prepareNodesStats(String... nodesIds);
+    /**
+     * Nodes stats of the cluster.
+    */
+    ProtobufNodesStatsRequestBuilder prepareNodesStats(String... nodesIds);
 }
diff --git a/server/src/main/java/org/opensearch/client/ProtobufFilterClient.java b/server/src/main/java/org/opensearch/client/ProtobufFilterClient.java
new file mode 100644
index 0000000000000..d5bbd47379070
--- /dev/null
+++ b/server/src/main/java/org/opensearch/client/ProtobufFilterClient.java
@@ -0,0 +1,74 @@
+/*
+* 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.
+*/
+
+package org.opensearch.client;
+
+import org.opensearch.action.ProtobufActionType;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.ProtobufActionRequest;
+import org.opensearch.action.ProtobufActionResponse;
+import org.opensearch.client.support.ProtobufAbstractClient;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.threadpool.ProtobufThreadPool;
+
+/**
+ * A {@link ProtobufClient} that contains another {@link ProtobufClient} which it
+* uses as its basic source, possibly transforming the requests / responses along the
+* way or providing additional functionality.
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufFilterClient extends ProtobufAbstractClient {
+
+    protected final ProtobufClient in;
+
+    /**
+     * Creates a new ProtobufFilterClient
+    *
+    * @param in the client to delegate to
+    * @see #in()
+    */
+    public ProtobufFilterClient(ProtobufClient in) {
+        this(in.settings(), in.threadPool(), in);
+    }
+
+    /**
+     * A Constructor that allows to pass settings and threadpool separately. This is useful if the
+    * client is a proxy and not yet fully constructed ie. both dependencies are not available yet.
+    */
+    protected ProtobufFilterClient(Settings settings, ProtobufThreadPool threadPool, ProtobufClient in) {
+        super(settings, threadPool);
+        this.in = in;
+    }
+
+    @Override
+    public void close() {
+        in().close();
+    }
+
+    @Override
+    protected <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> void doExecute(
+        ProtobufActionType<Response> action,
+        Request request,
+        ActionListener<Response> listener
+    ) {
+        in().execute(action, request, listener);
+    }
+
+    /**
+     * Returns the delegate {@link ProtobufClient}
+    */
+    protected ProtobufClient in() {
+        return in;
+    }
+
+    @Override
+    public ProtobufClient getRemoteClusterClient(String clusterAlias) {
+        return in.getRemoteClusterClient(clusterAlias);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/client/ProtobufOpenSearchClient.java b/server/src/main/java/org/opensearch/client/ProtobufOpenSearchClient.java
index a8db169724efb..a521ae469deed 100644
--- a/server/src/main/java/org/opensearch/client/ProtobufOpenSearchClient.java
+++ b/server/src/main/java/org/opensearch/client/ProtobufOpenSearchClient.java
@@ -8,16 +8,12 @@
 
 package org.opensearch.client;
 
-import org.opensearch.action.ActionType;
 import org.opensearch.action.ProtobufActionRequest;
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.action.ProtobufActionType;
 import org.opensearch.action.ActionFuture;
 import org.opensearch.action.ActionListener;
-import org.opensearch.action.ActionRequest;
-import org.opensearch.action.ActionResponse;
 import org.opensearch.threadpool.ProtobufThreadPool;
-import org.opensearch.threadpool.ThreadPool;
 
 /**
  * Interface for an OpenSearch client implementation
diff --git a/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java b/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java
index 2368b98e2b5e0..0602740a0e304 100644
--- a/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java
+++ b/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java
@@ -13,49 +13,45 @@
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.action.ProtobufActionType;
 import org.opensearch.action.ActionListener;
-import org.opensearch.action.ActionModule.DynamicActionRegistry;
-import org.opensearch.action.ActionRequest;
-import org.opensearch.action.ActionResponse;
-import org.opensearch.action.support.TransportAction;
-import org.opensearch.client.Client;
-import org.opensearch.client.support.AbstractClient;
+import org.opensearch.action.ActionModule.ProtobufDynamicActionRegistry;
+import org.opensearch.action.support.ProtobufTransportAction;
+import org.opensearch.client.ProtobufClient;
 import org.opensearch.client.support.ProtobufAbstractClient;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.common.io.stream.ProtobufNamedWriteableRegistry;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.tasks.Task;
-import org.opensearch.tasks.TaskListener;
+import org.opensearch.tasks.ProtobufTask;
+import org.opensearch.tasks.ProtobufTaskListener;
 import org.opensearch.threadpool.ProtobufThreadPool;
-import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.RemoteClusterService;
+import org.opensearch.transport.ProtobufRemoteClusterService;
 
 import java.util.function.Supplier;
 
 /**
- * Client that executes actions on the local node.
+ * ProtobufClient that executes actions on the local node.
 *
 * @opensearch.internal
 */
 public class ProtobufNodeClient extends ProtobufAbstractClient {
 
-    private DynamicActionRegistry actionRegistry;
+    private ProtobufDynamicActionRegistry actionRegistry;
     /**
      * The id of the local {@link DiscoveryNode}. Useful for generating task ids from tasks returned by
-    * {@link #executeLocally(ActionType, ActionRequest, TaskListener)}.
+    * {@link #executeLocally(ProtobufActionType, ProtobufActionRequest, ProtobufTaskListener)}.
     */
     private Supplier<String> localNodeId;
-    private RemoteClusterService remoteClusterService;
-    private NamedWriteableRegistry namedWriteableRegistry;
+    private ProtobufRemoteClusterService remoteClusterService;
+    private ProtobufNamedWriteableRegistry namedWriteableRegistry;
 
     public ProtobufNodeClient(Settings settings, ProtobufThreadPool threadPool) {
         super(settings, threadPool);
     }
 
     public void initialize(
-        DynamicActionRegistry actionRegistry,
+        ProtobufDynamicActionRegistry actionRegistry,
         Supplier<String> localNodeId,
-        RemoteClusterService remoteClusterService,
-        NamedWriteableRegistry namedWriteableRegistry
+        ProtobufRemoteClusterService remoteClusterService,
+        ProtobufNamedWriteableRegistry namedWriteableRegistry
     ) {
         this.actionRegistry = actionRegistry;
         this.localNodeId = localNodeId;
@@ -74,16 +70,16 @@ public <Request extends ProtobufActionRequest, Response extends ProtobufActionRe
         Request request,
         ActionListener<Response> listener
     ) {
-        // Discard the task because the Client interface doesn't use it.
+        // Discard the task because the ProtobufClient interface doesn't use it.
         executeLocally(action, request, listener);
     }
 
     /**
-     * Execute an {@link ActionType} locally, returning that {@link Task} used to track it, and linking an {@link ActionListener}.
+     * Execute an {@link ActionType} locally, returning that {@link ProtobufTask} used to track it, and linking an {@link ActionListener}.
     * Prefer this method if you don't need access to the task when listening for the response. This is the method used to implement
-    * the {@link Client} interface.
+    * the {@link ProtobufClient} interface.
     */
-    public <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> Task executeLocally(
+    public <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> ProtobufTask executeLocally(
         ProtobufActionType<Response> action,
         Request request,
         ActionListener<Response> listener
@@ -92,36 +88,40 @@ public <Request extends ProtobufActionRequest, Response extends ProtobufActionRe
     }
 
     /**
-     * Execute an {@link ActionType} locally, returning that {@link Task} used to track it, and linking an {@link TaskListener}. Prefer this
+     * Execute an {@link ActionType} locally, returning that {@link ProtobufTask} used to track it, and linking an {@link ProtobufTaskListener}. Prefer this
     * method if you need access to the task when listening for the response.
     */
-    public <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> Task executeLocally(
+    public <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> ProtobufTask executeLocally(
         ProtobufActionType<Response> action,
         Request request,
-        TaskListener<Response> listener
+        ProtobufTaskListener<Response> listener
     ) {
         return transportAction(action).execute(request, listener);
     }
 
     /**
      * The id of the local {@link DiscoveryNode}. Useful for generating task ids from tasks returned by
-    * {@link #executeLocally(ProtobufActionType, ProtobufActionRequest, TaskListener)}.
+    * {@link #executeLocally(ProtobufActionType, ProtobufActionRequest, ProtobufTaskListener)}.
     */
     public String getLocalNodeId() {
         return localNodeId.get();
     }
 
     /**
-     * Get the {@link TransportAction} for an {@link ActionType}, throwing exceptions if the action isn't available.
+     * Get the {@link ProtobufTransportAction} for an {@link ActionType}, throwing exceptions if the action isn't available.
     */
     @SuppressWarnings("unchecked")
-    private <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> TransportAction<Request, Response> transportAction(
-        ProtobufActionType<Response> action
-    ) {
+    private <
+        Request extends ProtobufActionRequest,
+        Response extends ProtobufActionResponse> ProtobufTransportAction<Request, Response> transportAction(
+            ProtobufActionType<Response> action
+        ) {
         if (actionRegistry == null) {
             throw new IllegalStateException("NodeClient has not been initialized");
         }
-        TransportAction<Request, Response> transportAction = (TransportAction<Request, Response>) actionRegistry.get(action);
+        ProtobufTransportAction<Request, Response> transportAction = (ProtobufTransportAction<Request, Response>) actionRegistry.get(
+            action
+        );
         if (transportAction == null) {
             throw new IllegalStateException("failed to find action [" + action + "] to execute");
         }
@@ -129,11 +129,11 @@ private <Request extends ProtobufActionRequest, Response extends ProtobufActionR
     }
 
     @Override
-    public Client getRemoteClusterClient(String clusterAlias) {
+    public ProtobufClient getRemoteClusterClient(String clusterAlias) {
         return remoteClusterService.getRemoteClusterClient(threadPool(), clusterAlias);
     }
 
-    public NamedWriteableRegistry getNamedWriteableRegistry() {
+    public ProtobufNamedWriteableRegistry getNamedWriteableRegistry() {
         return namedWriteableRegistry;
     }
 }
diff --git a/server/src/main/java/org/opensearch/client/support/AbstractClient.java b/server/src/main/java/org/opensearch/client/support/AbstractClient.java
index e43f96eeddc7c..40489e29ed9b5 100644
--- a/server/src/main/java/org/opensearch/client/support/AbstractClient.java
+++ b/server/src/main/java/org/opensearch/client/support/AbstractClient.java
@@ -67,8 +67,6 @@
 import org.opensearch.action.admin.cluster.node.info.NodesInfoRequest;
 import org.opensearch.action.admin.cluster.node.info.NodesInfoRequestBuilder;
 import org.opensearch.action.admin.cluster.node.info.NodesInfoResponse;
-import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequest;
-import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoResponse;
 import org.opensearch.action.admin.cluster.node.reload.NodesReloadSecureSettingsAction;
 import org.opensearch.action.admin.cluster.node.reload.NodesReloadSecureSettingsRequestBuilder;
 import org.opensearch.action.admin.cluster.node.stats.NodesStatsAction;
@@ -166,8 +164,6 @@
 import org.opensearch.action.admin.cluster.state.ClusterStateRequest;
 import org.opensearch.action.admin.cluster.state.ClusterStateRequestBuilder;
 import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
-import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
-import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
 import org.opensearch.action.admin.cluster.stats.ClusterStatsAction;
 import org.opensearch.action.admin.cluster.stats.ClusterStatsRequest;
 import org.opensearch.action.admin.cluster.stats.ClusterStatsRequestBuilder;
@@ -880,21 +876,6 @@ public NodesInfoRequestBuilder prepareNodesInfo(String... nodesIds) {
             return new NodesInfoRequestBuilder(this, NodesInfoAction.INSTANCE).setNodesIds(nodesIds);
         }
 
-        @Override
-        public ActionFuture<ProtobufNodesInfoResponse> nodesInfo(final ProtobufNodesInfoRequest request) {
-            return execute(NodesInfoAction.INSTANCE, request);
-        }
-
-        @Override
-        public void nodesInfo(final NodesInfoRequest request, final ActionListener<NodesInfoResponse> listener) {
-            execute(NodesInfoAction.INSTANCE, request, listener);
-        }
-
-        @Override
-        public NodesInfoRequestBuilder prepareNodesInfo(String... nodesIds) {
-            return new NodesInfoRequestBuilder(this, NodesInfoAction.INSTANCE).setNodesIds(nodesIds);
-        }
-
         @Override
         public ActionFuture<NodesStatsResponse> nodesStats(final NodesStatsRequest request) {
             return execute(NodesStatsAction.INSTANCE, request);
diff --git a/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java b/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
index d069c0edb0077..ae47220331874 100644
--- a/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
+++ b/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
@@ -12,395 +12,30 @@
 import org.apache.logging.log4j.Logger;
 import org.opensearch.action.ActionFuture;
 import org.opensearch.action.ActionListener;
-import org.opensearch.action.ActionRequest;
-import org.opensearch.action.ActionResponse;
-import org.opensearch.action.ActionType;
 import org.opensearch.action.ProtobufActionRequest;
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.action.ProtobufActionType;
-import org.opensearch.action.admin.cluster.allocation.ClusterAllocationExplainAction;
-import org.opensearch.action.admin.cluster.allocation.ClusterAllocationExplainRequest;
-import org.opensearch.action.admin.cluster.allocation.ClusterAllocationExplainRequestBuilder;
-import org.opensearch.action.admin.cluster.allocation.ClusterAllocationExplainResponse;
-import org.opensearch.action.admin.cluster.decommission.awareness.delete.DeleteDecommissionStateAction;
-import org.opensearch.action.admin.cluster.decommission.awareness.delete.DeleteDecommissionStateRequest;
-import org.opensearch.action.admin.cluster.decommission.awareness.delete.DeleteDecommissionStateRequestBuilder;
-import org.opensearch.action.admin.cluster.decommission.awareness.delete.DeleteDecommissionStateResponse;
-import org.opensearch.action.admin.cluster.decommission.awareness.get.GetDecommissionStateAction;
-import org.opensearch.action.admin.cluster.decommission.awareness.get.GetDecommissionStateRequest;
-import org.opensearch.action.admin.cluster.decommission.awareness.get.GetDecommissionStateRequestBuilder;
-import org.opensearch.action.admin.cluster.decommission.awareness.get.GetDecommissionStateResponse;
-import org.opensearch.action.admin.cluster.decommission.awareness.put.DecommissionAction;
-import org.opensearch.action.admin.cluster.decommission.awareness.put.DecommissionRequest;
-import org.opensearch.action.admin.cluster.decommission.awareness.put.DecommissionRequestBuilder;
-import org.opensearch.action.admin.cluster.decommission.awareness.put.DecommissionResponse;
-import org.opensearch.action.admin.cluster.health.ClusterHealthAction;
-import org.opensearch.action.admin.cluster.health.ClusterHealthRequest;
-import org.opensearch.action.admin.cluster.health.ClusterHealthRequestBuilder;
-import org.opensearch.action.admin.cluster.health.ClusterHealthResponse;
-import org.opensearch.action.admin.cluster.node.hotthreads.NodesHotThreadsAction;
-import org.opensearch.action.admin.cluster.node.hotthreads.NodesHotThreadsRequest;
-import org.opensearch.action.admin.cluster.node.hotthreads.NodesHotThreadsRequestBuilder;
-import org.opensearch.action.admin.cluster.node.hotthreads.NodesHotThreadsResponse;
-import org.opensearch.action.admin.cluster.node.info.NodesInfoAction;
-import org.opensearch.action.admin.cluster.node.info.NodesInfoRequest;
-import org.opensearch.action.admin.cluster.node.info.NodesInfoRequestBuilder;
-import org.opensearch.action.admin.cluster.node.info.NodesInfoResponse;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoAction;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequestBuilder;
 import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequest;
 import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoResponse;
-import org.opensearch.action.admin.cluster.node.reload.NodesReloadSecureSettingsAction;
-import org.opensearch.action.admin.cluster.node.reload.NodesReloadSecureSettingsRequestBuilder;
-import org.opensearch.action.admin.cluster.node.stats.NodesStatsAction;
-import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
-import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequestBuilder;
-import org.opensearch.action.admin.cluster.node.stats.NodesStatsResponse;
-import org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksAction;
-import org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksRequest;
-import org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksRequestBuilder;
-import org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksResponse;
-import org.opensearch.action.admin.cluster.node.tasks.get.GetTaskAction;
-import org.opensearch.action.admin.cluster.node.tasks.get.GetTaskRequest;
-import org.opensearch.action.admin.cluster.node.tasks.get.GetTaskRequestBuilder;
-import org.opensearch.action.admin.cluster.node.tasks.get.GetTaskResponse;
-import org.opensearch.action.admin.cluster.node.tasks.list.ListTasksAction;
-import org.opensearch.action.admin.cluster.node.tasks.list.ListTasksRequest;
-import org.opensearch.action.admin.cluster.node.tasks.list.ListTasksRequestBuilder;
-import org.opensearch.action.admin.cluster.node.tasks.list.ListTasksResponse;
-import org.opensearch.action.admin.cluster.node.usage.NodesUsageAction;
-import org.opensearch.action.admin.cluster.node.usage.NodesUsageRequest;
-import org.opensearch.action.admin.cluster.node.usage.NodesUsageRequestBuilder;
-import org.opensearch.action.admin.cluster.node.usage.NodesUsageResponse;
-import org.opensearch.action.admin.cluster.remotestore.restore.RestoreRemoteStoreAction;
-import org.opensearch.action.admin.cluster.remotestore.restore.RestoreRemoteStoreRequest;
-import org.opensearch.action.admin.cluster.remotestore.restore.RestoreRemoteStoreResponse;
-import org.opensearch.action.admin.cluster.repositories.cleanup.CleanupRepositoryAction;
-import org.opensearch.action.admin.cluster.repositories.cleanup.CleanupRepositoryRequest;
-import org.opensearch.action.admin.cluster.repositories.cleanup.CleanupRepositoryRequestBuilder;
-import org.opensearch.action.admin.cluster.repositories.cleanup.CleanupRepositoryResponse;
-import org.opensearch.action.admin.cluster.repositories.delete.DeleteRepositoryAction;
-import org.opensearch.action.admin.cluster.repositories.delete.DeleteRepositoryRequest;
-import org.opensearch.action.admin.cluster.repositories.delete.DeleteRepositoryRequestBuilder;
-import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesAction;
-import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesRequest;
-import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesRequestBuilder;
-import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesResponse;
-import org.opensearch.action.admin.cluster.repositories.put.PutRepositoryAction;
-import org.opensearch.action.admin.cluster.repositories.put.PutRepositoryRequest;
-import org.opensearch.action.admin.cluster.repositories.put.PutRepositoryRequestBuilder;
-import org.opensearch.action.admin.cluster.repositories.verify.VerifyRepositoryAction;
-import org.opensearch.action.admin.cluster.repositories.verify.VerifyRepositoryRequest;
-import org.opensearch.action.admin.cluster.repositories.verify.VerifyRepositoryRequestBuilder;
-import org.opensearch.action.admin.cluster.repositories.verify.VerifyRepositoryResponse;
-import org.opensearch.action.admin.cluster.reroute.ClusterRerouteAction;
-import org.opensearch.action.admin.cluster.reroute.ClusterRerouteRequest;
-import org.opensearch.action.admin.cluster.reroute.ClusterRerouteRequestBuilder;
-import org.opensearch.action.admin.cluster.reroute.ClusterRerouteResponse;
-import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsAction;
-import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
-import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequestBuilder;
-import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsResponse;
-import org.opensearch.action.admin.cluster.shards.ClusterSearchShardsAction;
-import org.opensearch.action.admin.cluster.shards.ClusterSearchShardsRequest;
-import org.opensearch.action.admin.cluster.shards.ClusterSearchShardsRequestBuilder;
-import org.opensearch.action.admin.cluster.shards.ClusterSearchShardsResponse;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.delete.ClusterDeleteWeightedRoutingAction;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.delete.ClusterDeleteWeightedRoutingRequest;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.delete.ClusterDeleteWeightedRoutingRequestBuilder;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.delete.ClusterDeleteWeightedRoutingResponse;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.get.ClusterGetWeightedRoutingAction;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.get.ClusterGetWeightedRoutingRequest;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.get.ClusterGetWeightedRoutingRequestBuilder;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.get.ClusterGetWeightedRoutingResponse;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.put.ClusterAddWeightedRoutingAction;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.put.ClusterPutWeightedRoutingRequest;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.put.ClusterPutWeightedRoutingRequestBuilder;
-import org.opensearch.action.admin.cluster.shards.routing.weighted.put.ClusterPutWeightedRoutingResponse;
-import org.opensearch.action.admin.cluster.snapshots.clone.CloneSnapshotAction;
-import org.opensearch.action.admin.cluster.snapshots.clone.CloneSnapshotRequest;
-import org.opensearch.action.admin.cluster.snapshots.clone.CloneSnapshotRequestBuilder;
-import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotAction;
-import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotRequest;
-import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotRequestBuilder;
-import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotResponse;
-import org.opensearch.action.admin.cluster.snapshots.delete.DeleteSnapshotAction;
-import org.opensearch.action.admin.cluster.snapshots.delete.DeleteSnapshotRequest;
-import org.opensearch.action.admin.cluster.snapshots.delete.DeleteSnapshotRequestBuilder;
-import org.opensearch.action.admin.cluster.snapshots.get.GetSnapshotsAction;
-import org.opensearch.action.admin.cluster.snapshots.get.GetSnapshotsRequest;
-import org.opensearch.action.admin.cluster.snapshots.get.GetSnapshotsRequestBuilder;
-import org.opensearch.action.admin.cluster.snapshots.get.GetSnapshotsResponse;
-import org.opensearch.action.admin.cluster.snapshots.restore.RestoreSnapshotAction;
-import org.opensearch.action.admin.cluster.snapshots.restore.RestoreSnapshotRequest;
-import org.opensearch.action.admin.cluster.snapshots.restore.RestoreSnapshotRequestBuilder;
-import org.opensearch.action.admin.cluster.snapshots.restore.RestoreSnapshotResponse;
-import org.opensearch.action.admin.cluster.snapshots.status.SnapshotsStatusAction;
-import org.opensearch.action.admin.cluster.snapshots.status.SnapshotsStatusRequest;
-import org.opensearch.action.admin.cluster.snapshots.status.SnapshotsStatusRequestBuilder;
-import org.opensearch.action.admin.cluster.snapshots.status.SnapshotsStatusResponse;
-import org.opensearch.action.admin.cluster.state.ClusterStateAction;
-import org.opensearch.action.admin.cluster.state.ClusterStateRequest;
-import org.opensearch.action.admin.cluster.state.ClusterStateRequestBuilder;
-import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
+import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsAction;
+import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsRequest;
+import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsRequestBuilder;
+import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsResponse;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateAction;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequestBuilder;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
-import org.opensearch.action.admin.cluster.stats.ClusterStatsAction;
-import org.opensearch.action.admin.cluster.stats.ClusterStatsRequest;
-import org.opensearch.action.admin.cluster.stats.ClusterStatsRequestBuilder;
-import org.opensearch.action.admin.cluster.stats.ClusterStatsResponse;
-import org.opensearch.action.admin.cluster.storedscripts.DeleteStoredScriptAction;
-import org.opensearch.action.admin.cluster.storedscripts.DeleteStoredScriptRequest;
-import org.opensearch.action.admin.cluster.storedscripts.DeleteStoredScriptRequestBuilder;
-import org.opensearch.action.admin.cluster.storedscripts.GetStoredScriptAction;
-import org.opensearch.action.admin.cluster.storedscripts.GetStoredScriptRequest;
-import org.opensearch.action.admin.cluster.storedscripts.GetStoredScriptRequestBuilder;
-import org.opensearch.action.admin.cluster.storedscripts.GetStoredScriptResponse;
-import org.opensearch.action.admin.cluster.storedscripts.PutStoredScriptAction;
-import org.opensearch.action.admin.cluster.storedscripts.PutStoredScriptRequest;
-import org.opensearch.action.admin.cluster.storedscripts.PutStoredScriptRequestBuilder;
-import org.opensearch.action.admin.cluster.tasks.PendingClusterTasksAction;
-import org.opensearch.action.admin.cluster.tasks.PendingClusterTasksRequest;
-import org.opensearch.action.admin.cluster.tasks.PendingClusterTasksRequestBuilder;
-import org.opensearch.action.admin.cluster.tasks.PendingClusterTasksResponse;
-import org.opensearch.action.admin.indices.alias.IndicesAliasesAction;
-import org.opensearch.action.admin.indices.alias.IndicesAliasesRequest;
-import org.opensearch.action.admin.indices.alias.IndicesAliasesRequestBuilder;
-import org.opensearch.action.admin.indices.alias.get.GetAliasesAction;
-import org.opensearch.action.admin.indices.alias.get.GetAliasesRequest;
-import org.opensearch.action.admin.indices.alias.get.GetAliasesRequestBuilder;
-import org.opensearch.action.admin.indices.alias.get.GetAliasesResponse;
-import org.opensearch.action.admin.indices.analyze.AnalyzeAction;
-import org.opensearch.action.admin.indices.analyze.AnalyzeRequestBuilder;
-import org.opensearch.action.admin.indices.cache.clear.ClearIndicesCacheAction;
-import org.opensearch.action.admin.indices.cache.clear.ClearIndicesCacheRequest;
-import org.opensearch.action.admin.indices.cache.clear.ClearIndicesCacheRequestBuilder;
-import org.opensearch.action.admin.indices.cache.clear.ClearIndicesCacheResponse;
-import org.opensearch.action.admin.indices.close.CloseIndexAction;
-import org.opensearch.action.admin.indices.close.CloseIndexRequest;
-import org.opensearch.action.admin.indices.close.CloseIndexRequestBuilder;
-import org.opensearch.action.admin.indices.close.CloseIndexResponse;
-import org.opensearch.action.admin.indices.create.CreateIndexAction;
-import org.opensearch.action.admin.indices.create.CreateIndexRequest;
-import org.opensearch.action.admin.indices.create.CreateIndexRequestBuilder;
-import org.opensearch.action.admin.indices.create.CreateIndexResponse;
-import org.opensearch.action.admin.indices.dangling.delete.DeleteDanglingIndexAction;
-import org.opensearch.action.admin.indices.dangling.delete.DeleteDanglingIndexRequest;
-import org.opensearch.action.admin.indices.dangling.import_index.ImportDanglingIndexAction;
-import org.opensearch.action.admin.indices.dangling.import_index.ImportDanglingIndexRequest;
-import org.opensearch.action.admin.indices.dangling.list.ListDanglingIndicesAction;
-import org.opensearch.action.admin.indices.dangling.list.ListDanglingIndicesRequest;
-import org.opensearch.action.admin.indices.dangling.list.ListDanglingIndicesResponse;
-import org.opensearch.action.admin.indices.datastream.CreateDataStreamAction;
-import org.opensearch.action.admin.indices.datastream.DeleteDataStreamAction;
-import org.opensearch.action.admin.indices.datastream.GetDataStreamAction;
-import org.opensearch.action.admin.indices.delete.DeleteIndexAction;
-import org.opensearch.action.admin.indices.delete.DeleteIndexRequest;
-import org.opensearch.action.admin.indices.delete.DeleteIndexRequestBuilder;
-import org.opensearch.action.admin.indices.exists.indices.IndicesExistsAction;
-import org.opensearch.action.admin.indices.exists.indices.IndicesExistsRequest;
-import org.opensearch.action.admin.indices.exists.indices.IndicesExistsRequestBuilder;
-import org.opensearch.action.admin.indices.exists.indices.IndicesExistsResponse;
-import org.opensearch.action.admin.indices.flush.FlushAction;
-import org.opensearch.action.admin.indices.flush.FlushRequest;
-import org.opensearch.action.admin.indices.flush.FlushRequestBuilder;
-import org.opensearch.action.admin.indices.flush.FlushResponse;
-import org.opensearch.action.admin.indices.forcemerge.ForceMergeAction;
-import org.opensearch.action.admin.indices.forcemerge.ForceMergeRequest;
-import org.opensearch.action.admin.indices.forcemerge.ForceMergeRequestBuilder;
-import org.opensearch.action.admin.indices.forcemerge.ForceMergeResponse;
-import org.opensearch.action.admin.indices.get.GetIndexAction;
-import org.opensearch.action.admin.indices.get.GetIndexRequest;
-import org.opensearch.action.admin.indices.get.GetIndexRequestBuilder;
-import org.opensearch.action.admin.indices.get.GetIndexResponse;
-import org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsAction;
-import org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsRequest;
-import org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsRequestBuilder;
-import org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsResponse;
-import org.opensearch.action.admin.indices.mapping.get.GetMappingsAction;
-import org.opensearch.action.admin.indices.mapping.get.GetMappingsRequest;
-import org.opensearch.action.admin.indices.mapping.get.GetMappingsRequestBuilder;
-import org.opensearch.action.admin.indices.mapping.get.GetMappingsResponse;
-import org.opensearch.action.admin.indices.mapping.put.PutMappingAction;
-import org.opensearch.action.admin.indices.mapping.put.PutMappingRequest;
-import org.opensearch.action.admin.indices.mapping.put.PutMappingRequestBuilder;
-import org.opensearch.action.admin.indices.open.OpenIndexAction;
-import org.opensearch.action.admin.indices.open.OpenIndexRequest;
-import org.opensearch.action.admin.indices.open.OpenIndexRequestBuilder;
-import org.opensearch.action.admin.indices.open.OpenIndexResponse;
-import org.opensearch.action.admin.indices.readonly.AddIndexBlockAction;
-import org.opensearch.action.admin.indices.readonly.AddIndexBlockRequest;
-import org.opensearch.action.admin.indices.readonly.AddIndexBlockRequestBuilder;
-import org.opensearch.action.admin.indices.readonly.AddIndexBlockResponse;
-import org.opensearch.action.admin.indices.recovery.RecoveryAction;
-import org.opensearch.action.admin.indices.recovery.RecoveryRequest;
-import org.opensearch.action.admin.indices.recovery.RecoveryRequestBuilder;
-import org.opensearch.action.admin.indices.recovery.RecoveryResponse;
-import org.opensearch.action.admin.indices.refresh.RefreshAction;
-import org.opensearch.action.admin.indices.refresh.RefreshRequest;
-import org.opensearch.action.admin.indices.refresh.RefreshRequestBuilder;
-import org.opensearch.action.admin.indices.refresh.RefreshResponse;
-import org.opensearch.action.admin.indices.resolve.ResolveIndexAction;
-import org.opensearch.action.admin.indices.rollover.RolloverAction;
-import org.opensearch.action.admin.indices.rollover.RolloverRequest;
-import org.opensearch.action.admin.indices.rollover.RolloverRequestBuilder;
-import org.opensearch.action.admin.indices.rollover.RolloverResponse;
-import org.opensearch.action.admin.indices.replication.SegmentReplicationStatsAction;
-import org.opensearch.action.admin.indices.replication.SegmentReplicationStatsRequest;
-import org.opensearch.action.admin.indices.replication.SegmentReplicationStatsRequestBuilder;
-import org.opensearch.action.admin.indices.replication.SegmentReplicationStatsResponse;
-import org.opensearch.action.admin.indices.segments.IndicesSegmentResponse;
-import org.opensearch.action.admin.indices.segments.IndicesSegmentsAction;
-import org.opensearch.action.admin.indices.segments.IndicesSegmentsRequest;
-import org.opensearch.action.admin.indices.segments.IndicesSegmentsRequestBuilder;
-import org.opensearch.action.admin.indices.segments.PitSegmentsAction;
-import org.opensearch.action.admin.indices.segments.PitSegmentsRequest;
-import org.opensearch.action.admin.indices.settings.get.GetSettingsAction;
-import org.opensearch.action.admin.indices.settings.get.GetSettingsRequest;
-import org.opensearch.action.admin.indices.settings.get.GetSettingsRequestBuilder;
-import org.opensearch.action.admin.indices.settings.get.GetSettingsResponse;
-import org.opensearch.action.admin.indices.settings.put.UpdateSettingsAction;
-import org.opensearch.action.admin.indices.settings.put.UpdateSettingsRequest;
-import org.opensearch.action.admin.indices.settings.put.UpdateSettingsRequestBuilder;
-import org.opensearch.action.admin.indices.shards.IndicesShardStoreRequestBuilder;
-import org.opensearch.action.admin.indices.shards.IndicesShardStoresAction;
-import org.opensearch.action.admin.indices.shards.IndicesShardStoresRequest;
-import org.opensearch.action.admin.indices.shards.IndicesShardStoresResponse;
-import org.opensearch.action.admin.indices.shrink.ResizeAction;
-import org.opensearch.action.admin.indices.shrink.ResizeRequest;
-import org.opensearch.action.admin.indices.shrink.ResizeRequestBuilder;
-import org.opensearch.action.admin.indices.shrink.ResizeResponse;
-import org.opensearch.action.admin.indices.stats.IndicesStatsAction;
-import org.opensearch.action.admin.indices.stats.IndicesStatsRequest;
-import org.opensearch.action.admin.indices.stats.IndicesStatsRequestBuilder;
-import org.opensearch.action.admin.indices.stats.IndicesStatsResponse;
-import org.opensearch.action.admin.indices.template.delete.DeleteIndexTemplateAction;
-import org.opensearch.action.admin.indices.template.delete.DeleteIndexTemplateRequest;
-import org.opensearch.action.admin.indices.template.delete.DeleteIndexTemplateRequestBuilder;
-import org.opensearch.action.admin.indices.template.get.GetIndexTemplatesAction;
-import org.opensearch.action.admin.indices.template.get.GetIndexTemplatesRequest;
-import org.opensearch.action.admin.indices.template.get.GetIndexTemplatesRequestBuilder;
-import org.opensearch.action.admin.indices.template.get.GetIndexTemplatesResponse;
-import org.opensearch.action.admin.indices.template.put.PutIndexTemplateAction;
-import org.opensearch.action.admin.indices.template.put.PutIndexTemplateRequest;
-import org.opensearch.action.admin.indices.template.put.PutIndexTemplateRequestBuilder;
-import org.opensearch.action.admin.indices.upgrade.get.UpgradeStatusAction;
-import org.opensearch.action.admin.indices.upgrade.get.UpgradeStatusRequest;
-import org.opensearch.action.admin.indices.upgrade.get.UpgradeStatusRequestBuilder;
-import org.opensearch.action.admin.indices.upgrade.get.UpgradeStatusResponse;
-import org.opensearch.action.admin.indices.upgrade.post.UpgradeAction;
-import org.opensearch.action.admin.indices.upgrade.post.UpgradeRequest;
-import org.opensearch.action.admin.indices.upgrade.post.UpgradeRequestBuilder;
-import org.opensearch.action.admin.indices.upgrade.post.UpgradeResponse;
-import org.opensearch.action.admin.indices.validate.query.ValidateQueryAction;
-import org.opensearch.action.admin.indices.validate.query.ValidateQueryRequest;
-import org.opensearch.action.admin.indices.validate.query.ValidateQueryRequestBuilder;
-import org.opensearch.action.admin.indices.validate.query.ValidateQueryResponse;
-import org.opensearch.action.bulk.BulkAction;
-import org.opensearch.action.bulk.BulkRequest;
-import org.opensearch.action.bulk.BulkRequestBuilder;
-import org.opensearch.action.bulk.BulkResponse;
-import org.opensearch.action.delete.DeleteAction;
-import org.opensearch.action.delete.DeleteRequest;
-import org.opensearch.action.delete.DeleteRequestBuilder;
-import org.opensearch.action.delete.DeleteResponse;
-import org.opensearch.action.explain.ExplainAction;
-import org.opensearch.action.explain.ExplainRequest;
-import org.opensearch.action.explain.ExplainRequestBuilder;
-import org.opensearch.action.explain.ExplainResponse;
-import org.opensearch.action.fieldcaps.FieldCapabilitiesAction;
-import org.opensearch.action.fieldcaps.FieldCapabilitiesRequest;
-import org.opensearch.action.fieldcaps.FieldCapabilitiesRequestBuilder;
-import org.opensearch.action.fieldcaps.FieldCapabilitiesResponse;
-import org.opensearch.action.get.GetAction;
-import org.opensearch.action.get.GetRequest;
-import org.opensearch.action.get.GetRequestBuilder;
-import org.opensearch.action.get.GetResponse;
-import org.opensearch.action.get.MultiGetAction;
-import org.opensearch.action.get.MultiGetRequest;
-import org.opensearch.action.get.MultiGetRequestBuilder;
-import org.opensearch.action.get.MultiGetResponse;
-import org.opensearch.action.index.IndexAction;
-import org.opensearch.action.index.IndexRequest;
-import org.opensearch.action.index.IndexRequestBuilder;
-import org.opensearch.action.index.IndexResponse;
-import org.opensearch.action.ingest.DeletePipelineAction;
-import org.opensearch.action.ingest.DeletePipelineRequest;
-import org.opensearch.action.ingest.DeletePipelineRequestBuilder;
-import org.opensearch.action.ingest.GetPipelineAction;
-import org.opensearch.action.ingest.GetPipelineRequest;
-import org.opensearch.action.ingest.GetPipelineRequestBuilder;
-import org.opensearch.action.ingest.GetPipelineResponse;
-import org.opensearch.action.ingest.PutPipelineAction;
-import org.opensearch.action.ingest.PutPipelineRequest;
-import org.opensearch.action.ingest.PutPipelineRequestBuilder;
-import org.opensearch.action.ingest.SimulatePipelineAction;
-import org.opensearch.action.ingest.SimulatePipelineRequest;
-import org.opensearch.action.ingest.SimulatePipelineRequestBuilder;
-import org.opensearch.action.ingest.SimulatePipelineResponse;
-import org.opensearch.action.search.ClearScrollAction;
-import org.opensearch.action.search.ClearScrollRequest;
-import org.opensearch.action.search.ClearScrollRequestBuilder;
-import org.opensearch.action.search.ClearScrollResponse;
-import org.opensearch.action.search.CreatePitAction;
-import org.opensearch.action.search.CreatePitRequest;
-import org.opensearch.action.search.CreatePitResponse;
-import org.opensearch.action.search.DeletePitAction;
-import org.opensearch.action.search.DeletePitRequest;
-import org.opensearch.action.search.DeletePitResponse;
-import org.opensearch.action.search.DeleteSearchPipelineAction;
-import org.opensearch.action.search.DeleteSearchPipelineRequest;
-import org.opensearch.action.search.GetAllPitNodesRequest;
-import org.opensearch.action.search.GetAllPitNodesResponse;
-import org.opensearch.action.search.GetSearchPipelineAction;
-import org.opensearch.action.search.GetSearchPipelineRequest;
-import org.opensearch.action.search.GetSearchPipelineResponse;
-import org.opensearch.action.search.MultiSearchAction;
-import org.opensearch.action.search.MultiSearchRequest;
-import org.opensearch.action.search.MultiSearchRequestBuilder;
-import org.opensearch.action.search.MultiSearchResponse;
-import org.opensearch.action.search.GetAllPitsAction;
-import org.opensearch.action.search.PutSearchPipelineAction;
-import org.opensearch.action.search.PutSearchPipelineRequest;
-import org.opensearch.action.search.SearchAction;
-import org.opensearch.action.search.SearchRequest;
-import org.opensearch.action.search.SearchRequestBuilder;
-import org.opensearch.action.search.SearchResponse;
-import org.opensearch.action.search.SearchScrollAction;
-import org.opensearch.action.search.SearchScrollRequest;
-import org.opensearch.action.search.SearchScrollRequestBuilder;
 import org.opensearch.action.support.PlainActionFuture;
-import org.opensearch.action.support.master.AcknowledgedResponse;
-import org.opensearch.action.termvectors.MultiTermVectorsAction;
-import org.opensearch.action.termvectors.MultiTermVectorsRequest;
-import org.opensearch.action.termvectors.MultiTermVectorsRequestBuilder;
-import org.opensearch.action.termvectors.MultiTermVectorsResponse;
-import org.opensearch.action.termvectors.TermVectorsAction;
-import org.opensearch.action.termvectors.TermVectorsRequest;
-import org.opensearch.action.termvectors.TermVectorsRequestBuilder;
-import org.opensearch.action.termvectors.TermVectorsResponse;
-import org.opensearch.action.update.UpdateAction;
-import org.opensearch.action.update.UpdateRequest;
-import org.opensearch.action.update.UpdateRequestBuilder;
-import org.opensearch.action.update.UpdateResponse;
-import org.opensearch.client.AdminClient;
-import org.opensearch.client.Client;
-import org.opensearch.client.ClusterAdminClient;
-import org.opensearch.client.FilterClient;
-import org.opensearch.client.IndicesAdminClient;
-import org.opensearch.client.OpenSearchClient;
-import org.opensearch.client.ProtobufAdminClient;
 import org.opensearch.client.ProtobufClient;
+import org.opensearch.client.ProtobufFilterClient;
+import org.opensearch.client.ProtobufAdminClient;
 import org.opensearch.client.ProtobufClusterAdminClient;
 import org.opensearch.client.ProtobufOpenSearchClient;
-import org.opensearch.cluster.metadata.IndexMetadata.APIBlock;
-import org.opensearch.common.Nullable;
-import org.opensearch.common.bytes.BytesReference;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.common.xcontent.XContentType;
-import org.opensearch.tasks.TaskId;
 import org.opensearch.threadpool.ProtobufThreadPool;
-import org.opensearch.threadpool.ThreadPool;
 
 import java.util.Map;
 
@@ -489,6 +124,11 @@ static class ClusterAdmin implements ProtobufClusterAdminClient {
             this.client = client;
         }
 
+        @Override
+        public ProtobufThreadPool threadPool() {
+            return client.threadPool();
+        }
+
         @Override
         public <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> ActionFuture<Response> execute(
             ProtobufActionType<Response> action,
@@ -516,58 +156,48 @@ public void state(final ProtobufClusterStateRequest request, final ActionListene
             execute(ProtobufClusterStateAction.INSTANCE, request, listener);
         }
 
+        @Override
+        public ProtobufClusterStateRequestBuilder prepareState() {
+            return new ProtobufClusterStateRequestBuilder(this, ProtobufClusterStateAction.INSTANCE);
+        }
+
         @Override
         public ActionFuture<ProtobufNodesInfoResponse> nodesInfo(final ProtobufNodesInfoRequest request) {
-            return execute(NodesInfoAction.INSTANCE, request);
+            return execute(ProtobufNodesInfoAction.INSTANCE, request);
         }
 
         @Override
         public void nodesInfo(final ProtobufNodesInfoRequest request, final ActionListener<ProtobufNodesInfoResponse> listener) {
-            execute(NodesInfoAction.INSTANCE, request, listener);
+            execute(ProtobufNodesInfoAction.INSTANCE, request, listener);
         }
 
         @Override
-        public NodesInfoRequestBuilder prepareNodesInfo(String... nodesIds) {
-            return new NodesInfoRequestBuilder(this, NodesInfoAction.INSTANCE).setNodesIds(nodesIds);
+        public ProtobufNodesInfoRequestBuilder prepareNodesInfo(String... nodesIds) {
+            return new ProtobufNodesInfoRequestBuilder(this, ProtobufNodesInfoAction.INSTANCE).setNodesIds(nodesIds);
         }
 
         @Override
-        public ActionFuture<ProtobufNodesInfoResponse> nodesInfo(final ProtobufNodesInfoRequest request) {
-            return execute(NodesInfoAction.INSTANCE, request);
+        public ActionFuture<ProtobufNodesStatsResponse> nodesStats(final ProtobufNodesStatsRequest request) {
+            return execute(ProtobufNodesStatsAction.INSTANCE, request);
         }
 
         @Override
-        public void nodesInfo(final ProtobufNodesInfoRequest request, final ActionListener<ProtobufNodesInfoResponse> listener) {
-            execute(NodesInfoAction.INSTANCE, request, listener);
+        public void nodesStats(final ProtobufNodesStatsRequest request, final ActionListener<ProtobufNodesStatsResponse> listener) {
+            execute(ProtobufNodesStatsAction.INSTANCE, request, listener);
         }
 
         @Override
-        public NodesInfoRequestBuilder prepareNodesInfo(String... nodesIds) {
-            return new NodesInfoRequestBuilder(this, NodesInfoAction.INSTANCE).setNodesIds(nodesIds);
+        public ProtobufNodesStatsRequestBuilder prepareNodesStats(String... nodesIds) {
+            return new ProtobufNodesStatsRequestBuilder(this, ProtobufNodesStatsAction.INSTANCE).setNodesIds(nodesIds);
         }
-
-        // @Override
-        // public ActionFuture<NodesStatsResponse> nodesStats(final NodesStatsRequest request) {
-        //     return execute(NodesStatsAction.INSTANCE, request);
-        // }
-
-        // @Override
-        // public void nodesStats(final NodesStatsRequest request, final ActionListener<NodesStatsResponse> listener) {
-        //     execute(NodesStatsAction.INSTANCE, request, listener);
-        // }
-
-        // @Override
-        // public NodesStatsRequestBuilder prepareNodesStats(String... nodesIds) {
-        //     return new NodesStatsRequestBuilder(this, NodesStatsAction.INSTANCE).setNodesIds(nodesIds);
-        // }
     }
 
     @Override
-    public Client filterWithHeader(Map<String, String> headers) {
-        return new FilterClient(this) {
+    public ProtobufClient filterWithHeader(Map<String, String> headers) {
+        return new ProtobufFilterClient(this) {
             @Override
-            protected <Request extends ActionRequest, Response extends ActionResponse> void doExecute(
-                ActionType<Response> action,
+            protected <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> void doExecute(
+                ProtobufActionType<Response> action,
                 Request request,
                 ActionListener<Response> listener
             ) {
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufAbstractDiffable.java b/server/src/main/java/org/opensearch/cluster/ProtobufAbstractDiffable.java
new file mode 100644
index 0000000000000..9af03c8bc9463
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufAbstractDiffable.java
@@ -0,0 +1,88 @@
+/*
+* 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.
+*/
+
+package org.opensearch.cluster;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.Nullable;
+
+import java.io.IOException;
+
+/**
+ * Abstract diffable object with simple diffs implementation that sends the entire object if object has changed or
+* nothing if object remained the same.
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufAbstractDiffable<T extends ProtobufDiffable<T>> implements ProtobufDiffable<T> {
+
+    private static final ProtobufDiff<?> EMPTY = new CompleteDiff<>();
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public ProtobufDiff<T> diff(T previousState) {
+        if (this.equals(previousState)) {
+            return (ProtobufDiff<T>) EMPTY;
+        } else {
+            return new CompleteDiff<>((T) this);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T extends ProtobufDiffable<T>> ProtobufDiff<T> readDiffFrom(Reader<T> reader, CodedInputStream in) throws IOException {
+        if (in.readBool()) {
+            return new CompleteDiff<>(reader.read(in));
+        }
+        return (ProtobufDiff<T>) EMPTY;
+    }
+
+    /**
+     * A complete diff.
+    *
+    * @opensearch.internal
+    */
+    private static class CompleteDiff<T extends ProtobufDiffable<T>> implements ProtobufDiff<T> {
+
+        @Nullable
+        private final T part;
+
+        /**
+         * Creates simple diff with changes
+        */
+        CompleteDiff(T part) {
+            this.part = part;
+        }
+
+        /**
+         * Creates simple diff without changes
+        */
+        CompleteDiff() {
+            this.part = null;
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            if (part != null) {
+                out.writeBoolNoTag(true);
+                part.writeTo(out);
+            } else {
+                out.writeBoolNoTag(false);
+            }
+        }
+
+        @Override
+        public T apply(T part) {
+            if (this.part != null) {
+                return this.part;
+            } else {
+                return part;
+            }
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterName.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterName.java
index a41eed231ef18..a7980d7cbd3ed 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufClusterName.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufClusterName.java
@@ -20,6 +20,7 @@
 import org.opensearch.common.settings.Settings;
 
 import java.io.IOException;
+import java.util.function.Predicate;
 
 /**
  * Cluster Name
@@ -58,4 +59,18 @@ public String value() {
     public void writeTo(CodedOutputStream out) throws IOException {
         out.writeStringNoTag(value);
     }
+
+    public Predicate<ProtobufClusterName> getEqualityPredicate() {
+        return new Predicate<ProtobufClusterName>() {
+            @Override
+            public boolean test(ProtobufClusterName o) {
+                return ProtobufClusterName.this.equals(o);
+            }
+
+            @Override
+            public String toString() {
+                return "local cluster name [" + ProtobufClusterName.this.value() + "]";
+            }
+        };
+    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java
index 85adfd417936d..5973eab393121 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java
@@ -24,10 +24,10 @@
 import org.opensearch.cluster.coordination.CoordinationMetadata.VotingConfiguration;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
 import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
 import org.opensearch.cluster.routing.IndexRoutingTable;
 import org.opensearch.cluster.routing.IndexShardRoutingTable;
-import org.opensearch.cluster.routing.RoutingNode;
 import org.opensearch.cluster.routing.RoutingNodes;
 import org.opensearch.cluster.routing.RoutingTable;
 import org.opensearch.cluster.routing.ShardRouting;
@@ -114,7 +114,7 @@ static <T extends ProtobufVersionedNamedWriteable & FeatureAware> boolean should
             final CodedOutputStream out,
             final T custom
         ) {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
             return protobufStreamOutput.getVersion().onOrAfter(custom.getMinimalSupportedVersion());
         }
 
@@ -306,13 +306,13 @@ public Set<VotingConfigExclusion> getVotingConfigExclusions() {
     /**
      * Returns a built (on demand) routing nodes view of the routing table.
     */
-    public RoutingNodes getRoutingNodes() {
-        if (routingNodes != null) {
-            return routingNodes;
-        }
-        routingNodes = new RoutingNodes(this);
-        return routingNodes;
-    }
+    // public RoutingNodes getRoutingNodes() {
+    // if (routingNodes != null) {
+    // return routingNodes;
+    // }
+    // routingNodes = new RoutingNodes(this);
+    // return routingNodes;
+    // }
 
     /**
      * Metrics for cluster state.
@@ -426,7 +426,7 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         // nodes
         if (metrics.contains(Metric.NODES)) {
             builder.startObject("nodes");
-            for (DiscoveryNode node : nodes) {
+            for (ProtobufDiscoveryNode node : nodes) {
                 node.toXContent(builder, params);
             }
             builder.endObject();
@@ -459,26 +459,26 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         }
 
         // routing nodes
-        if (metrics.contains(Metric.ROUTING_NODES)) {
-            builder.startObject("routing_nodes");
-            builder.startArray("unassigned");
-            for (ShardRouting shardRouting : getRoutingNodes().unassigned()) {
-                shardRouting.toXContent(builder, params);
-            }
-            builder.endArray();
+        // if (metrics.contains(Metric.ROUTING_NODES)) {
+        // builder.startObject("routing_nodes");
+        // builder.startArray("unassigned");
+        // for (ShardRouting shardRouting : getRoutingNodes().unassigned()) {
+        // shardRouting.toXContent(builder, params);
+        // }
+        // builder.endArray();
 
-            builder.startObject("nodes");
-            for (RoutingNode routingNode : getRoutingNodes()) {
-                builder.startArray(routingNode.nodeId() == null ? "null" : routingNode.nodeId());
-                for (ShardRouting shardRouting : routingNode) {
-                    shardRouting.toXContent(builder, params);
-                }
-                builder.endArray();
-            }
-            builder.endObject();
+        // builder.startObject("nodes");
+        // for (RoutingNode routingNode : getRoutingNodes()) {
+        // builder.startArray(routingNode.nodeId() == null ? "null" : routingNode.nodeId());
+        // for (ShardRouting shardRouting : routingNode) {
+        // shardRouting.toXContent(builder, params);
+        // }
+        // builder.endArray();
+        // }
+        // builder.endObject();
 
-            builder.endObject();
-        }
+        // builder.endObject();
+        // }
         if (metrics.contains(Metric.CUSTOMS)) {
             for (ObjectObjectCursor<String, Custom> cursor : customs) {
                 builder.startObject(cursor.key);
@@ -658,7 +658,7 @@ public static ProtobufDiff<ProtobufClusterState> readDiffFrom(CodedInputStream i
     }
 
     public static ProtobufClusterState readFrom(CodedInputStream in, DiscoveryNode localNode) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
         ProtobufClusterName clusterName = new ProtobufClusterName(in);
         Builder builder = new Builder(clusterName);
         builder.version = in.readInt64();
@@ -678,7 +678,7 @@ public static ProtobufClusterState readFrom(CodedInputStream in, DiscoveryNode l
 
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         clusterName.writeTo(out);
         out.writeInt64NoTag(version);
         out.writeStringNoTag(stateUUID);
@@ -696,7 +696,7 @@ public void writeTo(CodedOutputStream out) throws IOException {
         out.writeInt32NoTag(numberOfCustoms);
         for (final ObjectCursor<Custom> cursor : customs.values()) {
             if (FeatureAware.shouldSerialize(out, cursor.value)) {
-                protobufStreamOutput.writeNamedWriteable(cursor.value, out);
+                protobufStreamOutput.writeNamedWriteable(cursor.value);
             }
         }
         out.writeInt32NoTag(minimumClusterManagerNodesOnPublishingClusterManager);
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufDiffableUtils.java b/server/src/main/java/org/opensearch/cluster/ProtobufDiffableUtils.java
index 52f4635c6f2e1..32eecd526f997 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufDiffableUtils.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufDiffableUtils.java
@@ -461,18 +461,18 @@ protected MapDiff(
         }
 
         protected MapDiff(CodedInputStream in, KeySerializer<K> keySerializer, ValueSerializer<K, T> valueSerializer) throws IOException {
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
             this.keySerializer = keySerializer;
             this.valueSerializer = valueSerializer;
-            deletes = protobufStreamInput.readList(keySerializer::readKey, in);
-            int diffsCount = protobufStreamInput.readVInt(in);
+            deletes = protobufStreamInput.readList(keySerializer::readKey);
+            int diffsCount = protobufStreamInput.readVInt();
             diffs = diffsCount == 0 ? Collections.emptyMap() : new HashMap<>(diffsCount);
             for (int i = 0; i < diffsCount; i++) {
                 K key = keySerializer.readKey(in);
                 ProtobufDiff<T> diff = valueSerializer.readDiff(in, key);
                 diffs.put(key, diff);
             }
-            int upsertsCount = protobufStreamInput.readVInt(in);
+            int upsertsCount = protobufStreamInput.readVInt();
             upserts = upsertsCount == 0 ? Collections.emptyMap() : new HashMap<>(upsertsCount);
             for (int i = 0; i < upsertsCount; i++) {
                 K key = keySerializer.readKey(in);
@@ -513,8 +513,8 @@ public Map<K, T> getUpserts() {
 
         @Override
         public void writeTo(CodedOutputStream out) throws IOException {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
-            protobufStreamOutput.writeCollection(deletes, (o, v) -> keySerializer.writeKey(v, o), out);
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+            protobufStreamOutput.writeCollection(deletes, (o, v) -> keySerializer.writeKey(v, o));
             Version version = protobufStreamOutput.getVersion();
             // filter out custom states not supported by the other node
             int diffCount = 0;
@@ -799,14 +799,14 @@ public static <K> StringSetValueSerializer<K> getInstance() {
 
         @Override
         public void write(Set<String> value, CodedOutputStream out) throws IOException {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
-            protobufStreamOutput.writeCollection(value, CodedOutputStream::writeStringNoTag, out);
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+            protobufStreamOutput.writeStringCollection(value);
         }
 
         @Override
         public Set<String> read(CodedInputStream in, K key) throws IOException {
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
-            return Collections.unmodifiableSet(new HashSet<>(Arrays.asList(protobufStreamInput.readStringArray(in))));
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+            return Collections.unmodifiableSet(new HashSet<>(Arrays.asList(protobufStreamInput.readStringArray())));
         }
     }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffableValueSerializer.java b/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffableValueSerializer.java
index e7b3720256b09..a5d142efa670c 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffableValueSerializer.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffableValueSerializer.java
@@ -36,7 +36,7 @@ public ProtobufNamedDiffableValueSerializer(Class<T> tClass) {
 
     @Override
     public T read(CodedInputStream in, String key) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
         return protobufStreamInput.readNamedWriteable(tClass, key);
     }
 
@@ -53,7 +53,7 @@ public boolean supportsVersion(T value, Version version) {
     @SuppressWarnings("unchecked")
     @Override
     public ProtobufDiff<T> readDiff(CodedInputStream in, String key) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
         return protobufStreamInput.readNamedWriteable(ProtobufNamedDiff.class, key);
     }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/ProtobufPendingClusterStateStats.java b/server/src/main/java/org/opensearch/cluster/coordination/ProtobufPendingClusterStateStats.java
new file mode 100644
index 0000000000000..1270f8214ef49
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/coordination/ProtobufPendingClusterStateStats.java
@@ -0,0 +1,87 @@
+/*
+* 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.
+*/
+
+package org.opensearch.cluster.coordination;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+/**
+ * Class encapsulating stats about the PendingClusterStatsQueue
+*
+* @opensearch.internal
+*/
+public class ProtobufPendingClusterStateStats implements ProtobufWriteable, ToXContentFragment {
+
+    private final int total;
+    private final int pending;
+    private final int committed;
+
+    public ProtobufPendingClusterStateStats(int total, int pending, int committed) {
+        this.total = total;
+        this.pending = pending;
+        this.committed = committed;
+    }
+
+    public ProtobufPendingClusterStateStats(CodedInputStream in) throws IOException {
+        total = in.readInt32();
+        pending = in.readInt32();
+        committed = in.readInt32();
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt32NoTag(total);
+        out.writeInt32NoTag(pending);
+        out.writeInt32NoTag(committed);
+    }
+
+    public int getCommitted() {
+        return committed;
+    }
+
+    public int getPending() {
+        return pending;
+    }
+
+    public int getTotal() {
+        return total;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.QUEUE);
+        builder.field(Fields.TOTAL, total);
+        builder.field(Fields.PENDING, pending);
+        builder.field(Fields.COMMITTED, committed);
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * Fields for parsing and toXContent
+    *
+    * @opensearch.internal
+    */
+    static final class Fields {
+        static final String QUEUE = "cluster_state_queue";
+        static final String TOTAL = "total";
+        static final String PENDING = "pending";
+        static final String COMMITTED = "committed";
+    }
+
+    @Override
+    public String toString() {
+        return "ProtobufPendingClusterStateStats(total=" + total + ", pending=" + pending + ", committed=" + committed + ")";
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/ProtobufPublishClusterStateStats.java b/server/src/main/java/org/opensearch/cluster/coordination/ProtobufPublishClusterStateStats.java
new file mode 100644
index 0000000000000..83604bf3dae9b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/coordination/ProtobufPublishClusterStateStats.java
@@ -0,0 +1,92 @@
+/*
+* 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.
+*/
+
+package org.opensearch.cluster.coordination;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.xcontent.ToXContentObject;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+/**
+ * Class encapsulating stats about the PublishClusterStateAction
+*
+* @opensearch.internal
+*/
+public class ProtobufPublishClusterStateStats implements ProtobufWriteable, ToXContentObject {
+
+    private final long fullClusterStateReceivedCount;
+    private final long incompatibleClusterStateDiffReceivedCount;
+    private final long compatibleClusterStateDiffReceivedCount;
+
+    /**
+     * @param fullClusterStateReceivedCount the number of times this node has received a full copy of the cluster state from the cluster-manager.
+    * @param incompatibleClusterStateDiffReceivedCount the number of times this node has received a cluster-state diff from the cluster-manager.
+    * @param compatibleClusterStateDiffReceivedCount the number of times that received cluster-state diffs were compatible with
+    */
+    public ProtobufPublishClusterStateStats(
+        long fullClusterStateReceivedCount,
+        long incompatibleClusterStateDiffReceivedCount,
+        long compatibleClusterStateDiffReceivedCount
+    ) {
+        this.fullClusterStateReceivedCount = fullClusterStateReceivedCount;
+        this.incompatibleClusterStateDiffReceivedCount = incompatibleClusterStateDiffReceivedCount;
+        this.compatibleClusterStateDiffReceivedCount = compatibleClusterStateDiffReceivedCount;
+    }
+
+    public ProtobufPublishClusterStateStats(CodedInputStream in) throws IOException {
+        fullClusterStateReceivedCount = in.readInt64();
+        incompatibleClusterStateDiffReceivedCount = in.readInt64();
+        compatibleClusterStateDiffReceivedCount = in.readInt64();
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(fullClusterStateReceivedCount);
+        out.writeInt64NoTag(incompatibleClusterStateDiffReceivedCount);
+        out.writeInt64NoTag(compatibleClusterStateDiffReceivedCount);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject("published_cluster_states");
+        {
+            builder.field("full_states", fullClusterStateReceivedCount);
+            builder.field("incompatible_diffs", incompatibleClusterStateDiffReceivedCount);
+            builder.field("compatible_diffs", compatibleClusterStateDiffReceivedCount);
+        }
+        builder.endObject();
+        return builder;
+    }
+
+    public long getFullClusterStateReceivedCount() {
+        return fullClusterStateReceivedCount;
+    }
+
+    public long getIncompatibleClusterStateDiffReceivedCount() {
+        return incompatibleClusterStateDiffReceivedCount;
+    }
+
+    public long getCompatibleClusterStateDiffReceivedCount() {
+        return compatibleClusterStateDiffReceivedCount;
+    }
+
+    @Override
+    public String toString() {
+        return "ProtobufPublishClusterStateStats(full="
+            + fullClusterStateReceivedCount
+            + ", incompatible="
+            + incompatibleClusterStateDiffReceivedCount
+            + ", compatible="
+            + compatibleClusterStateDiffReceivedCount
+            + ")";
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNode.java b/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNode.java
index 11b1762b05108..a05d519744fb5 100644
--- a/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNode.java
+++ b/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNode.java
@@ -23,6 +23,8 @@
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.node.Node;
 
 import java.io.IOException;
@@ -47,7 +49,7 @@
 *
 * @opensearch.internal
 */
-public class ProtobufDiscoveryNode implements ProtobufWriteable {
+public class ProtobufDiscoveryNode implements ProtobufWriteable, ToXContentFragment {
 
     static final String COORDINATING_ONLY = "coordinating_only";
 
@@ -290,7 +292,7 @@ private static void validateLegacySettings(final Settings settings, final Map<St
     * @throws IOException if there is an error while reading from the stream
     */
     public ProtobufDiscoveryNode(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
         this.nodeName = in.readString();
         this.nodeId = in.readString();
         this.ephemeralId = in.readString();
@@ -331,7 +333,7 @@ public ProtobufDiscoveryNode(CodedInputStream in) throws IOException {
 
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         out.writeStringNoTag(nodeName);
         out.writeStringNoTag(nodeId);
         out.writeStringNoTag(ephemeralId);
@@ -515,4 +517,21 @@ public static Set<String> getPossibleRoleNames() {
         return roleMap.keySet();
     }
 
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(getId());
+        builder.field("name", getName());
+        builder.field("ephemeral_id", getEphemeralId());
+        builder.field("transport_address", getAddress().toString());
+
+        builder.startObject("attributes");
+        for (Map.Entry<String, String> entry : attributes.entrySet()) {
+            builder.field(entry.getKey(), entry.getValue());
+        }
+        builder.endObject();
+
+        builder.endObject();
+        return builder;
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java b/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java
index d6a19ef75a134..b2594459dd5e2 100644
--- a/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java
+++ b/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java
@@ -14,14 +14,13 @@
 import com.carrotsearch.hppc.cursors.ObjectCursor;
 import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
 import org.opensearch.Version;
-import org.opensearch.cluster.AbstractDiffable;
-import org.opensearch.cluster.Diff;
+import org.opensearch.cluster.ProtobufAbstractDiffable;
+import org.opensearch.cluster.ProtobufDiff;
+import org.opensearch.cluster.ProtobufAbstractDiffable;
 import org.opensearch.common.Booleans;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.Strings;
 import org.opensearch.common.collect.ImmutableOpenMap;
-import org.opensearch.common.io.stream.StreamInput;
-import org.opensearch.common.io.stream.StreamOutput;
 import org.opensearch.common.regex.Regex;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.util.set.Sets;
@@ -43,7 +42,7 @@
 *
 * @opensearch.internal
 */
-public class ProtobufDiscoveryNodes extends AbstractDiffable<ProtobufDiscoveryNodes> implements Iterable<ProtobufDiscoveryNode> {
+public class ProtobufDiscoveryNodes extends ProtobufAbstractDiffable<ProtobufDiscoveryNodes> implements Iterable<ProtobufDiscoveryNode> {
 
     public static final ProtobufDiscoveryNodes EMPTY_NODES = builder().build();
 
@@ -700,8 +699,9 @@ public static ProtobufDiscoveryNodes readFrom(CodedInputStream in, ProtobufDisco
         return builder.build();
     }
 
-    public static Diff<ProtobufDiscoveryNodes> readDiffFrom(CodedInputStream in, ProtobufDiscoveryNode localNode) throws IOException {
-        return AbstractDiffable.readDiffFrom(in1 -> readFrom(in1, localNode), in);
+    public static ProtobufDiff<ProtobufDiscoveryNodes> readDiffFrom(CodedInputStream in, ProtobufDiscoveryNode localNode)
+        throws IOException {
+        return ProtobufAbstractDiffable.readDiffFrom(in1 -> readFrom(in1, localNode), in);
     }
 
     public static Builder builder() {
diff --git a/server/src/main/java/org/opensearch/cluster/routing/RoutingNodes.java b/server/src/main/java/org/opensearch/cluster/routing/RoutingNodes.java
index 5b2ef369a930c..5402218664f6f 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/RoutingNodes.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/RoutingNodes.java
@@ -36,7 +36,6 @@
 import org.apache.lucene.util.CollectionUtil;
 import org.opensearch.core.Assertions;
 import org.opensearch.cluster.ClusterState;
-import org.opensearch.cluster.ProtobufClusterState;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
@@ -162,64 +161,6 @@ public RoutingNodes(ClusterState clusterState, boolean readOnly) {
         }
     }
 
-    public RoutingNodes(ProtobufClusterState clusterState) {
-        this(clusterState, true);
-    }
-
-    public RoutingNodes(ProtobufClusterState clusterState, boolean readOnly) {
-        this.readOnly = readOnly;
-        final RoutingTable routingTable = clusterState.routingTable();
-
-        // fill in the nodeToShards with the "live" nodes
-        for (ObjectCursor<DiscoveryNode> cursor : clusterState.nodes().getDataNodes().values()) {
-            String nodeId = cursor.value.getId();
-            this.nodesToShards.put(cursor.value.getId(), new RoutingNode(nodeId, clusterState.nodes().get(nodeId)));
-        }
-
-        // fill in the inverse of node -> shards allocated
-        // also fill replicaSet information
-        for (ObjectCursor<IndexRoutingTable> indexRoutingTable : routingTable.indicesRouting().values()) {
-            for (IndexShardRoutingTable indexShard : indexRoutingTable.value) {
-                assert indexShard.primary != null;
-                for (ShardRouting shard : indexShard) {
-                    // to get all the shards belonging to an index, including the replicas,
-                    // we define a replica set and keep track of it. A replica set is identified
-                    // by the ShardId, as this is common for primary and replicas.
-                    // A replica Set might have one (and not more) replicas with the state of RELOCATING.
-                    if (shard.assignedToNode()) {
-                        RoutingNode routingNode = this.nodesToShards.computeIfAbsent(
-                            shard.currentNodeId(),
-                            k -> new RoutingNode(shard.currentNodeId(), clusterState.nodes().get(shard.currentNodeId()))
-                        );
-                        routingNode.add(shard);
-                        assignedShardsAdd(shard);
-                        if (shard.relocating()) {
-                            relocatingShards++;
-                            // Add the counterpart shard with relocatingNodeId reflecting the source from which
-                            // it's relocating from.
-                            routingNode = nodesToShards.computeIfAbsent(
-                                shard.relocatingNodeId(),
-                                k -> new RoutingNode(shard.relocatingNodeId(), clusterState.nodes().get(shard.relocatingNodeId()))
-                            );
-                            ShardRouting targetShardRouting = shard.getTargetRelocatingShard();
-                            addInitialRecovery(targetShardRouting, indexShard.primary);
-                            routingNode.add(targetShardRouting);
-                            assignedShardsAdd(targetShardRouting);
-                        } else if (shard.initializing()) {
-                            if (shard.primary()) {
-                                inactivePrimaryCount++;
-                            }
-                            inactiveShardCount++;
-                            addInitialRecovery(shard, indexShard.primary);
-                        }
-                    } else {
-                        unassignedShards.add(shard);
-                    }
-                }
-            }
-        }
-    }
-
     private void addRecovery(ShardRouting routing) {
         updateRecoveryCounts(routing, true, findAssignedPrimaryIfPeerRecovery(routing));
     }
diff --git a/server/src/main/java/org/opensearch/common/ProtobufFieldMemoryStats.java b/server/src/main/java/org/opensearch/common/ProtobufFieldMemoryStats.java
new file mode 100644
index 0000000000000..511f8deea3a97
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/ProtobufFieldMemoryStats.java
@@ -0,0 +1,124 @@
+/*
+* 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.
+*/
+
+package org.opensearch.common;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import com.carrotsearch.hppc.ObjectLongHashMap;
+import com.carrotsearch.hppc.cursors.ObjectLongCursor;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.Objects;
+
+/**
+ * A reusable class to encode {@code field -&gt; memory size} mappings
+*
+* @opensearch.internal
+*/
+public final class ProtobufFieldMemoryStats implements ProtobufWriteable, Iterable<ObjectLongCursor<String>> {
+
+    private final ObjectLongHashMap<String> stats;
+
+    /**
+     * Creates a new ProtobufFieldMemoryStats instance
+    */
+    public ProtobufFieldMemoryStats(ObjectLongHashMap<String> stats) {
+        this.stats = Objects.requireNonNull(stats, "status must be non-null");
+        assert !stats.containsKey(null);
+    }
+
+    /**
+     * Creates a new ProtobufFieldMemoryStats instance from a stream
+    */
+    public ProtobufFieldMemoryStats(CodedInputStream input) throws IOException {
+        int size = input.readInt32();
+        stats = new ObjectLongHashMap<>(size);
+        for (int i = 0; i < size; i++) {
+            stats.put(input.readString(), input.readInt64());
+        }
+    }
+
+    /**
+     * Adds / merges the given field memory stats into this stats instance
+    */
+    public void add(ProtobufFieldMemoryStats fieldMemoryStats) {
+        for (ObjectLongCursor<String> entry : fieldMemoryStats.stats) {
+            stats.addTo(entry.key, entry.value);
+        }
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt32NoTag(stats.size());
+        for (ObjectLongCursor<String> entry : stats) {
+            out.writeStringNoTag(entry.key);
+            out.writeInt64NoTag(entry.value);
+        }
+    }
+
+    /**
+     * Generates x-content into the given builder for each of the fields in this stats instance
+    * @param builder the builder to generated on
+    * @param key the top level key for this stats object
+    * @param rawKey the raw byte key for each of the fields byte sizes
+    * @param readableKey the readable key for each of the fields byte sizes
+    */
+    public void toXContent(XContentBuilder builder, String key, String rawKey, String readableKey) throws IOException {
+        builder.startObject(key);
+        for (ObjectLongCursor<String> entry : stats) {
+            builder.startObject(entry.key);
+            builder.humanReadableField(rawKey, readableKey, new ByteSizeValue(entry.value));
+            builder.endObject();
+        }
+        builder.endObject();
+    }
+
+    /**
+     * Creates a deep copy of this stats instance
+    */
+    public ProtobufFieldMemoryStats copy() {
+        return new ProtobufFieldMemoryStats(stats.clone());
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ProtobufFieldMemoryStats that = (ProtobufFieldMemoryStats) o;
+        return Objects.equals(stats, that.stats);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(stats);
+    }
+
+    @Override
+    public Iterator<ObjectLongCursor<String>> iterator() {
+        return stats.iterator();
+    }
+
+    /**
+     * Returns the fields value in bytes or <code>0</code> if it's not present in the stats
+    */
+    public long get(String field) {
+        return stats.get(field);
+    }
+
+    /**
+     * Returns <code>true</code> iff the given field is in the stats
+    */
+    public boolean containsField(String field) {
+        return stats.containsKey(field);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufNamedWriteableRegistry.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufNamedWriteableRegistry.java
new file mode 100644
index 0000000000000..4d724d8d2683b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/io/stream/ProtobufNamedWriteableRegistry.java
@@ -0,0 +1,121 @@
+/*
+* 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.
+*/
+
+package org.opensearch.common.io.stream;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * A registry for {@link org.opensearch.common.io.stream.ProtobufWriteable.Reader} readers of {@link ProtobufNamedWriteable}.
+*
+* The registration is keyed by the combination of the category class of {@link ProtobufNamedWriteable}, and a name unique
+* to that category.
+*
+* @opensearch.internal
+*/
+public class ProtobufNamedWriteableRegistry {
+
+    /**
+     * An entry in the registry, made up of a category class and name, and a reader for that category class.
+    *
+    * @opensearch.internal
+    */
+    public static class Entry {
+
+        /** The superclass of a {@link ProtobufNamedWriteable} which will be read by {@link #reader}. */
+        public final Class<?> categoryClass;
+
+        /** A name for the writeable which is unique to the {@link #categoryClass}. */
+        public final String name;
+
+        /** A reader capability of reading*/
+        public final ProtobufWriteable.Reader<?> reader;
+
+        /** Creates a new entry which can be stored by the registry. */
+        public <T extends ProtobufNamedWriteable> Entry(Class<T> categoryClass, String name, ProtobufWriteable.Reader<? extends T> reader) {
+            this.categoryClass = Objects.requireNonNull(categoryClass);
+            this.name = Objects.requireNonNull(name);
+            this.reader = Objects.requireNonNull(reader);
+        }
+    }
+
+    /**
+     * The underlying data of the registry maps from the category to an inner
+    * map of name unique to that category, to the actual reader.
+    */
+    private final Map<Class<?>, Map<String, ProtobufWriteable.Reader<?>>> registry;
+
+    /**
+     * Constructs a new registry from the given entries.
+    */
+    public ProtobufNamedWriteableRegistry(List<Entry> entries) {
+        if (entries.isEmpty()) {
+            registry = Collections.emptyMap();
+            return;
+        }
+        entries = new ArrayList<>(entries);
+        entries.sort((e1, e2) -> e1.categoryClass.getName().compareTo(e2.categoryClass.getName()));
+
+        Map<Class<?>, Map<String, ProtobufWriteable.Reader<?>>> registry = new HashMap<>();
+        Map<String, ProtobufWriteable.Reader<?>> readers = null;
+        Class currentCategory = null;
+        for (Entry entry : entries) {
+            if (currentCategory != entry.categoryClass) {
+                if (currentCategory != null) {
+                    // we've seen the last of this category, put it into the big map
+                    registry.put(currentCategory, Collections.unmodifiableMap(readers));
+                }
+                readers = new HashMap<>();
+                currentCategory = entry.categoryClass;
+            }
+
+            ProtobufWriteable.Reader<?> oldReader = readers.put(entry.name, entry.reader);
+            if (oldReader != null) {
+                throw new IllegalArgumentException(
+                    "ProtobufNamedWriteable ["
+                        + currentCategory.getName()
+                        + "]["
+                        + entry.name
+                        + "]"
+                        + " is already registered for ["
+                        + oldReader.getClass().getName()
+                        + "],"
+                        + " cannot register ["
+                        + entry.reader.getClass().getName()
+                        + "]"
+                );
+            }
+        }
+        // handle the last category
+        registry.put(currentCategory, Collections.unmodifiableMap(readers));
+
+        this.registry = Collections.unmodifiableMap(registry);
+    }
+
+    /**
+     * Returns a reader for a {@link ProtobufNamedWriteable} object identified by the
+    * name provided as argument and its category.
+    */
+    public <T> ProtobufWriteable.Reader<? extends T> getReader(Class<T> categoryClass, String name) {
+        Map<String, ProtobufWriteable.Reader<?>> readers = registry.get(categoryClass);
+        if (readers == null) {
+            throw new IllegalArgumentException("Unknown ProtobufNamedWriteable category [" + categoryClass.getName() + "]");
+        }
+        @SuppressWarnings("unchecked")
+        ProtobufWriteable.Reader<? extends T> reader = (ProtobufWriteable.Reader<? extends T>) readers.get(name);
+        if (reader == null) {
+            throw new IllegalArgumentException("Unknown ProtobufNamedWriteable [" + categoryClass.getName() + "][" + name + "]");
+        }
+        return reader;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufNotSerializableExceptionWrapper.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufNotSerializableExceptionWrapper.java
new file mode 100644
index 0000000000000..2552fbf099f1f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/io/stream/ProtobufNotSerializableExceptionWrapper.java
@@ -0,0 +1,74 @@
+/*
+* 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.
+*/
+
+package org.opensearch.common.io.stream;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.ProtobufOpenSearchException;
+import org.opensearch.ExceptionsHelper;
+import org.opensearch.rest.RestStatus;
+
+import java.io.IOException;
+
+/**
+ * This exception can be used to wrap a given, not serializable exception
+* to serialize via {@link ProtobufStreamOutput#writeException(Throwable)}.
+* This class will preserve the stacktrace as well as the suppressed exceptions of
+* the throwable it was created with instead of it's own. The stacktrace has no indication
+* of where this exception was created.
+*
+* @opensearch.internal
+*/
+public final class ProtobufNotSerializableExceptionWrapper extends ProtobufOpenSearchException {
+
+    private final String name;
+    private final RestStatus status;
+
+    public ProtobufNotSerializableExceptionWrapper(Throwable other) {
+        super(ProtobufOpenSearchException.getExceptionName(other) + ": " + other.getMessage(), other.getCause());
+        this.name = ProtobufOpenSearchException.getExceptionName(other);
+        this.status = ExceptionsHelper.status(other);
+        setStackTrace(other.getStackTrace());
+        for (Throwable otherSuppressed : other.getSuppressed()) {
+            addSuppressed(otherSuppressed);
+        }
+        if (other instanceof ProtobufOpenSearchException) {
+            ProtobufOpenSearchException ex = (ProtobufOpenSearchException) other;
+            for (String key : ex.getHeaderKeys()) {
+                this.addHeader(key, ex.getHeader(key));
+            }
+            for (String key : ex.getMetadataKeys()) {
+                this.addMetadata(key, ex.getMetadata(key));
+            }
+        }
+    }
+
+    public ProtobufNotSerializableExceptionWrapper(CodedInputStream in) throws IOException {
+        super(in);
+        name = in.readString();
+        status = RestStatus.readFromProtobuf(in);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        super.writeTo(out);
+        out.writeStringNoTag(name);
+        RestStatus.writeToProtobuf(out, status);
+    }
+
+    @Override
+    protected String getExceptionName() {
+        return name;
+    }
+
+    @Override
+    public RestStatus status() {
+        return status;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java
index 54c7ec6adbc57..7742e4578744c 100644
--- a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java
+++ b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java
@@ -11,6 +11,14 @@
 import com.google.protobuf.CodedInputStream;
 
 import java.io.IOException;
+import java.nio.file.AccessDeniedException;
+import java.nio.file.AtomicMoveNotSupportedException;
+import java.nio.file.DirectoryNotEmptyException;
+import java.nio.file.FileAlreadyExistsException;
+import java.nio.file.FileSystemException;
+import java.nio.file.FileSystemLoopException;
+import java.nio.file.NoSuchFileException;
+import java.nio.file.NotDirectoryException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -27,19 +35,27 @@
 import org.opensearch.common.bytes.BytesArray;
 import org.opensearch.common.bytes.BytesReference;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.ProtobufOpenSearchException;
 import org.opensearch.Version;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.Strings;
 
+import static org.opensearch.ProtobufOpenSearchException.readStackTrace;
+
 /**
  * A class for additional methods to read from a {@link CodedInputStream}.
  */
 public class ProtobufStreamInput {
 
+    private CodedInputStream in;
     private Version version = Version.CURRENT;
 
     private static final TimeUnit[] TIME_UNITS = TimeUnit.values();
 
+    public ProtobufStreamInput(CodedInputStream in) {
+        this.in = in;
+    }
+
     /**
      * The version of the node on the other side of this stream.
      */
@@ -55,24 +71,24 @@ public void setVersion(Version version) {
     }
 
     @Nullable
-    public String readOptionalString(CodedInputStream in) throws IOException {
-        if (readBoolean(in)) {
-            return in.readString();
+    public String readOptionalString() throws IOException {
+        if (readBoolean()) {
+            return this.in.readString();
         }
         return null;
     }
 
     @Nullable
-    public Long readOptionalLong(CodedInputStream in) throws IOException {
-        if (readBoolean(in)) {
-            return in.readInt64();
+    public Long readOptionalLong() throws IOException {
+        if (readBoolean()) {
+            return this.in.readInt64();
         }
         return null;
     }
 
     @Nullable
-    public final Boolean readOptionalBoolean(CodedInputStream in) throws IOException {
-        final byte value = in.readRawByte();
+    public final Boolean readOptionalBoolean() throws IOException {
+        final byte value = this.in.readRawByte();
         if (value == 2) {
             return null;
         } else {
@@ -83,26 +99,24 @@ public final Boolean readOptionalBoolean(CodedInputStream in) throws IOException
     /**
      * If the returned map contains any entries it will be mutable. If it is empty it might be immutable.
      */
-    public <K, V> Map<K, V> readMap(ProtobufWriteable.Reader<K> keyReader, ProtobufWriteable.Reader<V> valueReader, CodedInputStream in)
-        throws IOException {
-        int size = readArraySize(in);
+    public <K, V> Map<K, V> readMap(ProtobufWriteable.Reader<K> keyReader, ProtobufWriteable.Reader<V> valueReader) throws IOException {
+        int size = readArraySize();
         if (size == 0) {
             return Collections.emptyMap();
         }
         Map<K, V> map = new HashMap<>(size);
         for (int i = 0; i < size; i++) {
-            K key = keyReader.read(in);
-            V value = valueReader.read(in);
+            K key = keyReader.read(this.in);
+            V value = valueReader.read(this.in);
             map.put(key, value);
         }
         return map;
     }
 
     @Nullable
-    public <T extends ProtobufWriteable> T readOptionalWriteable(ProtobufWriteable.Reader<T> reader, CodedInputStream in)
-        throws IOException {
-        if (readBoolean(in)) {
-            T t = reader.read(in);
+    public <T extends ProtobufWriteable> T readOptionalWriteable(ProtobufWriteable.Reader<T> reader) throws IOException {
+        if (readBoolean()) {
+            T t = reader.read(this.in);
             if (t == null) {
                 throw new IOException(
                     "Writeable.Reader [" + reader + "] returned null which is not allowed and probably means it screwed up the stream."
@@ -114,8 +128,8 @@ public <T extends ProtobufWriteable> T readOptionalWriteable(ProtobufWriteable.R
         }
     }
 
-    private int readArraySize(CodedInputStream in) throws IOException {
-        final int arraySize = readVInt(in);
+    private int readArraySize() throws IOException {
+        final int arraySize = readVInt();
         if (arraySize > ArrayUtil.MAX_ARRAY_LENGTH) {
             throw new IllegalStateException("array length must be <= to " + ArrayUtil.MAX_ARRAY_LENGTH + " but was: " + arraySize);
         }
@@ -129,28 +143,28 @@ private int readArraySize(CodedInputStream in) throws IOException {
         return arraySize;
     }
 
-    public int readVInt(CodedInputStream in) throws IOException {
-        byte b = in.readRawByte();
+    public int readVInt() throws IOException {
+        byte b = this.in.readRawByte();
         int i = b & 0x7F;
         if ((b & 0x80) == 0) {
             return i;
         }
-        b = in.readRawByte();
+        b = this.in.readRawByte();
         i |= (b & 0x7F) << 7;
         if ((b & 0x80) == 0) {
             return i;
         }
-        b = in.readRawByte();
+        b = this.in.readRawByte();
         i |= (b & 0x7F) << 14;
         if ((b & 0x80) == 0) {
             return i;
         }
-        b = in.readRawByte();
+        b = this.in.readRawByte();
         i |= (b & 0x7F) << 21;
         if ((b & 0x80) == 0) {
             return i;
         }
-        b = in.readRawByte();
+        b = this.in.readRawByte();
         if ((b & 0x80) != 0) {
             throw new IOException("Invalid vInt ((" + Integer.toHexString(b) + " & 0x7f) << 28) | " + Integer.toHexString(i));
         }
@@ -160,8 +174,8 @@ public int readVInt(CodedInputStream in) throws IOException {
     /**
      * Reads a boolean.
      */
-    public final boolean readBoolean(CodedInputStream in) throws IOException {
-        return readBoolean(in.readRawByte());
+    public final boolean readBoolean() throws IOException {
+        return readBoolean(this.in.readRawByte());
     }
 
     /**
@@ -169,50 +183,66 @@ public final boolean readBoolean(CodedInputStream in) throws IOException {
      * only if you must differentiate null from empty.
      */
     @Nullable
-    public BytesReference readOptionalBytesReference(CodedInputStream in) throws IOException {
-        int length = readVInt(in) - 1;
+    public BytesReference readOptionalBytesReference() throws IOException {
+        int length = readVInt() - 1;
         if (length < 0) {
             return null;
         }
-        return readBytesReference(length, in);
+        return readBytesReference(length);
     }
 
     /**
      * Reads a bytes reference from this stream, might hold an actual reference to the underlying
      * bytes of the stream.
      */
-    public BytesReference readBytesReference(int length, CodedInputStream in) throws IOException {
+    public BytesReference readBytesReference() throws IOException {
+        int length = readArraySize();
+        return readBytesReference(length);
+    }
+
+    /**
+     * Reads a bytes reference from this stream, might hold an actual reference to the underlying
+     * bytes of the stream.
+     */
+    public BytesReference readBytesReference(int length) throws IOException {
         if (length == 0) {
             return BytesArray.EMPTY;
         }
         byte[] bytes = new byte[length];
-        bytes = in.readByteArray();
+        bytes = this.in.readByteArray();
         return new BytesArray(bytes, 0, length);
     }
 
     /**
      * Read a {@link TimeValue} from the stream
      */
-    public TimeValue readTimeValue(CodedInputStream in) throws IOException {
-        long duration = in.readInt64();
-        TimeUnit timeUnit = TIME_UNITS[in.readRawByte()];
+    public TimeValue readTimeValue() throws IOException {
+        long duration = this.in.readInt64();
+        TimeUnit timeUnit = TIME_UNITS[this.in.readRawByte()];
         return new TimeValue(duration, timeUnit);
     }
 
-    public String[] readStringArray(CodedInputStream in) throws IOException {
-        int size = readArraySize(in);
+    public String[] readStringArray() throws IOException {
+        int size = readArraySize();
         if (size == 0) {
             return Strings.EMPTY_ARRAY;
         }
         String[] ret = new String[size];
         for (int i = 0; i < size; i++) {
-            ret[i] = in.readString();
+            ret[i] = this.in.readString();
         }
         return ret;
     }
 
-    private <E extends Enum<E>> E readEnum(Class<E> enumClass, E[] values, CodedInputStream in) throws IOException {
-        int ordinal = readVInt(in);
+    /**
+    * Reads an enum with type E that was serialized based on the value of its ordinal
+    */
+    public <E extends Enum<E>> E readEnum(Class<E> enumClass) throws IOException {
+        return readEnum(enumClass, enumClass.getEnumConstants());
+    }
+
+    private <E extends Enum<E>> E readEnum(Class<E> enumClass, E[] values) throws IOException {
+        int ordinal = readVInt();
         if (ordinal < 0 || ordinal >= values.length) {
             throw new IOException("Unknown " + enumClass.getSimpleName() + " ordinal [" + ordinal + "]");
         }
@@ -222,15 +252,15 @@ private <E extends Enum<E>> E readEnum(Class<E> enumClass, E[] values, CodedInpu
     /**
      * Reads an enum with type E that was serialized based on the value of it's ordinal
      */
-    public <E extends Enum<E>> EnumSet<E> readEnumSet(Class<E> enumClass, CodedInputStream in) throws IOException {
-        int size = readVInt(in);
+    public <E extends Enum<E>> EnumSet<E> readEnumSet(Class<E> enumClass) throws IOException {
+        int size = readVInt();
         final EnumSet<E> res = EnumSet.noneOf(enumClass);
         if (size == 0) {
             return res;
         }
         final E[] values = enumClass.getEnumConstants();
         for (int i = 0; i < size; i++) {
-            res.add(readEnum(enumClass, values, in));
+            res.add(readEnum(enumClass, values));
         }
         return res;
     }
@@ -253,26 +283,22 @@ private boolean readBoolean(final byte value) {
      * @return the list of objects
      * @throws IOException if an I/O exception occurs reading the list
      */
-    public <T> List<T> readList(final ProtobufWriteable.Reader<T> reader, CodedInputStream in) throws IOException {
-        return readCollection(reader, ArrayList::new, Collections.emptyList(), in);
+    public <T> List<T> readList(final ProtobufWriteable.Reader<T> reader) throws IOException {
+        return readCollection(reader, ArrayList::new, Collections.emptyList());
     }
 
     /**
      * Reads a collection of objects
      */
-    private <T, C extends Collection<? super T>> C readCollection(
-        ProtobufWriteable.Reader<T> reader,
-        IntFunction<C> constructor,
-        C empty,
-        CodedInputStream in
-    ) throws IOException {
-        int count = readArraySize(in);
+    private <T, C extends Collection<? super T>> C readCollection(ProtobufWriteable.Reader<T> reader, IntFunction<C> constructor, C empty)
+        throws IOException {
+        int count = readArraySize();
         if (count == 0) {
             return empty;
         }
         C builder = constructor.apply(count);
         for (int i = 0; i < count; i++) {
-            builder.add(reader.read(in));
+            builder.add(reader.read(this.in));
         }
         return builder;
     }
@@ -301,17 +327,15 @@ public <C extends ProtobufNamedWriteable> C readNamedWriteable(
         throw new UnsupportedOperationException("can't read named writeable from StreamInput");
     }
 
-    public <T> T[] readOptionalArray(ProtobufWriteable.Reader<T> reader, IntFunction<T[]> arraySupplier, CodedInputStream in)
-        throws IOException {
-        return readBoolean(in) ? readArray(reader, arraySupplier, in) : null;
+    public <T> T[] readOptionalArray(ProtobufWriteable.Reader<T> reader, IntFunction<T[]> arraySupplier) throws IOException {
+        return readBoolean() ? readArray(reader, arraySupplier) : null;
     }
 
-    public <T> T[] readArray(final ProtobufWriteable.Reader<T> reader, final IntFunction<T[]> arraySupplier, CodedInputStream in)
-        throws IOException {
-        final int length = readArraySize(in);
+    public <T> T[] readArray(final ProtobufWriteable.Reader<T> reader, final IntFunction<T[]> arraySupplier) throws IOException {
+        final int length = readArraySize();
         final T[] values = arraySupplier.apply(length);
         for (int i = 0; i < length; i++) {
-            values[i] = reader.read(in);
+            values[i] = reader.read(this.in);
         }
         return values;
     }
@@ -319,12 +343,94 @@ public <T> T[] readArray(final ProtobufWriteable.Reader<T> reader, final IntFunc
     /**
      * Read an optional {@link TimeValue} from the stream, returning null if no TimeValue was written.
      */
-    public @Nullable TimeValue readOptionalTimeValue(CodedInputStream in) throws IOException {
-        if (readBoolean(in)) {
-            return readTimeValue(in);
+    public @Nullable TimeValue readOptionalTimeValue() throws IOException {
+        if (readBoolean()) {
+            return readTimeValue();
         } else {
             return null;
         }
     }
 
+    @Nullable
+    @SuppressWarnings("unchecked")
+    public <T extends Exception> T readException() throws IOException {
+        if (readBoolean()) {
+            int key = readVInt();
+            switch (key) {
+                case 0:
+                    final int ord = readVInt();
+                    return (T) ProtobufOpenSearchException.readException(this.in, ord);
+                case 4:
+                    return (T) readStackTrace(new NullPointerException(readOptionalString()), this.in);
+                case 5:
+                    return (T) readStackTrace(new NumberFormatException(readOptionalString()), this.in);
+                case 6:
+                    return (T) readStackTrace(new IllegalArgumentException(readOptionalString(), readException()), this.in);
+                case 13:
+                    final int subclass = readVInt();
+                    final String file = readOptionalString();
+                    final String other = readOptionalString();
+                    final String reason = readOptionalString();
+                    readOptionalString(); // skip the msg - it's composed from file, other and reason
+                    final Exception exception;
+                    switch (subclass) {
+                        case 0:
+                            exception = new NoSuchFileException(file, other, reason);
+                            break;
+                        case 1:
+                            exception = new NotDirectoryException(file);
+                            break;
+                        case 2:
+                            exception = new DirectoryNotEmptyException(file);
+                            break;
+                        case 3:
+                            exception = new AtomicMoveNotSupportedException(file, other, reason);
+                            break;
+                        case 4:
+                            exception = new FileAlreadyExistsException(file, other, reason);
+                            break;
+                        case 5:
+                            exception = new AccessDeniedException(file, other, reason);
+                            break;
+                        case 6:
+                            exception = new FileSystemLoopException(file);
+                            break;
+                        case 7:
+                            exception = new FileSystemException(file, other, reason);
+                            break;
+                        default:
+                            throw new IllegalStateException("unknown FileSystemException with index " + subclass);
+                    }
+                    return (T) readStackTrace(exception, this.in);
+                case 14:
+                    return (T) readStackTrace(new IllegalStateException(readOptionalString(), readException()), this.in);
+                case 16:
+                    return (T) readStackTrace(new InterruptedException(readOptionalString()), this.in);
+                case 17:
+                    return (T) readStackTrace(new IOException(readOptionalString(), readException()), this.in);
+                default:
+                    throw new IOException("no such exception for id: " + key);
+            }
+        }
+        return null;
+    }
+
+    public short readShort() throws IOException {
+        return (short) (((this.in.readRawByte() & 0xFF) << 8) | (this.in.readRawByte() & 0xFF));
+    }
+
+    private static final double[] EMPTY_DOUBLE_ARRAY = new double[0];
+
+    public double[] readDoubleArray() throws IOException {
+        int length = readArraySize();
+        if (length == 0) {
+            return EMPTY_DOUBLE_ARRAY;
+        }
+        double[] values = new double[length];
+        for (int i = 0; i < length; i++) {
+            values[i] = this.in.readDouble();
+        }
+        return values;
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java
index 5c6f7106938b8..ab58c4ba749a1 100644
--- a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java
+++ b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java
@@ -10,11 +10,27 @@
 
 import com.google.protobuf.CodedOutputStream;
 
+import java.io.EOFException;
+import java.io.FileNotFoundException;
 import java.io.IOException;
+import java.nio.file.AccessDeniedException;
+import java.nio.file.AtomicMoveNotSupportedException;
+import java.nio.file.DirectoryNotEmptyException;
+import java.nio.file.FileAlreadyExistsException;
+import java.nio.file.FileSystemException;
+import java.nio.file.FileSystemLoopException;
+import java.nio.file.NoSuchFileException;
+import java.nio.file.NotDirectoryException;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.EnumSet;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
 
+import org.apache.lucene.store.AlreadyClosedException;
+import org.apache.lucene.store.LockObtainFailedException;
+import org.opensearch.ProtobufOpenSearchException;
 import org.opensearch.Version;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.io.stream.ProtobufWriteable.Writer;
@@ -25,7 +41,14 @@
  */
 public class ProtobufStreamOutput {
 
+    private static final int MAX_NESTED_EXCEPTION_LEVEL = 100;
+    private CodedOutputStream out;
     private Version version = Version.CURRENT;
+    private Set<String> features = Collections.emptySet();
+
+    public ProtobufStreamOutput(CodedOutputStream out) {
+        this.out = out;
+    }
 
     /**
      * The version of the node on the other side of this stream.
@@ -54,137 +77,281 @@ public void setVersion(Version version) {
     public final <K, V> void writeMap(
         final Map<K, V> map,
         final ProtobufWriteable.Writer<K> keyWriter,
-        final ProtobufWriteable.Writer<V> valueWriter,
-        CodedOutputStream out
+        final ProtobufWriteable.Writer<V> valueWriter
     ) throws IOException {
         for (final Map.Entry<K, V> entry : map.entrySet()) {
-            keyWriter.write(out, entry.getKey());
-            valueWriter.write(out, entry.getValue());
+            keyWriter.write(this.out, entry.getKey());
+            valueWriter.write(this.out, entry.getValue());
         }
     }
 
-    public void writeOptionalWriteable(@Nullable ProtobufWriteable writeable, CodedOutputStream out) throws IOException {
+    public void writeOptionalWriteable(@Nullable ProtobufWriteable writeable) throws IOException {
         if (writeable != null) {
-            out.writeBoolNoTag(true);
-            writeable.writeTo(out);
+            this.out.writeBoolNoTag(true);
+            writeable.writeTo(this.out);
         } else {
-            out.writeBoolNoTag(false);
+            this.out.writeBoolNoTag(false);
         }
     }
 
     /**
      * Write a {@link TimeValue} to the stream
      */
-    public void writeTimeValue(TimeValue timeValue, CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(timeValue.duration());
-        out.writeRawByte((byte) timeValue.timeUnit().ordinal());
+    public void writeTimeValue(TimeValue timeValue) throws IOException {
+        this.out.writeInt64NoTag(timeValue.duration());
+        this.out.writeRawByte((byte) timeValue.timeUnit().ordinal());
     }
 
     /**
      * Writes an EnumSet with type E that by serialized it based on it's ordinal value
      */
-    public <E extends Enum<E>> void writeEnumSet(EnumSet<E> enumSet, CodedOutputStream out) throws IOException {
-        out.writeInt32NoTag(enumSet.size());
+    public <E extends Enum<E>> void writeEnumSet(EnumSet<E> enumSet) throws IOException {
+        this.out.writeInt32NoTag(enumSet.size());
         for (E e : enumSet) {
-            out.writeEnumNoTag(e.ordinal());
+            this.out.writeEnumNoTag(e.ordinal());
         }
     }
 
-    public void writeOptionalLong(@Nullable Long l, CodedOutputStream out) throws IOException {
+    public void writeOptionalLong(@Nullable Long l) throws IOException {
         if (l == null) {
-            out.writeBoolNoTag(false);
+            this.out.writeBoolNoTag(false);
         } else {
-            out.writeBoolNoTag(true);
-            out.writeInt64NoTag(l);
+            this.out.writeBoolNoTag(true);
+            this.out.writeInt64NoTag(l);
         }
     }
 
-    public void writeOptionalString(@Nullable String str, CodedOutputStream out) throws IOException {
+    public void writeOptionalString(@Nullable String str) throws IOException {
         if (str == null) {
-            out.writeBoolNoTag(false);
+            this.out.writeBoolNoTag(false);
         } else {
-            out.writeBoolNoTag(true);
-            out.writeStringNoTag(str);
+            this.out.writeBoolNoTag(true);
+            this.out.writeStringNoTag(str);
         }
     }
 
-    public void writeOptionalBoolean(@Nullable Boolean b, CodedOutputStream out) throws IOException {
+    public void writeOptionalBoolean(@Nullable Boolean b) throws IOException {
         byte two = 2;
         if (b == null) {
-            out.write(two);
+            this.out.write(two);
         } else {
-            out.writeBoolNoTag(b);
+            this.out.writeBoolNoTag(b);
         }
     }
 
+    /**
+     * Writes a collection of a strings. The corresponding collection can be read from a stream input using
+     * {@link ProtobufStreamInput#readList(ProtobufWriteable.Reader)}.
+     *
+     * @param collection the collection of strings
+     * @throws IOException if an I/O exception occurs writing the collection
+     */
+    public void writeStringCollection(final Collection<String> collection) throws IOException {
+        writeCollection(collection, CodedOutputStream::writeStringNoTag);
+    }
+
     /**
      * Writes a collection of objects via a {@link Writer}.
      *
      * @param collection the collection of objects
      * @throws IOException if an I/O exception occurs writing the collection
      */
-    public <T> void writeCollection(final Collection<T> collection, final Writer<T> writer, CodedOutputStream out) throws IOException {
-        out.writeInt32NoTag(collection.size());
+    public <T> void writeCollection(final Collection<T> collection, final Writer<T> writer) throws IOException {
+        this.out.writeInt32NoTag(collection.size());
         for (final T val : collection) {
-            writer.write(out, val);
+            writer.write(this.out, val);
         }
     }
 
-    public void writeStringArray(String[] array, CodedOutputStream out) throws IOException {
-        out.writeInt32NoTag(array.length);
+    public void writeStringArray(String[] array) throws IOException {
+        this.out.writeInt32NoTag(array.length);
         for (String s : array) {
-            out.writeStringNoTag(s);
+            this.out.writeStringNoTag(s);
         }
     }
 
     /**
      * Writes a {@link ProtobufNamedWriteable} to the current stream, by first writing its name and then the object itself
      */
-    public void writeNamedWriteable(ProtobufNamedWriteable namedWriteable, CodedOutputStream out) throws IOException {
-        out.writeStringNoTag(namedWriteable.getWriteableName());
-        namedWriteable.writeTo(out);
+    public void writeNamedWriteable(ProtobufNamedWriteable namedWriteable) throws IOException {
+        this.out.writeStringNoTag(namedWriteable.getWriteableName());
+        namedWriteable.writeTo(this.out);
     }
 
     /**
      * Writes a string array, for nullable string, writes it as 0 (empty string).
      */
-    public void writeStringArrayNullable(@Nullable String[] array, CodedOutputStream out) throws IOException {
+    public void writeStringArrayNullable(@Nullable String[] array) throws IOException {
         if (array == null) {
-            out.writeInt32NoTag(0);
+            this.out.writeInt32NoTag(0);
         } else {
-            writeStringArray(array, out);
+            writeStringArray(array);
         }
     }
 
     /**
      * Write an optional {@link TimeValue} to the stream.
      */
-    public void writeOptionalTimeValue(@Nullable TimeValue timeValue, CodedOutputStream out) throws IOException {
+    public void writeOptionalTimeValue(@Nullable TimeValue timeValue) throws IOException {
         if (timeValue == null) {
-            out.writeBoolNoTag(false);
+            this.out.writeBoolNoTag(false);
         } else {
-            out.writeBoolNoTag(true);
-            writeTimeValue(timeValue, out);
+            this.out.writeBoolNoTag(true);
+            writeTimeValue(timeValue);
         }
     }
 
     /**
-     * Same as {@link #writeArray(Writer, Object[], CodedOutputStream)} but the provided array may be null. An additional boolean value is
+     * Same as {@link #writeArray(Writer, Object[])} but the provided array may be null. An additional boolean value is
      * serialized to indicate whether the array was null or not.
      */
-    public <T> void writeOptionalArray(final Writer<T> writer, final @Nullable T[] array, CodedOutputStream out) throws IOException {
+    public <T> void writeOptionalArray(final Writer<T> writer, final @Nullable T[] array) throws IOException {
         if (array == null) {
-            out.writeBoolNoTag(false);
+            this.out.writeBoolNoTag(false);
         } else {
-            out.writeBoolNoTag(true);
-            writeArray(writer, array, out);
+            this.out.writeBoolNoTag(true);
+            writeArray(writer, array);
         }
     }
 
-    public <T> void writeArray(final Writer<T> writer, final T[] array, CodedOutputStream out) throws IOException {
-        out.writeInt32NoTag(array.length);
+    public <T> void writeArray(final Writer<T> writer, final T[] array) throws IOException {
+        this.out.writeInt32NoTag(array.length);
         for (T value : array) {
-            writer.write(out, value);
+            writer.write(this.out, value);
+        }
+    }
+
+    /**
+    * Set the features on the stream. See {@link StreamOutput#hasFeature(String)}.
+    *
+    * @param features the features on the stream
+    */
+    public void setFeatures(final Set<String> features) {
+        assert this.features.isEmpty() : this.features;
+        this.features = Collections.unmodifiableSet(new HashSet<>(features));
+    }
+
+    public Set<String> getFeatures() {
+        return this.features;
+    }
+
+    public void writeException(Throwable throwable) throws IOException {
+        writeException(throwable, throwable, 0);
+    }
+
+    private void writeException(Throwable rootException, Throwable throwable, int nestedLevel) throws IOException {
+        if (throwable == null) {
+            this.out.writeBoolNoTag(false);
+        } else if (nestedLevel > MAX_NESTED_EXCEPTION_LEVEL) {
+            assert failOnTooManyNestedExceptions(rootException);
+            writeException(new IllegalStateException("too many nested exceptions"));
+        } else {
+            this.out.writeBoolNoTag(true);
+            boolean writeCause = true;
+            boolean writeMessage = true;
+            if (throwable instanceof NullPointerException) {
+                this.out.writeInt32NoTag(4);
+                writeCause = false;
+            } else if (throwable instanceof NumberFormatException) {
+                this.out.writeInt32NoTag(5);
+                writeCause = false;
+            } else if (throwable instanceof IllegalArgumentException) {
+                this.out.writeInt32NoTag(6);
+            } else if (throwable instanceof AlreadyClosedException) {
+                this.out.writeInt32NoTag(7);
+            } else if (throwable instanceof EOFException) {
+                this.out.writeInt32NoTag(8);
+                writeCause = false;
+            } else if (throwable instanceof SecurityException) {
+                this.out.writeInt32NoTag(9);
+            } else if (throwable instanceof StringIndexOutOfBoundsException) {
+                this.out.writeInt32NoTag(10);
+                writeCause = false;
+            } else if (throwable instanceof ArrayIndexOutOfBoundsException) {
+                this.out.writeInt32NoTag(11);
+                writeCause = false;
+            } else if (throwable instanceof FileNotFoundException) {
+                this.out.writeInt32NoTag(12);
+                writeCause = false;
+            } else if (throwable instanceof FileSystemException) {
+                this.out.writeInt32NoTag(13);
+                if (throwable instanceof NoSuchFileException) {
+                    this.out.writeInt32NoTag(0);
+                } else if (throwable instanceof NotDirectoryException) {
+                    this.out.writeInt32NoTag(1);
+                } else if (throwable instanceof DirectoryNotEmptyException) {
+                    this.out.writeInt32NoTag(2);
+                } else if (throwable instanceof AtomicMoveNotSupportedException) {
+                    this.out.writeInt32NoTag(3);
+                } else if (throwable instanceof FileAlreadyExistsException) {
+                    this.out.writeInt32NoTag(4);
+                } else if (throwable instanceof AccessDeniedException) {
+                    this.out.writeInt32NoTag(5);
+                } else if (throwable instanceof FileSystemLoopException) {
+                    this.out.writeInt32NoTag(6);
+                } else {
+                    this.out.writeInt32NoTag(7);
+                }
+                writeOptionalString(((FileSystemException) throwable).getFile());
+                writeOptionalString(((FileSystemException) throwable).getOtherFile());
+                writeOptionalString(((FileSystemException) throwable).getReason());
+                writeCause = false;
+            } else if (throwable instanceof IllegalStateException) {
+                this.out.writeInt32NoTag(14);
+            } else if (throwable instanceof LockObtainFailedException) {
+                this.out.writeInt32NoTag(15);
+            } else if (throwable instanceof InterruptedException) {
+                this.out.writeInt32NoTag(16);
+                writeCause = false;
+            } else if (throwable instanceof IOException) {
+                this.out.writeInt32NoTag(17);
+            } else {
+                final ProtobufOpenSearchException ex;
+                if (throwable instanceof ProtobufOpenSearchException
+                    && ProtobufOpenSearchException.isRegistered(throwable.getClass(), version)) {
+                    ex = (ProtobufOpenSearchException) throwable;
+                } else {
+                    ex = new ProtobufNotSerializableExceptionWrapper(throwable);
+                }
+                this.out.writeInt32NoTag(0);
+                this.out.writeInt32NoTag(ProtobufOpenSearchException.getId(ex.getClass()));
+                ex.writeTo(this.out);
+                return;
+            }
+            if (writeMessage) {
+                writeOptionalString(throwable.getMessage());
+            }
+            if (writeCause) {
+                writeException(rootException, throwable.getCause(), nestedLevel + 1);
+            }
+            ProtobufOpenSearchException.writeStackTraces(throwable, this.out, new ProtobufStreamOutput(this.out));
+        }
+    }
+
+    boolean failOnTooManyNestedExceptions(Throwable throwable) {
+        throw new AssertionError("too many nested exceptions", throwable);
+    }
+
+    /**
+     * Writes an enum with type E based on its ordinal value
+     */
+    public <E extends Enum<E>> void writeEnum(E enumValue) throws IOException {
+        this.out.writeInt32NoTag(enumValue.ordinal());
+    }
+
+    private static final ThreadLocal<byte[]> scratch = ThreadLocal.withInitial(() -> new byte[1024]);
+
+    public final void writeShort(short v) throws IOException {
+        final byte[] buffer = scratch.get();
+        buffer[0] = (byte) (v >> 8);
+        buffer[1] = (byte) v;
+        this.out.writeByteArrayNoTag(buffer);
+    }
+
+    public void writeDoubleArray(double[] values) throws IOException {
+        this.out.writeInt32NoTag(values.length);
+        for (double value : values) {
+            this.out.writeDoubleNoTag(value);
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java b/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
index 924a773b578be..f6d1d1d6af0c7 100644
--- a/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
+++ b/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
@@ -202,7 +202,7 @@ public ProtobufWriteable captureAsWriteable() {
     /**
      * Captures the current thread context as writeable, allowing it to be serialized out later
      */
-    public ProtobufWriteable captureAsWriteable() {
+    public ProtobufWriteable captureAsProtobufWriteable() {
         final ThreadContextStruct context = threadLocal.get();
         return out -> context.writeTo(out, defaultHeader);
     }
@@ -621,6 +621,7 @@ private static final class ThreadContextStruct {
         private final boolean isSystemContext;
         // saving current warning headers' size not to recalculate the size with every new warning header
         private final long warningHeadersSize;
+        private ProtobufStreamOutput protobufStreamOutput;
 
         private ThreadContextStruct setSystemContext() {
             if (isSystemContext) {
@@ -866,8 +867,13 @@ private void writeTo(CodedOutputStream out, Map<String, String> defaultHeaders)
                 out.writeStringNoTag(entry.getValue());
             }
 
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
-            protobufStreamOutput.writeMap(responseHeaders, CodedOutputStream::writeStringNoTag, CodedOutputStream::writeStringNoTag, out);
+            protobufStreamOutput = new ProtobufStreamOutput(out);
+            protobufStreamOutput.writeMap(responseHeaders, CodedOutputStream::writeStringNoTag, (o, v) -> {
+                o.writeInt32NoTag(v.size());
+                for (String s : v) {
+                    o.writeStringNoTag(s);
+                }
+            });
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/discovery/ProtobufDiscoveryStats.java b/server/src/main/java/org/opensearch/discovery/ProtobufDiscoveryStats.java
new file mode 100644
index 0000000000000..e11d0535852d1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/discovery/ProtobufDiscoveryStats.java
@@ -0,0 +1,99 @@
+/*
+* 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.discovery;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.cluster.coordination.ProtobufPendingClusterStateStats;
+import org.opensearch.cluster.coordination.ProtobufPublishClusterStateStats;
+
+import java.io.IOException;
+
+/**
+ * Stores discovery stats
+*
+* @opensearch.internal
+*/
+public class ProtobufDiscoveryStats implements ProtobufWriteable, ToXContentFragment {
+
+    private final ProtobufPendingClusterStateStats queueStats;
+    private final ProtobufPublishClusterStateStats publishStats;
+
+    public ProtobufDiscoveryStats(ProtobufPendingClusterStateStats queueStats, ProtobufPublishClusterStateStats publishStats) {
+        this.queueStats = queueStats;
+        this.publishStats = publishStats;
+    }
+
+    public ProtobufDiscoveryStats(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        queueStats = protobufStreamInput.readOptionalWriteable(ProtobufPendingClusterStateStats::new);
+        publishStats = protobufStreamInput.readOptionalWriteable(ProtobufPublishClusterStateStats::new);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeOptionalWriteable(queueStats);
+        protobufStreamOutput.writeOptionalWriteable(publishStats);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.DISCOVERY);
+        if (queueStats != null) {
+            queueStats.toXContent(builder, params);
+        }
+        if (publishStats != null) {
+            publishStats.toXContent(builder, params);
+        }
+        builder.endObject();
+        return builder;
+    }
+
+    static final class Fields {
+        static final String DISCOVERY = "discovery";
+    }
+
+    public ProtobufPendingClusterStateStats getQueueStats() {
+        return queueStats;
+    }
+
+    public ProtobufPublishClusterStateStats getPublishStats() {
+        return publishStats;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/http/ProtobufHttpStats.java b/server/src/main/java/org/opensearch/http/ProtobufHttpStats.java
new file mode 100644
index 0000000000000..eedd4148575ea
--- /dev/null
+++ b/server/src/main/java/org/opensearch/http/ProtobufHttpStats.java
@@ -0,0 +1,67 @@
+/*
+* 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.
+*/
+
+package org.opensearch.http;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+/**
+ * Stats for HTTP connections
+*
+* @opensearch.internal
+*/
+public class ProtobufHttpStats implements ProtobufWriteable, ToXContentFragment {
+
+    private final long serverOpen;
+    private final long totalOpen;
+
+    public ProtobufHttpStats(long serverOpen, long totalOpened) {
+        this.serverOpen = serverOpen;
+        this.totalOpen = totalOpened;
+    }
+
+    public ProtobufHttpStats(CodedInputStream in) throws IOException {
+        serverOpen = in.readInt64();
+        totalOpen = in.readInt64();
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(serverOpen);
+        out.writeInt64NoTag(totalOpen);
+    }
+
+    public long getServerOpen() {
+        return this.serverOpen;
+    }
+
+    public long getTotalOpen() {
+        return this.totalOpen;
+    }
+
+    static final class Fields {
+        static final String HTTP = "http";
+        static final String CURRENT_OPEN = "current_open";
+        static final String TOTAL_OPENED = "total_opened";
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.HTTP);
+        builder.field(Fields.CURRENT_OPEN, serverOpen);
+        builder.field(Fields.TOTAL_OPENED, totalOpen);
+        builder.endObject();
+        return builder;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/cache/query/ProtobufQueryCacheStats.java b/server/src/main/java/org/opensearch/index/cache/query/ProtobufQueryCacheStats.java
new file mode 100644
index 0000000000000..f3b936f7b7c91
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/cache/query/ProtobufQueryCacheStats.java
@@ -0,0 +1,151 @@
+/*
+* 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.
+*/
+
+package org.opensearch.index.cache.query;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.apache.lucene.search.DocIdSet;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+/**
+ * Stats for the query cache
+*
+* @opensearch.internal
+*/
+public class ProtobufQueryCacheStats implements ProtobufWriteable, ToXContentFragment {
+
+    private long ramBytesUsed;
+    private long hitCount;
+    private long missCount;
+    private long cacheCount;
+    private long cacheSize;
+
+    public ProtobufQueryCacheStats() {}
+
+    public ProtobufQueryCacheStats(CodedInputStream in) throws IOException {
+        ramBytesUsed = in.readInt64();
+        hitCount = in.readInt64();
+        missCount = in.readInt64();
+        cacheCount = in.readInt64();
+        cacheSize = in.readInt64();
+    }
+
+    public ProtobufQueryCacheStats(long ramBytesUsed, long hitCount, long missCount, long cacheCount, long cacheSize) {
+        this.ramBytesUsed = ramBytesUsed;
+        this.hitCount = hitCount;
+        this.missCount = missCount;
+        this.cacheCount = cacheCount;
+        this.cacheSize = cacheSize;
+    }
+
+    public void add(ProtobufQueryCacheStats stats) {
+        ramBytesUsed += stats.ramBytesUsed;
+        hitCount += stats.hitCount;
+        missCount += stats.missCount;
+        cacheCount += stats.cacheCount;
+        cacheSize += stats.cacheSize;
+    }
+
+    public long getMemorySizeInBytes() {
+        return ramBytesUsed;
+    }
+
+    public ByteSizeValue getMemorySize() {
+        return new ByteSizeValue(ramBytesUsed);
+    }
+
+    /**
+     * The total number of lookups in the cache.
+    */
+    public long getTotalCount() {
+        return hitCount + missCount;
+    }
+
+    /**
+     * The number of successful lookups in the cache.
+    */
+    public long getHitCount() {
+        return hitCount;
+    }
+
+    /**
+     * The number of lookups in the cache that failed to retrieve a {@link DocIdSet}.
+    */
+    public long getMissCount() {
+        return missCount;
+    }
+
+    /**
+     * The number of {@link DocIdSet}s that have been cached.
+    */
+    public long getCacheCount() {
+        return cacheCount;
+    }
+
+    /**
+     * The number of {@link DocIdSet}s that are in the cache.
+    */
+    public long getCacheSize() {
+        return cacheSize;
+    }
+
+    /**
+     * The number of {@link DocIdSet}s that have been evicted from the cache.
+    */
+    public long getEvictions() {
+        return cacheCount - cacheSize;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(ramBytesUsed);
+        out.writeInt64NoTag(hitCount);
+        out.writeInt64NoTag(missCount);
+        out.writeInt64NoTag(cacheCount);
+        out.writeInt64NoTag(cacheSize);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params params) throws IOException {
+        builder.startObject(Fields.QUERY_CACHE);
+        builder.humanReadableField(Fields.MEMORY_SIZE_IN_BYTES, Fields.MEMORY_SIZE, getMemorySize());
+        builder.field(Fields.TOTAL_COUNT, getTotalCount());
+        builder.field(Fields.HIT_COUNT, getHitCount());
+        builder.field(Fields.MISS_COUNT, getMissCount());
+        builder.field(Fields.CACHE_SIZE, getCacheSize());
+        builder.field(Fields.CACHE_COUNT, getCacheCount());
+        builder.field(Fields.EVICTIONS, getEvictions());
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * Fields used for parsing and toXContent
+    *
+    * @opensearch.internal
+    */
+    static final class Fields {
+        static final String QUERY_CACHE = "query_cache";
+        static final String MEMORY_SIZE = "memory_size";
+        static final String MEMORY_SIZE_IN_BYTES = "memory_size_in_bytes";
+        static final String TOTAL_COUNT = "total_count";
+        static final String HIT_COUNT = "hit_count";
+        static final String MISS_COUNT = "miss_count";
+        static final String CACHE_SIZE = "cache_size";
+        static final String CACHE_COUNT = "cache_count";
+        static final String EVICTIONS = "evictions";
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/index/cache/request/ProtobufRequestCacheStats.java b/server/src/main/java/org/opensearch/index/cache/request/ProtobufRequestCacheStats.java
new file mode 100644
index 0000000000000..7825adc584287
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/cache/request/ProtobufRequestCacheStats.java
@@ -0,0 +1,107 @@
+/*
+* 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.
+*/
+
+package org.opensearch.index.cache.request;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+/**
+ * Request for the query cache statistics
+*
+* @opensearch.internal
+*/
+public class ProtobufRequestCacheStats implements ProtobufWriteable, ToXContentFragment {
+
+    private long memorySize;
+    private long evictions;
+    private long hitCount;
+    private long missCount;
+
+    public ProtobufRequestCacheStats() {}
+
+    public ProtobufRequestCacheStats(CodedInputStream in) throws IOException {
+        memorySize = in.readInt64();
+        evictions = in.readInt64();
+        hitCount = in.readInt64();
+        missCount = in.readInt64();
+    }
+
+    public ProtobufRequestCacheStats(long memorySize, long evictions, long hitCount, long missCount) {
+        this.memorySize = memorySize;
+        this.evictions = evictions;
+        this.hitCount = hitCount;
+        this.missCount = missCount;
+    }
+
+    public void add(ProtobufRequestCacheStats stats) {
+        this.memorySize += stats.memorySize;
+        this.evictions += stats.evictions;
+        this.hitCount += stats.hitCount;
+        this.missCount += stats.missCount;
+    }
+
+    public long getMemorySizeInBytes() {
+        return this.memorySize;
+    }
+
+    public ByteSizeValue getMemorySize() {
+        return new ByteSizeValue(memorySize);
+    }
+
+    public long getEvictions() {
+        return this.evictions;
+    }
+
+    public long getHitCount() {
+        return this.hitCount;
+    }
+
+    public long getMissCount() {
+        return this.missCount;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(memorySize);
+        out.writeInt64NoTag(evictions);
+        out.writeInt64NoTag(hitCount);
+        out.writeInt64NoTag(missCount);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.REQUEST_CACHE_STATS);
+        builder.humanReadableField(Fields.MEMORY_SIZE_IN_BYTES, Fields.MEMORY_SIZE, getMemorySize());
+        builder.field(Fields.EVICTIONS, getEvictions());
+        builder.field(Fields.HIT_COUNT, getHitCount());
+        builder.field(Fields.MISS_COUNT, getMissCount());
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * Fields used for parsing and toXContent
+    *
+    * @opensearch.internal
+    */
+    static final class Fields {
+        static final String REQUEST_CACHE_STATS = "request_cache";
+        static final String MEMORY_SIZE = "memory_size";
+        static final String MEMORY_SIZE_IN_BYTES = "memory_size_in_bytes";
+        static final String EVICTIONS = "evictions";
+        static final String HIT_COUNT = "hit_count";
+        static final String MISS_COUNT = "miss_count";
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/engine/ProtobufSegmentsStats.java b/server/src/main/java/org/opensearch/index/engine/ProtobufSegmentsStats.java
new file mode 100644
index 0000000000000..c5665107dd624
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/engine/ProtobufSegmentsStats.java
@@ -0,0 +1,285 @@
+/*
+* 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.
+*/
+
+package org.opensearch.index.engine;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.Version;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Tracker for segment stats
+*
+* @opensearch.internal
+*/
+public class ProtobufSegmentsStats implements ProtobufWriteable, ToXContentFragment {
+
+    private long count;
+    private long indexWriterMemoryInBytes;
+    private long versionMapMemoryInBytes;
+    private long maxUnsafeAutoIdTimestamp = Long.MIN_VALUE;
+    private long bitsetMemoryInBytes;
+    private final Map<String, Long> fileSizes;
+
+    private static final ByteSizeValue ZERO_BYTE_SIZE_VALUE = new ByteSizeValue(0L);
+
+    /*
+    * A map to provide a best-effort approach describing Lucene index files.
+    *
+    * Ideally this should be in sync to what the current version of Lucene is using, but it's harmless to leave extensions out,
+    * they'll just miss a proper description in the stats
+    */
+    private static final Map<String, String> FILE_DESCRIPTIONS = Map.ofEntries(
+        Map.entry("si", "Segment Info"),
+        Map.entry("fnm", "Fields"),
+        Map.entry("fdx", "Field Index"),
+        Map.entry("fdt", "Field Data"),
+        Map.entry("tim", "Term Dictionary"),
+        Map.entry("tip", "Term Index"),
+        Map.entry("doc", "Frequencies"),
+        Map.entry("pos", "Positions"),
+        Map.entry("pay", "Payloads"),
+        Map.entry("nvd", "Norms"),
+        Map.entry("nvm", "Norms"),
+        Map.entry("dii", "Points"),
+        Map.entry("dim", "Points"),
+        Map.entry("dvd", "DocValues"),
+        Map.entry("dvm", "DocValues"),
+        Map.entry("tvx", "Term Vector Index"),
+        Map.entry("tvd", "Term Vector Documents"),
+        Map.entry("tvf", "Term Vector Fields"),
+        Map.entry("liv", "Live Documents")
+    );
+
+    public ProtobufSegmentsStats() {
+        fileSizes = new HashMap<>();
+    }
+
+    public ProtobufSegmentsStats(CodedInputStream in) throws IOException {
+        count = in.readInt64();
+        // the following was removed in Lucene 9 (https://issues.apache.org/jira/browse/LUCENE-9387)
+        // retain for bwc only (todo: remove in OpenSearch 3)
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        if (protobufStreamInput.getVersion().before(Version.V_2_0_0)) {
+            in.readInt64(); // estimated segment memory
+            in.readInt64(); // estimated terms memory
+            in.readInt64(); // estimated stored fields memory
+            in.readInt64(); // estimated term vector memory
+            in.readInt64(); // estimated norms memory
+            in.readInt64(); // estimated points memory
+            in.readInt64(); // estimated doc values memory
+        }
+        indexWriterMemoryInBytes = in.readInt64();
+        versionMapMemoryInBytes = in.readInt64();
+        bitsetMemoryInBytes = in.readInt64();
+        maxUnsafeAutoIdTimestamp = in.readInt64();
+        fileSizes = protobufStreamInput.readMap(CodedInputStream::readString, CodedInputStream::readInt64);
+    }
+
+    public void add(long count) {
+        this.count += count;
+    }
+
+    public void addIndexWriterMemoryInBytes(long indexWriterMemoryInBytes) {
+        this.indexWriterMemoryInBytes += indexWriterMemoryInBytes;
+    }
+
+    public void addVersionMapMemoryInBytes(long versionMapMemoryInBytes) {
+        this.versionMapMemoryInBytes += versionMapMemoryInBytes;
+    }
+
+    void updateMaxUnsafeAutoIdTimestamp(long maxUnsafeAutoIdTimestamp) {
+        this.maxUnsafeAutoIdTimestamp = Math.max(maxUnsafeAutoIdTimestamp, this.maxUnsafeAutoIdTimestamp);
+    }
+
+    public void addBitsetMemoryInBytes(long bitsetMemoryInBytes) {
+        this.bitsetMemoryInBytes += bitsetMemoryInBytes;
+    }
+
+    public void addFileSizes(final Map<String, Long> newFileSizes) {
+        newFileSizes.forEach((k, v) -> this.fileSizes.merge(k, v, (a, b) -> {
+            assert a != null;
+            assert b != null;
+            return Math.addExact(a, b);
+        }));
+    }
+
+    public void add(ProtobufSegmentsStats mergeStats) {
+        if (mergeStats == null) {
+            return;
+        }
+        updateMaxUnsafeAutoIdTimestamp(mergeStats.maxUnsafeAutoIdTimestamp);
+        add(mergeStats.count);
+        addIndexWriterMemoryInBytes(mergeStats.indexWriterMemoryInBytes);
+        addVersionMapMemoryInBytes(mergeStats.versionMapMemoryInBytes);
+        addBitsetMemoryInBytes(mergeStats.bitsetMemoryInBytes);
+        addFileSizes(mergeStats.fileSizes);
+    }
+
+    /**
+     * The number of segments.
+    */
+    public long getCount() {
+        return this.count;
+    }
+
+    /**
+     * Estimation of the memory usage by index writer
+    */
+    public long getIndexWriterMemoryInBytes() {
+        return this.indexWriterMemoryInBytes;
+    }
+
+    public ByteSizeValue getIndexWriterMemory() {
+        return new ByteSizeValue(indexWriterMemoryInBytes);
+    }
+
+    /**
+     * Estimation of the memory usage by version map
+    */
+    public long getVersionMapMemoryInBytes() {
+        return this.versionMapMemoryInBytes;
+    }
+
+    public ByteSizeValue getVersionMapMemory() {
+        return new ByteSizeValue(versionMapMemoryInBytes);
+    }
+
+    /**
+     * Estimation of how much the cached bit sets are taking. (which nested and p/c rely on)
+    */
+    public long getBitsetMemoryInBytes() {
+        return bitsetMemoryInBytes;
+    }
+
+    public ByteSizeValue getBitsetMemory() {
+        return new ByteSizeValue(bitsetMemoryInBytes);
+    }
+
+    /** Returns mapping of file names to their size (only used in tests) */
+    public Map<String, Long> getFileSizes() {
+        return Collections.unmodifiableMap(this.fileSizes);
+    }
+
+    /**
+     * Returns the max timestamp that is used to de-optimize documents with auto-generated IDs in the engine.
+    * This is used to ensure we don't add duplicate documents when we assume an append only case based on auto-generated IDs
+    */
+    public long getMaxUnsafeAutoIdTimestamp() {
+        return maxUnsafeAutoIdTimestamp;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.SEGMENTS);
+        builder.field(Fields.COUNT, count);
+        builder.humanReadableField(Fields.MEMORY_IN_BYTES, Fields.MEMORY, ZERO_BYTE_SIZE_VALUE);
+        builder.humanReadableField(Fields.TERMS_MEMORY_IN_BYTES, Fields.TERMS_MEMORY, ZERO_BYTE_SIZE_VALUE);
+        builder.humanReadableField(Fields.STORED_FIELDS_MEMORY_IN_BYTES, Fields.STORED_FIELDS_MEMORY, ZERO_BYTE_SIZE_VALUE);
+        builder.humanReadableField(Fields.TERM_VECTORS_MEMORY_IN_BYTES, Fields.TERM_VECTORS_MEMORY, ZERO_BYTE_SIZE_VALUE);
+        builder.humanReadableField(Fields.NORMS_MEMORY_IN_BYTES, Fields.NORMS_MEMORY, ZERO_BYTE_SIZE_VALUE);
+        builder.humanReadableField(Fields.POINTS_MEMORY_IN_BYTES, Fields.POINTS_MEMORY, ZERO_BYTE_SIZE_VALUE);
+        builder.humanReadableField(Fields.DOC_VALUES_MEMORY_IN_BYTES, Fields.DOC_VALUES_MEMORY, ZERO_BYTE_SIZE_VALUE);
+        builder.humanReadableField(Fields.INDEX_WRITER_MEMORY_IN_BYTES, Fields.INDEX_WRITER_MEMORY, getIndexWriterMemory());
+        builder.humanReadableField(Fields.VERSION_MAP_MEMORY_IN_BYTES, Fields.VERSION_MAP_MEMORY, getVersionMapMemory());
+        builder.humanReadableField(Fields.FIXED_BIT_SET_MEMORY_IN_BYTES, Fields.FIXED_BIT_SET, getBitsetMemory());
+        builder.field(Fields.MAX_UNSAFE_AUTO_ID_TIMESTAMP, maxUnsafeAutoIdTimestamp);
+        builder.startObject(Fields.FILE_SIZES);
+        for (Map.Entry<String, Long> entry : fileSizes.entrySet()) {
+            builder.startObject(entry.getKey());
+            builder.humanReadableField(Fields.SIZE_IN_BYTES, Fields.SIZE, new ByteSizeValue(entry.getValue()));
+            builder.field(Fields.DESCRIPTION, FILE_DESCRIPTIONS.getOrDefault(entry.getKey(), "Others"));
+            builder.endObject();
+        }
+        builder.endObject();
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * Fields for segment statistics
+    *
+    * @opensearch.internal
+    */
+    static final class Fields {
+        static final String SEGMENTS = "segments";
+        static final String COUNT = "count";
+        static final String MEMORY = "memory";
+        static final String MEMORY_IN_BYTES = "memory_in_bytes";
+        static final String TERMS_MEMORY = "terms_memory";
+        static final String TERMS_MEMORY_IN_BYTES = "terms_memory_in_bytes";
+        static final String STORED_FIELDS_MEMORY = "stored_fields_memory";
+        static final String STORED_FIELDS_MEMORY_IN_BYTES = "stored_fields_memory_in_bytes";
+        static final String TERM_VECTORS_MEMORY = "term_vectors_memory";
+        static final String TERM_VECTORS_MEMORY_IN_BYTES = "term_vectors_memory_in_bytes";
+        static final String NORMS_MEMORY = "norms_memory";
+        static final String NORMS_MEMORY_IN_BYTES = "norms_memory_in_bytes";
+        static final String POINTS_MEMORY = "points_memory";
+        static final String POINTS_MEMORY_IN_BYTES = "points_memory_in_bytes";
+        static final String DOC_VALUES_MEMORY = "doc_values_memory";
+        static final String DOC_VALUES_MEMORY_IN_BYTES = "doc_values_memory_in_bytes";
+        static final String INDEX_WRITER_MEMORY = "index_writer_memory";
+        static final String INDEX_WRITER_MEMORY_IN_BYTES = "index_writer_memory_in_bytes";
+        static final String VERSION_MAP_MEMORY = "version_map_memory";
+        static final String VERSION_MAP_MEMORY_IN_BYTES = "version_map_memory_in_bytes";
+        static final String MAX_UNSAFE_AUTO_ID_TIMESTAMP = "max_unsafe_auto_id_timestamp";
+        static final String FIXED_BIT_SET = "fixed_bit_set";
+        static final String FIXED_BIT_SET_MEMORY_IN_BYTES = "fixed_bit_set_memory_in_bytes";
+        static final String FILE_SIZES = "file_sizes";
+        static final String SIZE = "size";
+        static final String SIZE_IN_BYTES = "size_in_bytes";
+        static final String DESCRIPTION = "description";
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(count);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        if (protobufStreamOutput.getVersion().before(Version.V_2_0_0)) {
+            // the following was removed in Lucene 9 (https://issues.apache.org/jira/browse/LUCENE-9387)
+            // retain the following for bwc only (todo: remove in OpenSearch 3)
+            out.writeInt64NoTag(0L); // estimated memory
+            out.writeInt64NoTag(0L); // estimated terms memory
+            out.writeInt64NoTag(0L); // estimated stored fields memory
+            out.writeInt64NoTag(0L); // estimated term vector memory
+            out.writeInt64NoTag(0L); // estimated norms memory
+            out.writeInt64NoTag(0L); // estimated points memory
+            out.writeInt64NoTag(0L); // estimated doc values memory
+        }
+        out.writeInt64NoTag(indexWriterMemoryInBytes);
+        out.writeInt64NoTag(versionMapMemoryInBytes);
+        out.writeInt64NoTag(bitsetMemoryInBytes);
+        out.writeInt64NoTag(maxUnsafeAutoIdTimestamp);
+        protobufStreamOutput.writeMap(this.fileSizes, CodedOutputStream::writeStringNoTag, CodedOutputStream::writeInt64NoTag);
+    }
+
+    public void clearFileSizes() {
+        fileSizes.clear();
+    }
+
+    /**
+     * Used only for deprecating memory tracking in REST interface
+    * todo remove in OpenSearch 3.0
+    * @deprecated
+    */
+    @Deprecated
+    public ByteSizeValue getZeroMemory() {
+        return ZERO_BYTE_SIZE_VALUE;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/fielddata/ProtobufFieldDataStats.java b/server/src/main/java/org/opensearch/index/fielddata/ProtobufFieldDataStats.java
new file mode 100644
index 0000000000000..cffac8b1c0d3f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/fielddata/ProtobufFieldDataStats.java
@@ -0,0 +1,120 @@
+/*
+* 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.
+*/
+
+package org.opensearch.index.fielddata;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.ProtobufFieldMemoryStats;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Objects;
+
+/**
+ * Encapsulates heap usage for field data
+*
+* @opensearch.internal
+*/
+public class ProtobufFieldDataStats implements ProtobufWriteable, ToXContentFragment {
+
+    private static final String FIELDDATA = "fielddata";
+    private static final String MEMORY_SIZE = "memory_size";
+    private static final String MEMORY_SIZE_IN_BYTES = "memory_size_in_bytes";
+    private static final String EVICTIONS = "evictions";
+    private static final String FIELDS = "fields";
+    private long memorySize;
+    private long evictions;
+    @Nullable
+    private ProtobufFieldMemoryStats fields;
+
+    public ProtobufFieldDataStats() {
+
+    }
+
+    public ProtobufFieldDataStats(CodedInputStream in) throws IOException {
+        memorySize = in.readInt64();
+        evictions = in.readInt64();
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        fields = protobufStreamInput.readOptionalWriteable(ProtobufFieldMemoryStats::new);
+    }
+
+    public ProtobufFieldDataStats(long memorySize, long evictions, @Nullable ProtobufFieldMemoryStats fields) {
+        this.memorySize = memorySize;
+        this.evictions = evictions;
+        this.fields = fields;
+    }
+
+    public void add(ProtobufFieldDataStats stats) {
+        this.memorySize += stats.memorySize;
+        this.evictions += stats.evictions;
+        if (stats.fields != null) {
+            if (fields == null) {
+                fields = stats.fields.copy();
+            } else {
+                fields.add(stats.fields);
+            }
+        }
+    }
+
+    public long getMemorySizeInBytes() {
+        return this.memorySize;
+    }
+
+    public ByteSizeValue getMemorySize() {
+        return new ByteSizeValue(memorySize);
+    }
+
+    public long getEvictions() {
+        return this.evictions;
+    }
+
+    @Nullable
+    public ProtobufFieldMemoryStats getFields() {
+        return fields;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(memorySize);
+        out.writeInt64NoTag(evictions);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeOptionalWriteable(fields);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(FIELDDATA);
+        builder.humanReadableField(MEMORY_SIZE_IN_BYTES, MEMORY_SIZE, getMemorySize());
+        builder.field(EVICTIONS, getEvictions());
+        if (fields != null) {
+            fields.toXContent(builder, FIELDS, MEMORY_SIZE_IN_BYTES, MEMORY_SIZE);
+        }
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ProtobufFieldDataStats that = (ProtobufFieldDataStats) o;
+        return memorySize == that.memorySize && evictions == that.evictions && Objects.equals(fields, that.fields);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(memorySize, evictions, fields);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/flush/ProtobufFlushStats.java b/server/src/main/java/org/opensearch/index/flush/ProtobufFlushStats.java
new file mode 100644
index 0000000000000..683389e339708
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/flush/ProtobufFlushStats.java
@@ -0,0 +1,123 @@
+/*
+* 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.
+*/
+
+package org.opensearch.index.flush;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+/**
+ * Encapsulates statistics for flush
+*
+* @opensearch.internal
+*/
+public class ProtobufFlushStats implements ProtobufWriteable, ToXContentFragment {
+
+    private long total;
+    private long periodic;
+    private long totalTimeInMillis;
+
+    public ProtobufFlushStats() {
+
+    }
+
+    public ProtobufFlushStats(CodedInputStream in) throws IOException {
+        total = in.readInt64();
+        totalTimeInMillis = in.readInt64();
+        periodic = in.readInt64();
+    }
+
+    public ProtobufFlushStats(long total, long periodic, long totalTimeInMillis) {
+        this.total = total;
+        this.periodic = periodic;
+        this.totalTimeInMillis = totalTimeInMillis;
+    }
+
+    public void add(long total, long periodic, long totalTimeInMillis) {
+        this.total += total;
+        this.periodic += periodic;
+        this.totalTimeInMillis += totalTimeInMillis;
+    }
+
+    public void add(ProtobufFlushStats flushStats) {
+        addTotals(flushStats);
+    }
+
+    public void addTotals(ProtobufFlushStats flushStats) {
+        if (flushStats == null) {
+            return;
+        }
+        this.total += flushStats.total;
+        this.periodic += flushStats.periodic;
+        this.totalTimeInMillis += flushStats.totalTimeInMillis;
+    }
+
+    /**
+     * The total number of flush executed.
+    */
+    public long getTotal() {
+        return this.total;
+    }
+
+    /**
+     * The number of flushes that were periodically triggered when translog exceeded the flush threshold.
+    */
+    public long getPeriodic() {
+        return periodic;
+    }
+
+    /**
+     * The total time merges have been executed (in milliseconds).
+    */
+    public long getTotalTimeInMillis() {
+        return this.totalTimeInMillis;
+    }
+
+    /**
+     * The total time merges have been executed.
+    */
+    public TimeValue getTotalTime() {
+        return new TimeValue(totalTimeInMillis);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.FLUSH);
+        builder.field(Fields.TOTAL, total);
+        builder.field(Fields.PERIODIC, periodic);
+        builder.humanReadableField(Fields.TOTAL_TIME_IN_MILLIS, Fields.TOTAL_TIME, getTotalTime());
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * Fields for flush statistics
+    *
+    * @opensearch.internal
+    */
+    static final class Fields {
+        static final String FLUSH = "flush";
+        static final String TOTAL = "total";
+        static final String PERIODIC = "periodic";
+        static final String TOTAL_TIME = "total_time";
+        static final String TOTAL_TIME_IN_MILLIS = "total_time_in_millis";
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(total);
+        out.writeInt64NoTag(totalTimeInMillis);
+        out.writeInt64NoTag(periodic);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/get/ProtobufGetStats.java b/server/src/main/java/org/opensearch/index/get/ProtobufGetStats.java
new file mode 100644
index 0000000000000..751bcdd76b07e
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/get/ProtobufGetStats.java
@@ -0,0 +1,151 @@
+/*
+* 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.
+*/
+
+package org.opensearch.index.get;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+/**
+ * Stats for a search get
+*
+* @opensearch.api
+*/
+public class ProtobufGetStats implements ProtobufWriteable, ToXContentFragment {
+
+    private long existsCount;
+    private long existsTimeInMillis;
+    private long missingCount;
+    private long missingTimeInMillis;
+    private long current;
+
+    public ProtobufGetStats() {}
+
+    public ProtobufGetStats(CodedInputStream in) throws IOException {
+        existsCount = in.readInt64();
+        existsTimeInMillis = in.readInt64();
+        missingCount = in.readInt64();
+        missingTimeInMillis = in.readInt64();
+        current = in.readInt64();
+    }
+
+    public ProtobufGetStats(long existsCount, long existsTimeInMillis, long missingCount, long missingTimeInMillis, long current) {
+        this.existsCount = existsCount;
+        this.existsTimeInMillis = existsTimeInMillis;
+        this.missingCount = missingCount;
+        this.missingTimeInMillis = missingTimeInMillis;
+        this.current = current;
+    }
+
+    public void add(ProtobufGetStats stats) {
+        if (stats == null) {
+            return;
+        }
+        current += stats.current;
+        addTotals(stats);
+    }
+
+    public void addTotals(ProtobufGetStats stats) {
+        if (stats == null) {
+            return;
+        }
+        existsCount += stats.existsCount;
+        existsTimeInMillis += stats.existsTimeInMillis;
+        missingCount += stats.missingCount;
+        missingTimeInMillis += stats.missingTimeInMillis;
+        current += stats.current;
+    }
+
+    public long getCount() {
+        return existsCount + missingCount;
+    }
+
+    public long getTimeInMillis() {
+        return existsTimeInMillis + missingTimeInMillis;
+    }
+
+    public TimeValue getTime() {
+        return new TimeValue(getTimeInMillis());
+    }
+
+    public long getExistsCount() {
+        return this.existsCount;
+    }
+
+    public long getExistsTimeInMillis() {
+        return this.existsTimeInMillis;
+    }
+
+    public TimeValue getExistsTime() {
+        return new TimeValue(existsTimeInMillis);
+    }
+
+    public long getMissingCount() {
+        return this.missingCount;
+    }
+
+    public long getMissingTimeInMillis() {
+        return this.missingTimeInMillis;
+    }
+
+    public TimeValue getMissingTime() {
+        return new TimeValue(missingTimeInMillis);
+    }
+
+    public long current() {
+        return this.current;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.GET);
+        builder.field(Fields.TOTAL, getCount());
+        builder.humanReadableField(Fields.TIME_IN_MILLIS, Fields.TIME, getTime());
+        builder.field(Fields.EXISTS_TOTAL, existsCount);
+        builder.humanReadableField(Fields.EXISTS_TIME_IN_MILLIS, Fields.EXISTS_TIME, getExistsTime());
+        builder.field(Fields.MISSING_TOTAL, missingCount);
+        builder.humanReadableField(Fields.MISSING_TIME_IN_MILLIS, Fields.MISSING_TIME, getMissingTime());
+        builder.field(Fields.CURRENT, current);
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * Fields for get statistics
+    *
+    * @opensearch.internal
+    */
+    static final class Fields {
+        static final String GET = "get";
+        static final String TOTAL = "total";
+        static final String TIME = "getTime";
+        static final String TIME_IN_MILLIS = "time_in_millis";
+        static final String EXISTS_TOTAL = "exists_total";
+        static final String EXISTS_TIME = "exists_time";
+        static final String EXISTS_TIME_IN_MILLIS = "exists_time_in_millis";
+        static final String MISSING_TOTAL = "missing_total";
+        static final String MISSING_TIME = "missing_time";
+        static final String MISSING_TIME_IN_MILLIS = "missing_time_in_millis";
+        static final String CURRENT = "current";
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(existsCount);
+        out.writeInt64NoTag(existsTimeInMillis);
+        out.writeInt64NoTag(missingCount);
+        out.writeInt64NoTag(missingTimeInMillis);
+        out.writeInt64NoTag(current);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/merge/ProtobufMergeStats.java b/server/src/main/java/org/opensearch/index/merge/ProtobufMergeStats.java
new file mode 100644
index 0000000000000..3a2ab71e28c09
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/merge/ProtobufMergeStats.java
@@ -0,0 +1,262 @@
+/*
+* 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.
+*/
+
+package org.opensearch.index.merge;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+/**
+ * Stores stats about a merge process
+*
+* @opensearch.internal
+*/
+public class ProtobufMergeStats implements ProtobufWriteable, ToXContentFragment {
+
+    private long total;
+    private long totalTimeInMillis;
+    private long totalNumDocs;
+    private long totalSizeInBytes;
+    private long current;
+    private long currentNumDocs;
+    private long currentSizeInBytes;
+
+    /** Total millis that large merges were stopped so that smaller merges would finish. */
+    private long totalStoppedTimeInMillis;
+
+    /** Total millis that we slept during writes so merge IO is throttled. */
+    private long totalThrottledTimeInMillis;
+
+    private long totalBytesPerSecAutoThrottle;
+
+    public ProtobufMergeStats() {
+
+    }
+
+    public ProtobufMergeStats(CodedInputStream in) throws IOException {
+        total = in.readInt64();
+        totalTimeInMillis = in.readInt64();
+        totalNumDocs = in.readInt64();
+        totalSizeInBytes = in.readInt64();
+        current = in.readInt64();
+        currentNumDocs = in.readInt64();
+        currentSizeInBytes = in.readInt64();
+        // Added in 2.0:
+        totalStoppedTimeInMillis = in.readInt64();
+        totalThrottledTimeInMillis = in.readInt64();
+        totalBytesPerSecAutoThrottle = in.readInt64();
+    }
+
+    public void add(
+        long totalMerges,
+        long totalMergeTime,
+        long totalNumDocs,
+        long totalSizeInBytes,
+        long currentMerges,
+        long currentNumDocs,
+        long currentSizeInBytes,
+        long stoppedTimeMillis,
+        long throttledTimeMillis,
+        double mbPerSecAutoThrottle
+    ) {
+        this.total += totalMerges;
+        this.totalTimeInMillis += totalMergeTime;
+        this.totalNumDocs += totalNumDocs;
+        this.totalSizeInBytes += totalSizeInBytes;
+        this.current += currentMerges;
+        this.currentNumDocs += currentNumDocs;
+        this.currentSizeInBytes += currentSizeInBytes;
+        this.totalStoppedTimeInMillis += stoppedTimeMillis;
+        this.totalThrottledTimeInMillis += throttledTimeMillis;
+        long bytesPerSecAutoThrottle = (long) (mbPerSecAutoThrottle * 1024 * 1024);
+        if (this.totalBytesPerSecAutoThrottle == Long.MAX_VALUE || bytesPerSecAutoThrottle == Long.MAX_VALUE) {
+            this.totalBytesPerSecAutoThrottle = Long.MAX_VALUE;
+        } else {
+            this.totalBytesPerSecAutoThrottle += bytesPerSecAutoThrottle;
+        }
+    }
+
+    public void add(ProtobufMergeStats mergeStats) {
+        if (mergeStats == null) {
+            return;
+        }
+        this.current += mergeStats.current;
+        this.currentNumDocs += mergeStats.currentNumDocs;
+        this.currentSizeInBytes += mergeStats.currentSizeInBytes;
+
+        addTotals(mergeStats);
+    }
+
+    public void addTotals(ProtobufMergeStats mergeStats) {
+        if (mergeStats == null) {
+            return;
+        }
+        this.total += mergeStats.total;
+        this.totalTimeInMillis += mergeStats.totalTimeInMillis;
+        this.totalNumDocs += mergeStats.totalNumDocs;
+        this.totalSizeInBytes += mergeStats.totalSizeInBytes;
+        this.totalStoppedTimeInMillis += mergeStats.totalStoppedTimeInMillis;
+        this.totalThrottledTimeInMillis += mergeStats.totalThrottledTimeInMillis;
+        if (this.totalBytesPerSecAutoThrottle == Long.MAX_VALUE || mergeStats.totalBytesPerSecAutoThrottle == Long.MAX_VALUE) {
+            this.totalBytesPerSecAutoThrottle = Long.MAX_VALUE;
+        } else {
+            this.totalBytesPerSecAutoThrottle += mergeStats.totalBytesPerSecAutoThrottle;
+        }
+    }
+
+    /**
+     * The total number of merges executed.
+    */
+    public long getTotal() {
+        return this.total;
+    }
+
+    /**
+     * The total time merges have been executed (in milliseconds).
+    */
+    public long getTotalTimeInMillis() {
+        return this.totalTimeInMillis;
+    }
+
+    /**
+     * The total time large merges were stopped so smaller merges could finish.
+    */
+    public long getTotalStoppedTimeInMillis() {
+        return this.totalStoppedTimeInMillis;
+    }
+
+    /**
+     * The total time large merges were stopped so smaller merges could finish.
+    */
+    public TimeValue getTotalStoppedTime() {
+        return new TimeValue(totalStoppedTimeInMillis);
+    }
+
+    /**
+     * The total time merge IO writes were throttled.
+    */
+    public long getTotalThrottledTimeInMillis() {
+        return this.totalThrottledTimeInMillis;
+    }
+
+    /**
+     * The total time merge IO writes were throttled.
+    */
+    public TimeValue getTotalThrottledTime() {
+        return new TimeValue(totalThrottledTimeInMillis);
+    }
+
+    /**
+     * The total time merges have been executed.
+    */
+    public TimeValue getTotalTime() {
+        return new TimeValue(totalTimeInMillis);
+    }
+
+    public long getTotalNumDocs() {
+        return this.totalNumDocs;
+    }
+
+    public long getTotalSizeInBytes() {
+        return this.totalSizeInBytes;
+    }
+
+    public ByteSizeValue getTotalSize() {
+        return new ByteSizeValue(totalSizeInBytes);
+    }
+
+    public long getTotalBytesPerSecAutoThrottle() {
+        return totalBytesPerSecAutoThrottle;
+    }
+
+    /**
+     * The current number of merges executing.
+    */
+    public long getCurrent() {
+        return this.current;
+    }
+
+    public long getCurrentNumDocs() {
+        return this.currentNumDocs;
+    }
+
+    public long getCurrentSizeInBytes() {
+        return this.currentSizeInBytes;
+    }
+
+    public ByteSizeValue getCurrentSize() {
+        return new ByteSizeValue(currentSizeInBytes);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.MERGES);
+        builder.field(Fields.CURRENT, current);
+        builder.field(Fields.CURRENT_DOCS, currentNumDocs);
+        builder.humanReadableField(Fields.CURRENT_SIZE_IN_BYTES, Fields.CURRENT_SIZE, getCurrentSize());
+        builder.field(Fields.TOTAL, total);
+        builder.humanReadableField(Fields.TOTAL_TIME_IN_MILLIS, Fields.TOTAL_TIME, getTotalTime());
+        builder.field(Fields.TOTAL_DOCS, totalNumDocs);
+        builder.humanReadableField(Fields.TOTAL_SIZE_IN_BYTES, Fields.TOTAL_SIZE, getTotalSize());
+        builder.humanReadableField(Fields.TOTAL_STOPPED_TIME_IN_MILLIS, Fields.TOTAL_STOPPED_TIME, getTotalStoppedTime());
+        builder.humanReadableField(Fields.TOTAL_THROTTLED_TIME_IN_MILLIS, Fields.TOTAL_THROTTLED_TIME, getTotalThrottledTime());
+        if (builder.humanReadable() && totalBytesPerSecAutoThrottle != -1) {
+            builder.field(Fields.TOTAL_THROTTLE_BYTES_PER_SEC).value(new ByteSizeValue(totalBytesPerSecAutoThrottle).toString());
+        }
+        builder.field(Fields.TOTAL_THROTTLE_BYTES_PER_SEC_IN_BYTES, totalBytesPerSecAutoThrottle);
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * Fields used for merge statistics
+    *
+    * @opensearch.internal
+    */
+    static final class Fields {
+        static final String MERGES = "merges";
+        static final String CURRENT = "current";
+        static final String CURRENT_DOCS = "current_docs";
+        static final String CURRENT_SIZE = "current_size";
+        static final String CURRENT_SIZE_IN_BYTES = "current_size_in_bytes";
+        static final String TOTAL = "total";
+        static final String TOTAL_TIME = "total_time";
+        static final String TOTAL_TIME_IN_MILLIS = "total_time_in_millis";
+        static final String TOTAL_STOPPED_TIME = "total_stopped_time";
+        static final String TOTAL_STOPPED_TIME_IN_MILLIS = "total_stopped_time_in_millis";
+        static final String TOTAL_THROTTLED_TIME = "total_throttled_time";
+        static final String TOTAL_THROTTLED_TIME_IN_MILLIS = "total_throttled_time_in_millis";
+        static final String TOTAL_DOCS = "total_docs";
+        static final String TOTAL_SIZE = "total_size";
+        static final String TOTAL_SIZE_IN_BYTES = "total_size_in_bytes";
+        static final String TOTAL_THROTTLE_BYTES_PER_SEC_IN_BYTES = "total_auto_throttle_in_bytes";
+        static final String TOTAL_THROTTLE_BYTES_PER_SEC = "total_auto_throttle";
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(total);
+        out.writeInt64NoTag(totalTimeInMillis);
+        out.writeInt64NoTag(totalNumDocs);
+        out.writeInt64NoTag(totalSizeInBytes);
+        out.writeInt64NoTag(current);
+        out.writeInt64NoTag(currentNumDocs);
+        out.writeInt64NoTag(currentSizeInBytes);
+        // Added in 2.0:
+        out.writeInt64NoTag(totalStoppedTimeInMillis);
+        out.writeInt64NoTag(totalThrottledTimeInMillis);
+        out.writeInt64NoTag(totalBytesPerSecAutoThrottle);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/recovery/ProtobufRecoveryStats.java b/server/src/main/java/org/opensearch/index/recovery/ProtobufRecoveryStats.java
new file mode 100644
index 0000000000000..a3521e794368c
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/recovery/ProtobufRecoveryStats.java
@@ -0,0 +1,137 @@
+/*
+* 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.
+*/
+
+package org.opensearch.index.recovery;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Recovery related statistics, starting at the shard level and allowing aggregation to
+* indices and node level
+*
+* @opensearch.internal
+*/
+public class ProtobufRecoveryStats implements ToXContentFragment, ProtobufWriteable {
+
+    private final AtomicInteger currentAsSource = new AtomicInteger();
+    private final AtomicInteger currentAsTarget = new AtomicInteger();
+    private final AtomicLong throttleTimeInNanos = new AtomicLong();
+
+    public ProtobufRecoveryStats() {}
+
+    public ProtobufRecoveryStats(CodedInputStream in) throws IOException {
+        currentAsSource.set(in.readInt32());
+        currentAsTarget.set(in.readInt32());
+        throttleTimeInNanos.set(in.readInt64());
+    }
+
+    public void add(ProtobufRecoveryStats recoveryStats) {
+        if (recoveryStats != null) {
+            this.currentAsSource.addAndGet(recoveryStats.currentAsSource());
+            this.currentAsTarget.addAndGet(recoveryStats.currentAsTarget());
+        }
+        addTotals(recoveryStats);
+    }
+
+    public void addTotals(ProtobufRecoveryStats recoveryStats) {
+        if (recoveryStats != null) {
+            this.throttleTimeInNanos.addAndGet(recoveryStats.throttleTime().nanos());
+        }
+    }
+
+    /**
+     * Number of ongoing recoveries for which a shard serves as a source
+    */
+    public int currentAsSource() {
+        return currentAsSource.get();
+    }
+
+    /**
+     * Number of ongoing recoveries for which a shard serves as a target
+    */
+    public int currentAsTarget() {
+        return currentAsTarget.get();
+    }
+
+    /**
+     * Total time recoveries waited due to throttling
+    */
+    public TimeValue throttleTime() {
+        return TimeValue.timeValueNanos(throttleTimeInNanos.get());
+    }
+
+    public void incCurrentAsTarget() {
+        currentAsTarget.incrementAndGet();
+    }
+
+    public void decCurrentAsTarget() {
+        currentAsTarget.decrementAndGet();
+    }
+
+    public void incCurrentAsSource() {
+        currentAsSource.incrementAndGet();
+    }
+
+    public void decCurrentAsSource() {
+        currentAsSource.decrementAndGet();
+    }
+
+    public void addThrottleTime(long nanos) {
+        throttleTimeInNanos.addAndGet(nanos);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.RECOVERY);
+        builder.field(Fields.CURRENT_AS_SOURCE, currentAsSource());
+        builder.field(Fields.CURRENT_AS_TARGET, currentAsTarget());
+        builder.humanReadableField(Fields.THROTTLE_TIME_IN_MILLIS, Fields.THROTTLE_TIME, throttleTime());
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * Fields for recovery statistics
+    *
+    * @opensearch.internal
+    */
+    static final class Fields {
+        static final String RECOVERY = "recovery";
+        static final String CURRENT_AS_SOURCE = "current_as_source";
+        static final String CURRENT_AS_TARGET = "current_as_target";
+        static final String THROTTLE_TIME = "throttle_time";
+        static final String THROTTLE_TIME_IN_MILLIS = "throttle_time_in_millis";
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt32NoTag(currentAsSource.get());
+        out.writeInt32NoTag(currentAsTarget.get());
+        out.writeInt64NoTag(throttleTimeInNanos.get());
+    }
+
+    @Override
+    public String toString() {
+        return "recoveryStats, currentAsSource ["
+            + currentAsSource()
+            + "],currentAsTarget ["
+            + currentAsTarget()
+            + "], throttle ["
+            + throttleTime()
+            + "]";
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/refresh/ProtobufRefreshStats.java b/server/src/main/java/org/opensearch/index/refresh/ProtobufRefreshStats.java
new file mode 100644
index 0000000000000..8688f660782b2
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/refresh/ProtobufRefreshStats.java
@@ -0,0 +1,161 @@
+/*
+* 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.
+*/
+
+package org.opensearch.index.refresh;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Objects;
+
+/**
+ * Encapsulates stats for index refresh
+*
+* @opensearch.internal
+*/
+public class ProtobufRefreshStats implements ProtobufWriteable, ToXContentFragment {
+
+    private long total;
+
+    private long totalTimeInMillis;
+
+    private long externalTotal;
+
+    private long externalTotalTimeInMillis;
+
+    /**
+     * Number of waiting refresh listeners.
+    */
+    private int listeners;
+
+    public ProtobufRefreshStats() {}
+
+    public ProtobufRefreshStats(CodedInputStream in) throws IOException {
+        total = in.readInt64();
+        totalTimeInMillis = in.readInt64();
+        externalTotal = in.readInt64();
+        externalTotalTimeInMillis = in.readInt64();
+        listeners = in.readInt32();
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(total);
+        out.writeInt64NoTag(totalTimeInMillis);
+        out.writeInt64NoTag(externalTotal);
+        out.writeInt64NoTag(externalTotalTimeInMillis);
+        out.writeInt32NoTag(listeners);
+    }
+
+    public ProtobufRefreshStats(long total, long totalTimeInMillis, long externalTotal, long externalTotalTimeInMillis, int listeners) {
+        this.total = total;
+        this.totalTimeInMillis = totalTimeInMillis;
+        this.externalTotal = externalTotal;
+        this.externalTotalTimeInMillis = externalTotalTimeInMillis;
+        this.listeners = listeners;
+    }
+
+    public void add(ProtobufRefreshStats refreshStats) {
+        addTotals(refreshStats);
+    }
+
+    public void addTotals(ProtobufRefreshStats refreshStats) {
+        if (refreshStats == null) {
+            return;
+        }
+        this.total += refreshStats.total;
+        this.totalTimeInMillis += refreshStats.totalTimeInMillis;
+        this.externalTotal += refreshStats.externalTotal;
+        this.externalTotalTimeInMillis += refreshStats.externalTotalTimeInMillis;
+        this.listeners += refreshStats.listeners;
+    }
+
+    /**
+     * The total number of refresh executed.
+    */
+    public long getTotal() {
+        return this.total;
+    }
+
+    /*
+    * The total number of external refresh executed.
+    */
+    public long getExternalTotal() {
+        return this.externalTotal;
+    }
+
+    /**
+     * The total time spent executing refreshes (in milliseconds).
+    */
+    public long getTotalTimeInMillis() {
+        return this.totalTimeInMillis;
+    }
+
+    /**
+     * The total time spent executing external refreshes (in milliseconds).
+    */
+    public long getExternalTotalTimeInMillis() {
+        return this.externalTotalTimeInMillis;
+    }
+
+    /**
+     * The total time refreshes have been executed.
+    */
+    public TimeValue getTotalTime() {
+        return new TimeValue(totalTimeInMillis);
+    }
+
+    /**
+     * The total time external refreshes have been executed.
+    */
+    public TimeValue getExternalTotalTime() {
+        return new TimeValue(externalTotalTimeInMillis);
+    }
+
+    /**
+     * The number of waiting refresh listeners.
+    */
+    public int getListeners() {
+        return listeners;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject("refresh");
+        builder.field("total", total);
+        builder.humanReadableField("total_time_in_millis", "total_time", getTotalTime());
+        builder.field("external_total", externalTotal);
+        builder.humanReadableField("external_total_time_in_millis", "external_total_time", getExternalTotalTime());
+        builder.field("listeners", listeners);
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null || obj.getClass() != ProtobufRefreshStats.class) {
+            return false;
+        }
+        ProtobufRefreshStats rhs = (ProtobufRefreshStats) obj;
+        return total == rhs.total
+            && totalTimeInMillis == rhs.totalTimeInMillis
+            && externalTotal == rhs.externalTotal
+            && externalTotalTimeInMillis == rhs.externalTotalTimeInMillis
+            && listeners == rhs.listeners;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(total, totalTimeInMillis, externalTotal, externalTotalTimeInMillis, listeners);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/search/stats/ProtobufSearchStats.java b/server/src/main/java/org/opensearch/index/search/stats/ProtobufSearchStats.java
new file mode 100644
index 0000000000000..756e06b717f08
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/search/stats/ProtobufSearchStats.java
@@ -0,0 +1,444 @@
+/*
+* 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.
+*/
+
+package org.opensearch.index.search.stats;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.Version;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.Strings;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.xcontent.XContentType;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Encapsulates stats for search time
+*
+* @opensearch.internal
+*/
+public class ProtobufSearchStats implements ProtobufWriteable, ToXContentFragment {
+
+    /**
+     * Statistics for search
+    *
+    * @opensearch.internal
+    */
+    public static class Stats implements ProtobufWriteable, ToXContentFragment {
+
+        private long queryCount;
+        private long queryTimeInMillis;
+        private long queryCurrent;
+
+        private long fetchCount;
+        private long fetchTimeInMillis;
+        private long fetchCurrent;
+
+        private long scrollCount;
+        private long scrollTimeInMillis;
+        private long scrollCurrent;
+
+        private long suggestCount;
+        private long suggestTimeInMillis;
+        private long suggestCurrent;
+
+        private long pitCount;
+        private long pitTimeInMillis;
+        private long pitCurrent;
+
+        private Stats() {
+            // for internal use, initializes all counts to 0
+        }
+
+        public Stats(
+            long queryCount,
+            long queryTimeInMillis,
+            long queryCurrent,
+            long fetchCount,
+            long fetchTimeInMillis,
+            long fetchCurrent,
+            long scrollCount,
+            long scrollTimeInMillis,
+            long scrollCurrent,
+            long pitCount,
+            long pitTimeInMillis,
+            long pitCurrent,
+            long suggestCount,
+            long suggestTimeInMillis,
+            long suggestCurrent
+        ) {
+            this.queryCount = queryCount;
+            this.queryTimeInMillis = queryTimeInMillis;
+            this.queryCurrent = queryCurrent;
+
+            this.fetchCount = fetchCount;
+            this.fetchTimeInMillis = fetchTimeInMillis;
+            this.fetchCurrent = fetchCurrent;
+
+            this.scrollCount = scrollCount;
+            this.scrollTimeInMillis = scrollTimeInMillis;
+            this.scrollCurrent = scrollCurrent;
+
+            this.suggestCount = suggestCount;
+            this.suggestTimeInMillis = suggestTimeInMillis;
+            this.suggestCurrent = suggestCurrent;
+
+            this.pitCount = pitCount;
+            this.pitTimeInMillis = pitTimeInMillis;
+            this.pitCurrent = pitCurrent;
+        }
+
+        private Stats(CodedInputStream in) throws IOException {
+            queryCount = in.readInt64();
+            queryTimeInMillis = in.readInt64();
+            queryCurrent = in.readInt64();
+
+            fetchCount = in.readInt64();
+            fetchTimeInMillis = in.readInt64();
+            fetchCurrent = in.readInt64();
+
+            scrollCount = in.readInt64();
+            scrollTimeInMillis = in.readInt64();
+            scrollCurrent = in.readInt64();
+
+            suggestCount = in.readInt64();
+            suggestTimeInMillis = in.readInt64();
+            suggestCurrent = in.readInt64();
+
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+            if (protobufStreamInput.getVersion().onOrAfter(Version.V_2_4_0)) {
+                pitCount = in.readInt64();
+                pitTimeInMillis = in.readInt64();
+                pitCurrent = in.readInt64();
+            }
+        }
+
+        public void add(Stats stats) {
+            queryCount += stats.queryCount;
+            queryTimeInMillis += stats.queryTimeInMillis;
+            queryCurrent += stats.queryCurrent;
+
+            fetchCount += stats.fetchCount;
+            fetchTimeInMillis += stats.fetchTimeInMillis;
+            fetchCurrent += stats.fetchCurrent;
+
+            scrollCount += stats.scrollCount;
+            scrollTimeInMillis += stats.scrollTimeInMillis;
+            scrollCurrent += stats.scrollCurrent;
+
+            suggestCount += stats.suggestCount;
+            suggestTimeInMillis += stats.suggestTimeInMillis;
+            suggestCurrent += stats.suggestCurrent;
+
+            pitCount += stats.pitCount;
+            pitTimeInMillis += stats.pitTimeInMillis;
+            pitCurrent += stats.pitCurrent;
+        }
+
+        public void addForClosingShard(Stats stats) {
+            queryCount += stats.queryCount;
+            queryTimeInMillis += stats.queryTimeInMillis;
+
+            fetchCount += stats.fetchCount;
+            fetchTimeInMillis += stats.fetchTimeInMillis;
+
+            scrollCount += stats.scrollCount;
+            scrollTimeInMillis += stats.scrollTimeInMillis;
+            // need consider the count of the shard's current scroll
+            scrollCount += stats.scrollCurrent;
+
+            suggestCount += stats.suggestCount;
+            suggestTimeInMillis += stats.suggestTimeInMillis;
+
+            pitCount += stats.pitCount;
+            pitTimeInMillis += stats.pitTimeInMillis;
+            pitCurrent += stats.pitCurrent;
+        }
+
+        public long getQueryCount() {
+            return queryCount;
+        }
+
+        public TimeValue getQueryTime() {
+            return new TimeValue(queryTimeInMillis);
+        }
+
+        public long getQueryTimeInMillis() {
+            return queryTimeInMillis;
+        }
+
+        public long getQueryCurrent() {
+            return queryCurrent;
+        }
+
+        public long getFetchCount() {
+            return fetchCount;
+        }
+
+        public TimeValue getFetchTime() {
+            return new TimeValue(fetchTimeInMillis);
+        }
+
+        public long getFetchTimeInMillis() {
+            return fetchTimeInMillis;
+        }
+
+        public long getFetchCurrent() {
+            return fetchCurrent;
+        }
+
+        public long getScrollCount() {
+            return scrollCount;
+        }
+
+        public TimeValue getScrollTime() {
+            return new TimeValue(scrollTimeInMillis);
+        }
+
+        public long getScrollTimeInMillis() {
+            return scrollTimeInMillis;
+        }
+
+        public long getScrollCurrent() {
+            return scrollCurrent;
+        }
+
+        public long getPitCount() {
+            return pitCount;
+        }
+
+        public TimeValue getPitTime() {
+            return new TimeValue(pitTimeInMillis);
+        }
+
+        public long getPitTimeInMillis() {
+            return pitTimeInMillis;
+        }
+
+        public long getPitCurrent() {
+            return pitCurrent;
+        }
+
+        public long getSuggestCount() {
+            return suggestCount;
+        }
+
+        public long getSuggestTimeInMillis() {
+            return suggestTimeInMillis;
+        }
+
+        public TimeValue getSuggestTime() {
+            return new TimeValue(suggestTimeInMillis);
+        }
+
+        public long getSuggestCurrent() {
+            return suggestCurrent;
+        }
+
+        public static Stats readStats(CodedInputStream in) throws IOException {
+            return new Stats(in);
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeInt64NoTag(queryCount);
+            out.writeInt64NoTag(queryTimeInMillis);
+            out.writeInt64NoTag(queryCurrent);
+
+            out.writeInt64NoTag(fetchCount);
+            out.writeInt64NoTag(fetchTimeInMillis);
+            out.writeInt64NoTag(fetchCurrent);
+
+            out.writeInt64NoTag(scrollCount);
+            out.writeInt64NoTag(scrollTimeInMillis);
+            out.writeInt64NoTag(scrollCurrent);
+
+            out.writeInt64NoTag(suggestCount);
+            out.writeInt64NoTag(suggestTimeInMillis);
+            out.writeInt64NoTag(suggestCurrent);
+
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+            if (protobufStreamOutput.getVersion().onOrAfter(Version.V_2_4_0)) {
+                out.writeInt64NoTag(pitCount);
+                out.writeInt64NoTag(pitTimeInMillis);
+                out.writeInt64NoTag(pitCurrent);
+            }
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.field(Fields.QUERY_TOTAL, queryCount);
+            builder.humanReadableField(Fields.QUERY_TIME_IN_MILLIS, Fields.QUERY_TIME, getQueryTime());
+            builder.field(Fields.QUERY_CURRENT, queryCurrent);
+
+            builder.field(Fields.FETCH_TOTAL, fetchCount);
+            builder.humanReadableField(Fields.FETCH_TIME_IN_MILLIS, Fields.FETCH_TIME, getFetchTime());
+            builder.field(Fields.FETCH_CURRENT, fetchCurrent);
+
+            builder.field(Fields.SCROLL_TOTAL, scrollCount);
+            builder.humanReadableField(Fields.SCROLL_TIME_IN_MILLIS, Fields.SCROLL_TIME, getScrollTime());
+            builder.field(Fields.SCROLL_CURRENT, scrollCurrent);
+
+            builder.field(Fields.PIT_TOTAL, pitCount);
+            builder.humanReadableField(Fields.PIT_TIME_IN_MILLIS, Fields.PIT_TIME, getPitTime());
+            builder.field(Fields.PIT_CURRENT, pitCurrent);
+
+            builder.field(Fields.SUGGEST_TOTAL, suggestCount);
+            builder.humanReadableField(Fields.SUGGEST_TIME_IN_MILLIS, Fields.SUGGEST_TIME, getSuggestTime());
+            builder.field(Fields.SUGGEST_CURRENT, suggestCurrent);
+
+            return builder;
+        }
+    }
+
+    private final Stats totalStats;
+    private long openContexts;
+
+    @Nullable
+    private Map<String, Stats> groupStats;
+
+    public ProtobufSearchStats() {
+        totalStats = new Stats();
+    }
+
+    public ProtobufSearchStats(Stats totalStats, long openContexts, @Nullable Map<String, Stats> groupStats) {
+        this.totalStats = totalStats;
+        this.openContexts = openContexts;
+        this.groupStats = groupStats;
+    }
+
+    public ProtobufSearchStats(CodedInputStream in) throws IOException {
+        totalStats = Stats.readStats(in);
+        openContexts = in.readInt64();
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        if (protobufStreamInput.readBoolean()) {
+            groupStats = protobufStreamInput.readMap(CodedInputStream::readString, Stats::readStats);
+        }
+    }
+
+    public void add(ProtobufSearchStats searchStats) {
+        if (searchStats == null) {
+            return;
+        }
+        addTotals(searchStats);
+        openContexts += searchStats.openContexts;
+        if (searchStats.groupStats != null && !searchStats.groupStats.isEmpty()) {
+            if (groupStats == null) {
+                groupStats = new HashMap<>(searchStats.groupStats.size());
+            }
+            for (Map.Entry<String, Stats> entry : searchStats.groupStats.entrySet()) {
+                groupStats.putIfAbsent(entry.getKey(), new Stats());
+                groupStats.get(entry.getKey()).add(entry.getValue());
+            }
+        }
+    }
+
+    public void addTotals(ProtobufSearchStats searchStats) {
+        if (searchStats == null) {
+            return;
+        }
+        totalStats.add(searchStats.totalStats);
+    }
+
+    public void addTotalsForClosingShard(ProtobufSearchStats searchStats) {
+        if (searchStats == null) {
+            return;
+        }
+        totalStats.addForClosingShard(searchStats.totalStats);
+    }
+
+    public Stats getTotal() {
+        return this.totalStats;
+    }
+
+    public long getOpenContexts() {
+        return this.openContexts;
+    }
+
+    @Nullable
+    public Map<String, Stats> getGroupStats() {
+        return this.groupStats != null ? Collections.unmodifiableMap(this.groupStats) : null;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params params) throws IOException {
+        builder.startObject(Fields.SEARCH);
+        builder.field(Fields.OPEN_CONTEXTS, openContexts);
+        totalStats.toXContent(builder, params);
+        if (groupStats != null && !groupStats.isEmpty()) {
+            builder.startObject(Fields.GROUPS);
+            for (Map.Entry<String, Stats> entry : groupStats.entrySet()) {
+                builder.startObject(entry.getKey());
+                entry.getValue().toXContent(builder, params);
+                builder.endObject();
+            }
+            builder.endObject();
+        }
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public String toString() {
+        return Strings.toString(XContentType.JSON, this, true, true);
+    }
+
+    /**
+     * Fields for search statistics
+    *
+    * @opensearch.internal
+    */
+    static final class Fields {
+        static final String SEARCH = "search";
+        static final String OPEN_CONTEXTS = "open_contexts";
+        static final String GROUPS = "groups";
+        static final String QUERY_TOTAL = "query_total";
+        static final String QUERY_TIME = "query_time";
+        static final String QUERY_TIME_IN_MILLIS = "query_time_in_millis";
+        static final String QUERY_CURRENT = "query_current";
+        static final String FETCH_TOTAL = "fetch_total";
+        static final String FETCH_TIME = "fetch_time";
+        static final String FETCH_TIME_IN_MILLIS = "fetch_time_in_millis";
+        static final String FETCH_CURRENT = "fetch_current";
+        static final String SCROLL_TOTAL = "scroll_total";
+        static final String SCROLL_TIME = "scroll_time";
+        static final String SCROLL_TIME_IN_MILLIS = "scroll_time_in_millis";
+        static final String SCROLL_CURRENT = "scroll_current";
+        static final String PIT_TOTAL = "point_in_time_total";
+        static final String PIT_TIME = "point_in_time_time";
+        static final String PIT_TIME_IN_MILLIS = "point_in_time_time_in_millis";
+        static final String PIT_CURRENT = "point_in_time_current";
+        static final String SUGGEST_TOTAL = "suggest_total";
+        static final String SUGGEST_TIME = "suggest_time";
+        static final String SUGGEST_TIME_IN_MILLIS = "suggest_time_in_millis";
+        static final String SUGGEST_CURRENT = "suggest_current";
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        totalStats.writeTo(out);
+        out.writeInt64NoTag(openContexts);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        if (groupStats == null || groupStats.isEmpty()) {
+            out.writeBoolNoTag(false);
+        } else {
+            out.writeBoolNoTag(true);
+            protobufStreamOutput.writeMap(groupStats, CodedOutputStream::writeStringNoTag, (stream, stats) -> stats.writeTo(stream));
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/shard/ProtobufDocsStats.java b/server/src/main/java/org/opensearch/index/shard/ProtobufDocsStats.java
new file mode 100644
index 0000000000000..2ecfa368dec0f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/shard/ProtobufDocsStats.java
@@ -0,0 +1,110 @@
+/*
+* 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.
+*/
+
+package org.opensearch.index.shard;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.store.StoreStats;
+
+import java.io.IOException;
+
+/**
+ * Document statistics
+*
+* @opensearch.internal
+*/
+public class ProtobufDocsStats implements ProtobufWriteable, ToXContentFragment {
+
+    private long count = 0;
+    private long deleted = 0;
+    private long totalSizeInBytes = 0;
+
+    public ProtobufDocsStats() {
+
+    }
+
+    public ProtobufDocsStats(CodedInputStream in) throws IOException {
+        count = in.readInt64();
+        deleted = in.readInt64();
+        totalSizeInBytes = in.readInt64();
+    }
+
+    public ProtobufDocsStats(long count, long deleted, long totalSizeInBytes) {
+        this.count = count;
+        this.deleted = deleted;
+        this.totalSizeInBytes = totalSizeInBytes;
+    }
+
+    public void add(ProtobufDocsStats other) {
+        if (other == null) {
+            return;
+        }
+        if (this.totalSizeInBytes == -1) {
+            this.totalSizeInBytes = other.totalSizeInBytes;
+        } else if (other.totalSizeInBytes != -1) {
+            this.totalSizeInBytes += other.totalSizeInBytes;
+        }
+        this.count += other.count;
+        this.deleted += other.deleted;
+    }
+
+    public long getCount() {
+        return this.count;
+    }
+
+    public long getDeleted() {
+        return this.deleted;
+    }
+
+    /**
+     * Returns the total size in bytes of all documents in this stats.
+    * This value may be more reliable than {@link StoreStats#getSizeInBytes()} in estimating the index size.
+    */
+    public long getTotalSizeInBytes() {
+        return totalSizeInBytes;
+    }
+
+    /**
+     * Returns the average size in bytes of all documents in this stats.
+    */
+    public long getAverageSizeInBytes() {
+        long totalDocs = count + deleted;
+        return totalDocs == 0 ? 0 : totalSizeInBytes / totalDocs;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(count);
+        out.writeInt64NoTag(deleted);
+        out.writeInt64NoTag(totalSizeInBytes);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.DOCS);
+        builder.field(Fields.COUNT, count);
+        builder.field(Fields.DELETED, deleted);
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * Fields for document statistics
+    *
+    * @opensearch.internal
+    */
+    static final class Fields {
+        static final String DOCS = "docs";
+        static final String COUNT = "count";
+        static final String DELETED = "deleted";
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/shard/ProtobufIndexingStats.java b/server/src/main/java/org/opensearch/index/shard/ProtobufIndexingStats.java
new file mode 100644
index 0000000000000..04e851da6307e
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/shard/ProtobufIndexingStats.java
@@ -0,0 +1,286 @@
+/*
+* 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.
+*/
+
+package org.opensearch.index.shard;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.Version;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.mapper.MapperService;
+
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * Tracks indexing statistics
+*
+* @opensearch.internal
+*/
+public class ProtobufIndexingStats implements ProtobufWriteable, ToXContentFragment {
+
+    /**
+     * Internal statistics for indexing
+    *
+    * @opensearch.internal
+    */
+    public static class Stats implements ProtobufWriteable, ToXContentFragment {
+
+        private long indexCount;
+        private long indexTimeInMillis;
+        private long indexCurrent;
+        private long indexFailedCount;
+        private long deleteCount;
+        private long deleteTimeInMillis;
+        private long deleteCurrent;
+        private long noopUpdateCount;
+        private long throttleTimeInMillis;
+        private boolean isThrottled;
+
+        Stats() {}
+
+        public Stats(CodedInputStream in) throws IOException {
+            indexCount = in.readInt64();
+            indexTimeInMillis = in.readInt64();
+            indexCurrent = in.readInt64();
+            indexFailedCount = in.readInt64();
+            deleteCount = in.readInt64();
+            deleteTimeInMillis = in.readInt64();
+            deleteCurrent = in.readInt64();
+            noopUpdateCount = in.readInt64();
+            isThrottled = in.readBool();
+            throttleTimeInMillis = in.readInt64();
+        }
+
+        public Stats(
+            long indexCount,
+            long indexTimeInMillis,
+            long indexCurrent,
+            long indexFailedCount,
+            long deleteCount,
+            long deleteTimeInMillis,
+            long deleteCurrent,
+            long noopUpdateCount,
+            boolean isThrottled,
+            long throttleTimeInMillis
+        ) {
+            this.indexCount = indexCount;
+            this.indexTimeInMillis = indexTimeInMillis;
+            this.indexCurrent = indexCurrent;
+            this.indexFailedCount = indexFailedCount;
+            this.deleteCount = deleteCount;
+            this.deleteTimeInMillis = deleteTimeInMillis;
+            this.deleteCurrent = deleteCurrent;
+            this.noopUpdateCount = noopUpdateCount;
+            this.isThrottled = isThrottled;
+            this.throttleTimeInMillis = throttleTimeInMillis;
+        }
+
+        public void add(Stats stats) {
+            indexCount += stats.indexCount;
+            indexTimeInMillis += stats.indexTimeInMillis;
+            indexCurrent += stats.indexCurrent;
+            indexFailedCount += stats.indexFailedCount;
+
+            deleteCount += stats.deleteCount;
+            deleteTimeInMillis += stats.deleteTimeInMillis;
+            deleteCurrent += stats.deleteCurrent;
+
+            noopUpdateCount += stats.noopUpdateCount;
+            throttleTimeInMillis += stats.throttleTimeInMillis;
+            if (isThrottled != stats.isThrottled) {
+                isThrottled = true; // When combining if one is throttled set result to throttled.
+            }
+        }
+
+        /**
+         * The total number of indexing operations
+        */
+        public long getIndexCount() {
+            return indexCount;
+        }
+
+        /**
+         * The number of failed indexing operations
+        */
+        public long getIndexFailedCount() {
+            return indexFailedCount;
+        }
+
+        /**
+         * The total amount of time spend on executing index operations.
+        */
+        public TimeValue getIndexTime() {
+            return new TimeValue(indexTimeInMillis);
+        }
+
+        /**
+         * Returns the currently in-flight indexing operations.
+        */
+        public long getIndexCurrent() {
+            return indexCurrent;
+        }
+
+        /**
+         * Returns the number of delete operation executed
+        */
+        public long getDeleteCount() {
+            return deleteCount;
+        }
+
+        /**
+         * Returns if the index is under merge throttling control
+        */
+        public boolean isThrottled() {
+            return isThrottled;
+        }
+
+        /**
+         * Gets the amount of time in a TimeValue that the index has been under merge throttling control
+        */
+        public TimeValue getThrottleTime() {
+            return new TimeValue(throttleTimeInMillis);
+        }
+
+        /**
+         * The total amount of time spend on executing delete operations.
+        */
+        public TimeValue getDeleteTime() {
+            return new TimeValue(deleteTimeInMillis);
+        }
+
+        /**
+         * Returns the currently in-flight delete operations
+        */
+        public long getDeleteCurrent() {
+            return deleteCurrent;
+        }
+
+        public long getNoopUpdateCount() {
+            return noopUpdateCount;
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeInt64NoTag(indexCount);
+            out.writeInt64NoTag(indexTimeInMillis);
+            out.writeInt64NoTag(indexCurrent);
+            out.writeInt64NoTag(indexFailedCount);
+            out.writeInt64NoTag(deleteCount);
+            out.writeInt64NoTag(deleteTimeInMillis);
+            out.writeInt64NoTag(deleteCurrent);
+            out.writeInt64NoTag(noopUpdateCount);
+            out.writeBoolNoTag(isThrottled);
+            out.writeInt64NoTag(throttleTimeInMillis);
+
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.field(Fields.INDEX_TOTAL, indexCount);
+            builder.humanReadableField(Fields.INDEX_TIME_IN_MILLIS, Fields.INDEX_TIME, getIndexTime());
+            builder.field(Fields.INDEX_CURRENT, indexCurrent);
+            builder.field(Fields.INDEX_FAILED, indexFailedCount);
+
+            builder.field(Fields.DELETE_TOTAL, deleteCount);
+            builder.humanReadableField(Fields.DELETE_TIME_IN_MILLIS, Fields.DELETE_TIME, getDeleteTime());
+            builder.field(Fields.DELETE_CURRENT, deleteCurrent);
+
+            builder.field(Fields.NOOP_UPDATE_TOTAL, noopUpdateCount);
+
+            builder.field(Fields.IS_THROTTLED, isThrottled);
+            builder.humanReadableField(Fields.THROTTLED_TIME_IN_MILLIS, Fields.THROTTLED_TIME, getThrottleTime());
+            return builder;
+        }
+    }
+
+    private final Stats totalStats;
+
+    public ProtobufIndexingStats() {
+        totalStats = new Stats();
+    }
+
+    public ProtobufIndexingStats(CodedInputStream in) throws IOException {
+        totalStats = new Stats(in);
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        if (protobufStreamInput.getVersion().before(Version.V_2_0_0)) {
+            if (protobufStreamInput.readBoolean()) {
+                Map<String, Stats> typeStats = protobufStreamInput.readMap(CodedInputStream::readString, Stats::new);
+                assert typeStats.size() == 1;
+                assert typeStats.containsKey(MapperService.SINGLE_MAPPING_NAME);
+            }
+        }
+    }
+
+    public ProtobufIndexingStats(Stats totalStats) {
+        this.totalStats = totalStats;
+    }
+
+    public void add(ProtobufIndexingStats indexingStats) {
+        if (indexingStats == null) {
+            return;
+        }
+        addTotals(indexingStats);
+    }
+
+    public void addTotals(ProtobufIndexingStats indexingStats) {
+        if (indexingStats == null) {
+            return;
+        }
+        totalStats.add(indexingStats.totalStats);
+    }
+
+    public Stats getTotal() {
+        return this.totalStats;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params params) throws IOException {
+        builder.startObject(Fields.INDEXING);
+        totalStats.toXContent(builder, params);
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * Fields for indexing statistics
+    *
+    * @opensearch.internal
+    */
+    static final class Fields {
+        static final String INDEXING = "indexing";
+        static final String INDEX_TOTAL = "index_total";
+        static final String INDEX_TIME = "index_time";
+        static final String INDEX_TIME_IN_MILLIS = "index_time_in_millis";
+        static final String INDEX_CURRENT = "index_current";
+        static final String INDEX_FAILED = "index_failed";
+        static final String DELETE_TOTAL = "delete_total";
+        static final String DELETE_TIME = "delete_time";
+        static final String DELETE_TIME_IN_MILLIS = "delete_time_in_millis";
+        static final String DELETE_CURRENT = "delete_current";
+        static final String NOOP_UPDATE_TOTAL = "noop_update_total";
+        static final String IS_THROTTLED = "is_throttled";
+        static final String THROTTLED_TIME_IN_MILLIS = "throttle_time_in_millis";
+        static final String THROTTLED_TIME = "throttle_time";
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        totalStats.writeTo(out);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        if (protobufStreamOutput.getVersion().before(Version.V_2_0_0)) {
+            out.writeBoolNoTag(false);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/store/ProtobufStoreStats.java b/server/src/main/java/org/opensearch/index/store/ProtobufStoreStats.java
new file mode 100644
index 0000000000000..58542143484b0
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/store/ProtobufStoreStats.java
@@ -0,0 +1,118 @@
+/*
+* 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.
+*/
+
+package org.opensearch.index.store;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+/**
+ * Statistics about an OpenSearch Store
+*
+* @opensearch.internal
+*/
+public class ProtobufStoreStats implements ProtobufWriteable, ToXContentFragment {
+
+    /**
+     * Sentinel value for cases where the shard does not yet know its reserved size so we must fall back to an estimate, for instance
+    * prior to receiving the list of files in a peer recovery.
+    */
+    public static final long UNKNOWN_RESERVED_BYTES = -1L;
+    private long sizeInBytes;
+    private long reservedSize;
+
+    public ProtobufStoreStats() {
+
+    }
+
+    public ProtobufStoreStats(CodedInputStream in) throws IOException {
+        sizeInBytes = in.readInt64();
+        reservedSize = in.readInt64();
+    }
+
+    /**
+     * @param sizeInBytes the size of the store in bytes
+    * @param reservedSize a prediction of how much larger the store is expected to grow, or {@link ProtobufStoreStats#UNKNOWN_RESERVED_BYTES}.
+    */
+    public ProtobufStoreStats(long sizeInBytes, long reservedSize) {
+        assert reservedSize == UNKNOWN_RESERVED_BYTES || reservedSize >= 0 : reservedSize;
+        this.sizeInBytes = sizeInBytes;
+        this.reservedSize = reservedSize;
+    }
+
+    public void add(ProtobufStoreStats stats) {
+        if (stats == null) {
+            return;
+        }
+        sizeInBytes += stats.sizeInBytes;
+        reservedSize = ignoreIfUnknown(reservedSize) + ignoreIfUnknown(stats.reservedSize);
+    }
+
+    private static long ignoreIfUnknown(long reservedSize) {
+        return reservedSize == UNKNOWN_RESERVED_BYTES ? 0L : reservedSize;
+    }
+
+    public long sizeInBytes() {
+        return sizeInBytes;
+    }
+
+    public long getSizeInBytes() {
+        return sizeInBytes;
+    }
+
+    public ByteSizeValue size() {
+        return new ByteSizeValue(sizeInBytes);
+    }
+
+    public ByteSizeValue getSize() {
+        return size();
+    }
+
+    /**
+     * A prediction of how much larger this store will eventually grow. For instance, if we are currently doing a peer recovery or restoring
+    * a snapshot into this store then we can account for the rest of the recovery using this field. A value of {@code -1B} indicates that
+    * the reserved size is unknown.
+    */
+    public ByteSizeValue getReservedSize() {
+        return new ByteSizeValue(reservedSize);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(sizeInBytes);
+        out.writeInt64NoTag(reservedSize);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.STORE);
+        builder.humanReadableField(Fields.SIZE_IN_BYTES, Fields.SIZE, size());
+        builder.humanReadableField(Fields.RESERVED_IN_BYTES, Fields.RESERVED, getReservedSize());
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * Fields for store statistics
+    *
+    * @opensearch.internal
+    */
+    static final class Fields {
+        static final String STORE = "store";
+        static final String SIZE = "size";
+        static final String SIZE_IN_BYTES = "size_in_bytes";
+        static final String RESERVED = "reserved";
+        static final String RESERVED_IN_BYTES = "reserved_in_bytes";
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/translog/ProtobufTranslogStats.java b/server/src/main/java/org/opensearch/index/translog/ProtobufTranslogStats.java
new file mode 100644
index 0000000000000..d45d6cb926edd
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/translog/ProtobufTranslogStats.java
@@ -0,0 +1,137 @@
+/*
+* 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.
+*/
+
+package org.opensearch.index.translog;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.Strings;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.common.xcontent.XContentType;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+/**
+ * Translog statistics
+*
+* @opensearch.internal
+*/
+public class ProtobufTranslogStats implements ProtobufWriteable, ToXContentFragment {
+
+    private long translogSizeInBytes;
+    private int numberOfOperations;
+    private long uncommittedSizeInBytes;
+    private int uncommittedOperations;
+    private long earliestLastModifiedAge;
+
+    public ProtobufTranslogStats() {}
+
+    public ProtobufTranslogStats(CodedInputStream in) throws IOException {
+        numberOfOperations = in.readInt32();
+        translogSizeInBytes = in.readInt64();
+        uncommittedOperations = in.readInt32();
+        uncommittedSizeInBytes = in.readInt64();
+        earliestLastModifiedAge = in.readInt64();
+    }
+
+    public ProtobufTranslogStats(
+        int numberOfOperations,
+        long translogSizeInBytes,
+        int uncommittedOperations,
+        long uncommittedSizeInBytes,
+        long earliestLastModifiedAge
+    ) {
+        if (numberOfOperations < 0) {
+            throw new IllegalArgumentException("numberOfOperations must be >= 0");
+        }
+        if (translogSizeInBytes < 0) {
+            throw new IllegalArgumentException("translogSizeInBytes must be >= 0");
+        }
+        if (uncommittedOperations < 0) {
+            throw new IllegalArgumentException("uncommittedOperations must be >= 0");
+        }
+        if (uncommittedSizeInBytes < 0) {
+            throw new IllegalArgumentException("uncommittedSizeInBytes must be >= 0");
+        }
+        if (earliestLastModifiedAge < 0) {
+            throw new IllegalArgumentException("earliestLastModifiedAge must be >= 0");
+        }
+        this.numberOfOperations = numberOfOperations;
+        this.translogSizeInBytes = translogSizeInBytes;
+        this.uncommittedSizeInBytes = uncommittedSizeInBytes;
+        this.uncommittedOperations = uncommittedOperations;
+        this.earliestLastModifiedAge = earliestLastModifiedAge;
+    }
+
+    public void add(ProtobufTranslogStats translogStats) {
+        if (translogStats == null) {
+            return;
+        }
+
+        this.numberOfOperations += translogStats.numberOfOperations;
+        this.translogSizeInBytes += translogStats.translogSizeInBytes;
+        this.uncommittedOperations += translogStats.uncommittedOperations;
+        this.uncommittedSizeInBytes += translogStats.uncommittedSizeInBytes;
+        if (this.earliestLastModifiedAge == 0) {
+            this.earliestLastModifiedAge = translogStats.earliestLastModifiedAge;
+        } else {
+            this.earliestLastModifiedAge = Math.min(this.earliestLastModifiedAge, translogStats.earliestLastModifiedAge);
+        }
+    }
+
+    public long getTranslogSizeInBytes() {
+        return translogSizeInBytes;
+    }
+
+    public int estimatedNumberOfOperations() {
+        return numberOfOperations;
+    }
+
+    /** the size of the generations in the translog that weren't yet to committed to lucene */
+    public long getUncommittedSizeInBytes() {
+        return uncommittedSizeInBytes;
+    }
+
+    /** the number of operations in generations of the translog that weren't yet to committed to lucene */
+    public int getUncommittedOperations() {
+        return uncommittedOperations;
+    }
+
+    public long getEarliestLastModifiedAge() {
+        return earliestLastModifiedAge;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject("translog");
+        builder.field("operations", numberOfOperations);
+        builder.humanReadableField("size_in_bytes", "size", new ByteSizeValue(translogSizeInBytes));
+        builder.field("uncommitted_operations", uncommittedOperations);
+        builder.humanReadableField("uncommitted_size_in_bytes", "uncommitted_size", new ByteSizeValue(uncommittedSizeInBytes));
+        builder.field("earliest_last_modified_age", earliestLastModifiedAge);
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public String toString() {
+        return Strings.toString(XContentType.JSON, this, true, true);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt32NoTag(numberOfOperations);
+        out.writeInt64NoTag(translogSizeInBytes);
+        out.writeInt32NoTag(uncommittedOperations);
+        out.writeInt64NoTag(uncommittedSizeInBytes);
+        out.writeInt64NoTag(earliestLastModifiedAge);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/warmer/ProtobufWarmerStats.java b/server/src/main/java/org/opensearch/index/warmer/ProtobufWarmerStats.java
new file mode 100644
index 0000000000000..db45b2b37ba0f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/warmer/ProtobufWarmerStats.java
@@ -0,0 +1,118 @@
+/*
+* 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.
+*/
+
+package org.opensearch.index.warmer;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+/**
+ * Stats collected about the warmer
+*
+* @opensearch.internal
+*/
+public class ProtobufWarmerStats implements ProtobufWriteable, ToXContentFragment {
+
+    private long current;
+
+    private long total;
+
+    private long totalTimeInMillis;
+
+    public ProtobufWarmerStats() {
+
+    }
+
+    public ProtobufWarmerStats(CodedInputStream in) throws IOException {
+        current = in.readInt64();
+        total = in.readInt64();
+        totalTimeInMillis = in.readInt64();
+    }
+
+    public ProtobufWarmerStats(long current, long total, long totalTimeInMillis) {
+        this.current = current;
+        this.total = total;
+        this.totalTimeInMillis = totalTimeInMillis;
+    }
+
+    public void add(long current, long total, long totalTimeInMillis) {
+        this.current += current;
+        this.total += total;
+        this.totalTimeInMillis += totalTimeInMillis;
+    }
+
+    public void add(ProtobufWarmerStats warmerStats) {
+        if (warmerStats == null) {
+            return;
+        }
+        this.current += warmerStats.current;
+        this.total += warmerStats.total;
+        this.totalTimeInMillis += warmerStats.totalTimeInMillis;
+    }
+
+    public long current() {
+        return this.current;
+    }
+
+    /**
+     * The total number of warmer executed.
+    */
+    public long total() {
+        return this.total;
+    }
+
+    /**
+     * The total time warmer have been executed (in milliseconds).
+    */
+    public long totalTimeInMillis() {
+        return this.totalTimeInMillis;
+    }
+
+    /**
+     * The total time warmer have been executed.
+    */
+    public TimeValue totalTime() {
+        return new TimeValue(totalTimeInMillis);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.WARMER);
+        builder.field(Fields.CURRENT, current);
+        builder.field(Fields.TOTAL, total);
+        builder.humanReadableField(Fields.TOTAL_TIME_IN_MILLIS, Fields.TOTAL_TIME, totalTime());
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * Fields for warmer statistics
+    *
+    * @opensearch.internal
+    */
+    static final class Fields {
+        static final String WARMER = "warmer";
+        static final String CURRENT = "current";
+        static final String TOTAL = "total";
+        static final String TOTAL_TIME = "total_time";
+        static final String TOTAL_TIME_IN_MILLIS = "total_time_in_millis";
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(current);
+        out.writeInt64NoTag(total);
+        out.writeInt64NoTag(totalTimeInMillis);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/indices/ProtobufNodeIndicesStats.java b/server/src/main/java/org/opensearch/indices/ProtobufNodeIndicesStats.java
new file mode 100644
index 0000000000000..296dfb89bba05
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/ProtobufNodeIndicesStats.java
@@ -0,0 +1,165 @@
+/*
+* 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.
+*/
+
+package org.opensearch.indices;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.action.admin.indices.stats.ProtobufCommonStats;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.cache.query.ProtobufQueryCacheStats;
+import org.opensearch.index.cache.request.ProtobufRequestCacheStats;
+import org.opensearch.index.engine.ProtobufSegmentsStats;
+import org.opensearch.index.fielddata.ProtobufFieldDataStats;
+import org.opensearch.index.flush.ProtobufFlushStats;
+import org.opensearch.index.get.ProtobufGetStats;
+import org.opensearch.index.merge.ProtobufMergeStats;
+import org.opensearch.index.recovery.ProtobufRecoveryStats;
+import org.opensearch.index.refresh.ProtobufRefreshStats;
+import org.opensearch.index.search.stats.ProtobufSearchStats;
+import org.opensearch.index.shard.ProtobufDocsStats;
+import org.opensearch.index.shard.ProtobufIndexingStats;
+import org.opensearch.index.store.ProtobufStoreStats;
+import org.opensearch.index.translog.ProtobufTranslogStats;
+import org.opensearch.index.warmer.ProtobufWarmerStats;
+import org.opensearch.search.suggest.completion.ProtobufCompletionStats;
+
+import java.io.IOException;
+
+/**
+ * Global information on indices stats running on a specific node.
+*
+* @opensearch.internal
+*/
+public class ProtobufNodeIndicesStats implements ProtobufWriteable, ToXContentFragment {
+
+    private ProtobufCommonStats stats;
+
+    public ProtobufNodeIndicesStats(CodedInputStream in) throws IOException {
+        stats = new ProtobufCommonStats(in);
+    }
+
+    public ProtobufNodeIndicesStats(ProtobufCommonStats oldStats) {
+        // make a total common stats from old ones and current ones
+        this.stats = oldStats;
+    }
+
+    @Nullable
+    public ProtobufStoreStats getStore() {
+        return stats.getStore();
+    }
+
+    @Nullable
+    public ProtobufDocsStats getDocs() {
+        return stats.getDocs();
+    }
+
+    @Nullable
+    public ProtobufIndexingStats getIndexing() {
+        return stats.getIndexing();
+    }
+
+    @Nullable
+    public ProtobufGetStats getGet() {
+        return stats.getGet();
+    }
+
+    @Nullable
+    public ProtobufSearchStats getSearch() {
+        return stats.getSearch();
+    }
+
+    @Nullable
+    public ProtobufMergeStats getMerge() {
+        return stats.getMerge();
+    }
+
+    @Nullable
+    public ProtobufRefreshStats getRefresh() {
+        return stats.getRefresh();
+    }
+
+    @Nullable
+    public ProtobufFlushStats getFlush() {
+        return stats.getFlush();
+    }
+
+    @Nullable
+    public ProtobufWarmerStats getWarmer() {
+        return stats.getWarmer();
+    }
+
+    @Nullable
+    public ProtobufFieldDataStats getFieldData() {
+        return stats.getFieldData();
+    }
+
+    @Nullable
+    public ProtobufQueryCacheStats getQueryCache() {
+        return stats.getQueryCache();
+    }
+
+    @Nullable
+    public ProtobufRequestCacheStats getRequestCache() {
+        return stats.getRequestCache();
+    }
+
+    @Nullable
+    public ProtobufCompletionStats getCompletion() {
+        return stats.getCompletion();
+    }
+
+    @Nullable
+    public ProtobufSegmentsStats getSegments() {
+        return stats.getSegments();
+    }
+
+    @Nullable
+    public ProtobufTranslogStats getTranslog() {
+        return stats.getTranslog();
+    }
+
+    @Nullable
+    public ProtobufRecoveryStats getRecoveryStats() {
+        return stats.getRecoveryStats();
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        stats.writeTo(out);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        final String level = params.param("level", "node");
+        final boolean isLevelValid = "indices".equalsIgnoreCase(level)
+            || "node".equalsIgnoreCase(level)
+            || "shards".equalsIgnoreCase(level);
+        if (!isLevelValid) {
+            throw new IllegalArgumentException("level parameter must be one of [indices] or [node] or [shards] but was [" + level + "]");
+        }
+
+        // "node" level
+        builder.startObject(Fields.INDICES);
+        stats.toXContent(builder, params);
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * Fields used for parsing and toXContent
+    *
+    * @opensearch.internal
+    */
+    static final class Fields {
+        static final String INDICES = "indices";
+    }
+}
diff --git a/server/src/main/java/org/opensearch/indices/breaker/ProtobufAllCircuitBreakerStats.java b/server/src/main/java/org/opensearch/indices/breaker/ProtobufAllCircuitBreakerStats.java
new file mode 100644
index 0000000000000..220a7b5c37121
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/breaker/ProtobufAllCircuitBreakerStats.java
@@ -0,0 +1,78 @@
+/*
+* 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.
+*/
+
+package org.opensearch.indices.breaker;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+/**
+ * Stats class encapsulating all of the different circuit breaker stats
+*
+* @opensearch.internal
+*/
+public class ProtobufAllCircuitBreakerStats implements ProtobufWriteable, ToXContentFragment {
+
+    private final ProtobufCircuitBreakerStats[] allStats;
+
+    public ProtobufAllCircuitBreakerStats(ProtobufCircuitBreakerStats[] allStats) {
+        this.allStats = allStats;
+    }
+
+    public ProtobufAllCircuitBreakerStats(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        allStats = protobufStreamInput.readArray(ProtobufCircuitBreakerStats::new, ProtobufCircuitBreakerStats[]::new);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeArray((o, v) -> v.writeTo(o), allStats);
+    }
+
+    public ProtobufCircuitBreakerStats[] getAllStats() {
+        return this.allStats;
+    }
+
+    public ProtobufCircuitBreakerStats getStats(String name) {
+        for (ProtobufCircuitBreakerStats stats : allStats) {
+            if (stats.getName().equals(name)) {
+                return stats;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.BREAKERS);
+        for (ProtobufCircuitBreakerStats stats : allStats) {
+            if (stats != null) {
+                stats.toXContent(builder, params);
+            }
+        }
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * Fields used for parsing and toXContent
+    *
+    * @opensearch.internal
+    */
+    static final class Fields {
+        static final String BREAKERS = "breakers";
+    }
+}
diff --git a/server/src/main/java/org/opensearch/indices/breaker/ProtobufCircuitBreakerStats.java b/server/src/main/java/org/opensearch/indices/breaker/ProtobufCircuitBreakerStats.java
new file mode 100644
index 0000000000000..75f914f232354
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/breaker/ProtobufCircuitBreakerStats.java
@@ -0,0 +1,124 @@
+/*
+* 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.
+*/
+
+package org.opensearch.indices.breaker;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.core.xcontent.ToXContentObject;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Locale;
+
+/**
+ * Class encapsulating stats about the circuit breaker
+*
+* @opensearch.internal
+*/
+public class ProtobufCircuitBreakerStats implements ProtobufWriteable, ToXContentObject {
+
+    private final String name;
+    private final long limit;
+    private final long estimated;
+    private final long trippedCount;
+    private final double overhead;
+
+    public ProtobufCircuitBreakerStats(String name, long limit, long estimated, double overhead, long trippedCount) {
+        this.name = name;
+        this.limit = limit;
+        this.estimated = estimated;
+        this.trippedCount = trippedCount;
+        this.overhead = overhead;
+    }
+
+    public ProtobufCircuitBreakerStats(CodedInputStream in) throws IOException {
+        this.limit = in.readInt64();
+        this.estimated = in.readInt64();
+        this.overhead = in.readDouble();
+        this.trippedCount = in.readInt64();
+        this.name = in.readString();
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(limit);
+        out.writeInt64NoTag(estimated);
+        out.writeDoubleNoTag(overhead);
+        out.writeInt64NoTag(trippedCount);
+        out.writeStringNoTag(name);
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public long getLimit() {
+        return this.limit;
+    }
+
+    public long getEstimated() {
+        return this.estimated;
+    }
+
+    public long getTrippedCount() {
+        return this.trippedCount;
+    }
+
+    public double getOverhead() {
+        return this.overhead;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(name.toLowerCase(Locale.ROOT));
+        builder.field(Fields.LIMIT, limit);
+        builder.field(Fields.LIMIT_HUMAN, new ByteSizeValue(limit));
+        builder.field(Fields.ESTIMATED, estimated);
+        builder.field(Fields.ESTIMATED_HUMAN, new ByteSizeValue(estimated));
+        builder.field(Fields.OVERHEAD, overhead);
+        builder.field(Fields.TRIPPED_COUNT, trippedCount);
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public String toString() {
+        return "["
+            + this.name
+            + ",limit="
+            + this.limit
+            + "/"
+            + new ByteSizeValue(this.limit)
+            + ",estimated="
+            + this.estimated
+            + "/"
+            + new ByteSizeValue(this.estimated)
+            + ",overhead="
+            + this.overhead
+            + ",tripped="
+            + this.trippedCount
+            + "]";
+    }
+
+    /**
+     * Fields used for statistics
+    *
+    * @opensearch.internal
+    */
+    static final class Fields {
+        static final String LIMIT = "limit_size_in_bytes";
+        static final String LIMIT_HUMAN = "limit_size";
+        static final String ESTIMATED = "estimated_size_in_bytes";
+        static final String ESTIMATED_HUMAN = "estimated_size";
+        static final String OVERHEAD = "overhead";
+        static final String TRIPPED_COUNT = "tripped";
+    }
+}
diff --git a/server/src/main/java/org/opensearch/ingest/ProtobufIngestStats.java b/server/src/main/java/org/opensearch/ingest/ProtobufIngestStats.java
new file mode 100644
index 0000000000000..174885a879af4
--- /dev/null
+++ b/server/src/main/java/org/opensearch/ingest/ProtobufIngestStats.java
@@ -0,0 +1,351 @@
+/*
+* 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.
+*/
+
+package org.opensearch.ingest;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Stats for an ingest processor pipeline
+*
+* @opensearch.internal
+*/
+public class ProtobufIngestStats implements ProtobufWriteable, ToXContentFragment {
+    private final Stats totalStats;
+    private final List<PipelineStat> pipelineStats;
+    private final Map<String, List<ProcessorStat>> processorStats;
+
+    /**
+     * @param totalStats - The total stats for Ingest. This is the logically the sum of all pipeline stats,
+    *                   and pipeline stats are logically the sum of the processor stats.
+    * @param pipelineStats - The stats for a given ingest pipeline.
+    * @param processorStats - The per-processor stats for a given pipeline. A map keyed by the pipeline identifier.
+    */
+    public ProtobufIngestStats(Stats totalStats, List<PipelineStat> pipelineStats, Map<String, List<ProcessorStat>> processorStats) {
+        this.totalStats = totalStats;
+        this.pipelineStats = pipelineStats;
+        this.processorStats = processorStats;
+    }
+
+    /**
+     * Read from a stream.
+    */
+    public ProtobufIngestStats(CodedInputStream in) throws IOException {
+        this.totalStats = new Stats(in);
+        int size = in.readInt32();
+        this.pipelineStats = new ArrayList<>(size);
+        this.processorStats = new HashMap<>(size);
+        for (int i = 0; i < size; i++) {
+            String pipelineId = in.readString();
+            Stats pipelineStat = new Stats(in);
+            this.pipelineStats.add(new PipelineStat(pipelineId, pipelineStat));
+            int processorsSize = in.readInt32();
+            List<ProcessorStat> processorStatsPerPipeline = new ArrayList<>(processorsSize);
+            for (int j = 0; j < processorsSize; j++) {
+                String processorName = in.readString();
+                String processorType = "_NOT_AVAILABLE";
+                processorType = in.readString();
+                Stats processorStat = new Stats(in);
+                processorStatsPerPipeline.add(new ProcessorStat(processorName, processorType, processorStat));
+            }
+            this.processorStats.put(pipelineId, processorStatsPerPipeline);
+        }
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        totalStats.writeTo(out);
+        out.writeInt32NoTag(pipelineStats.size());
+        for (PipelineStat pipelineStat : pipelineStats) {
+            out.writeStringNoTag(pipelineStat.getPipelineId());
+            pipelineStat.getStats().writeTo(out);
+            List<ProcessorStat> processorStatsForPipeline = processorStats.get(pipelineStat.getPipelineId());
+            if (processorStatsForPipeline == null) {
+                out.writeInt32NoTag(0);
+            } else {
+                out.writeInt32NoTag(processorStatsForPipeline.size());
+                for (ProcessorStat processorStat : processorStatsForPipeline) {
+                    out.writeStringNoTag(processorStat.getName());
+                    out.writeStringNoTag(processorStat.getType());
+                    processorStat.getStats().writeTo(out);
+                }
+            }
+        }
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject("ingest");
+        builder.startObject("total");
+        totalStats.toXContent(builder, params);
+        builder.endObject();
+        builder.startObject("pipelines");
+        for (PipelineStat pipelineStat : pipelineStats) {
+            builder.startObject(pipelineStat.getPipelineId());
+            pipelineStat.getStats().toXContent(builder, params);
+            List<ProcessorStat> processorStatsForPipeline = processorStats.get(pipelineStat.getPipelineId());
+            builder.startArray("processors");
+            if (processorStatsForPipeline != null) {
+                for (ProcessorStat processorStat : processorStatsForPipeline) {
+                    builder.startObject();
+                    builder.startObject(processorStat.getName());
+                    builder.field("type", processorStat.getType());
+                    builder.startObject("stats");
+                    processorStat.getStats().toXContent(builder, params);
+                    builder.endObject();
+                    builder.endObject();
+                    builder.endObject();
+                }
+            }
+            builder.endArray();
+            builder.endObject();
+        }
+        builder.endObject();
+        builder.endObject();
+        return builder;
+    }
+
+    public Stats getTotalStats() {
+        return totalStats;
+    }
+
+    public List<PipelineStat> getPipelineStats() {
+        return pipelineStats;
+    }
+
+    public Map<String, List<ProcessorStat>> getProcessorStats() {
+        return processorStats;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ProtobufIngestStats that = (ProtobufIngestStats) o;
+        return Objects.equals(totalStats, that.totalStats)
+            && Objects.equals(pipelineStats, that.pipelineStats)
+            && Objects.equals(processorStats, that.processorStats);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(totalStats, pipelineStats, processorStats);
+    }
+
+    /**
+     * The ingest statistics.
+    *
+    * @opensearch.internal
+    */
+    public static class Stats implements ProtobufWriteable, ToXContentFragment {
+
+        private final long ingestCount;
+        private final long ingestTimeInMillis;
+        private final long ingestCurrent;
+        private final long ingestFailedCount;
+
+        public Stats(long ingestCount, long ingestTimeInMillis, long ingestCurrent, long ingestFailedCount) {
+            this.ingestCount = ingestCount;
+            this.ingestTimeInMillis = ingestTimeInMillis;
+            this.ingestCurrent = ingestCurrent;
+            this.ingestFailedCount = ingestFailedCount;
+        }
+
+        /**
+         * Read from a stream.
+        */
+        public Stats(CodedInputStream in) throws IOException {
+            ingestCount = in.readInt64();
+            ingestTimeInMillis = in.readInt64();
+            ingestCurrent = in.readInt64();
+            ingestFailedCount = in.readInt64();
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeInt64NoTag(ingestCount);
+            out.writeInt64NoTag(ingestTimeInMillis);
+            out.writeInt64NoTag(ingestCurrent);
+            out.writeInt64NoTag(ingestFailedCount);
+        }
+
+        /**
+         * @return The total number of executed ingest preprocessing operations.
+        */
+        public long getIngestCount() {
+            return ingestCount;
+        }
+
+        /**
+         * @return The total time spent of ingest preprocessing in millis.
+        */
+        public long getIngestTimeInMillis() {
+            return ingestTimeInMillis;
+        }
+
+        /**
+         * @return The total number of ingest preprocessing operations currently executing.
+        */
+        public long getIngestCurrent() {
+            return ingestCurrent;
+        }
+
+        /**
+         * @return The total number of ingest preprocessing operations that have failed.
+        */
+        public long getIngestFailedCount() {
+            return ingestFailedCount;
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.field("count", ingestCount);
+            builder.humanReadableField("time_in_millis", "time", new TimeValue(ingestTimeInMillis, TimeUnit.MILLISECONDS));
+            builder.field("current", ingestCurrent);
+            builder.field("failed", ingestFailedCount);
+            return builder;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            ProtobufIngestStats.Stats that = (ProtobufIngestStats.Stats) o;
+            return Objects.equals(ingestCount, that.ingestCount)
+                && Objects.equals(ingestTimeInMillis, that.ingestTimeInMillis)
+                && Objects.equals(ingestFailedCount, that.ingestFailedCount)
+                && Objects.equals(ingestCurrent, that.ingestCurrent);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(ingestCount, ingestTimeInMillis, ingestFailedCount, ingestCurrent);
+        }
+    }
+
+    /**
+     * Easy conversion from scoped {@link IngestMetric} objects to a serializable Stats objects
+    */
+    static class Builder {
+        private Stats totalStats;
+        private List<PipelineStat> pipelineStats = new ArrayList<>();
+        private Map<String, List<ProcessorStat>> processorStats = new HashMap<>();
+
+        Builder addTotalMetrics(IngestMetric totalMetric) {
+            this.totalStats = totalMetric.createProtobufStats();
+            return this;
+        }
+
+        Builder addPipelineMetrics(String pipelineId, IngestMetric pipelineMetric) {
+            this.pipelineStats.add(new PipelineStat(pipelineId, pipelineMetric.createProtobufStats()));
+            return this;
+        }
+
+        Builder addProcessorMetrics(String pipelineId, String processorName, String processorType, IngestMetric metric) {
+            this.processorStats.computeIfAbsent(pipelineId, k -> new ArrayList<>())
+                .add(new ProcessorStat(processorName, processorType, metric.createProtobufStats()));
+            return this;
+        }
+
+        ProtobufIngestStats build() {
+            return new ProtobufIngestStats(
+                totalStats,
+                Collections.unmodifiableList(pipelineStats),
+                Collections.unmodifiableMap(processorStats)
+            );
+        }
+    }
+
+    /**
+     * Container for pipeline stats.
+    */
+    public static class PipelineStat {
+        private final String pipelineId;
+        private final Stats stats;
+
+        public PipelineStat(String pipelineId, Stats stats) {
+            this.pipelineId = pipelineId;
+            this.stats = stats;
+        }
+
+        public String getPipelineId() {
+            return pipelineId;
+        }
+
+        public Stats getStats() {
+            return stats;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            ProtobufIngestStats.PipelineStat that = (ProtobufIngestStats.PipelineStat) o;
+            return Objects.equals(pipelineId, that.pipelineId) && Objects.equals(stats, that.stats);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(pipelineId, stats);
+        }
+    }
+
+    /**
+     * Container for processor stats.
+    */
+    public static class ProcessorStat {
+        private final String name;
+        private final String type;
+        private final Stats stats;
+
+        public ProcessorStat(String name, String type, Stats stats) {
+            this.name = name;
+            this.type = type;
+            this.stats = stats;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public String getType() {
+            return type;
+        }
+
+        public Stats getStats() {
+            return stats;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            ProtobufIngestStats.ProcessorStat that = (ProtobufIngestStats.ProcessorStat) o;
+            return Objects.equals(name, that.name) && Objects.equals(type, that.type) && Objects.equals(stats, that.stats);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(name, type, stats);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/monitor/fs/ProtobufFsInfo.java b/server/src/main/java/org/opensearch/monitor/fs/ProtobufFsInfo.java
new file mode 100644
index 0000000000000..88fb93b8bc7da
--- /dev/null
+++ b/server/src/main/java/org/opensearch/monitor/fs/ProtobufFsInfo.java
@@ -0,0 +1,554 @@
+/*
+* 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.
+*/
+
+package org.opensearch.monitor.fs;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.Version;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.ToXContentObject;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+/**
+ * FileSystem information
+*
+* @opensearch.internal
+*/
+public class ProtobufFsInfo implements Iterable<ProtobufFsInfo.Path>, ProtobufWriteable, ToXContentFragment {
+
+    /**
+     * Path for the file system
+    *
+    * @opensearch.internal
+    */
+    public static class Path implements ProtobufWriteable, ToXContentObject {
+
+        String path;
+        @Nullable
+        String mount;
+        /** File system type from {@code java.nio.file.FileStore type()}, if available. */
+        @Nullable
+        String type;
+        long total = -1;
+        long free = -1;
+        long available = -1;
+        long fileCacheReserved = -1;
+        long fileCacheUtilized = 0;
+
+        public Path() {}
+
+        public Path(String path, @Nullable String mount, long total, long free, long available) {
+            this.path = path;
+            this.mount = mount;
+            this.total = total;
+            this.free = free;
+            this.available = available;
+        }
+
+        /**
+         * Read from a stream.
+        */
+        public Path(CodedInputStream in) throws IOException {
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+            path = protobufStreamInput.readOptionalString();
+            mount = protobufStreamInput.readOptionalString();
+            type = protobufStreamInput.readOptionalString();
+            total = in.readInt64();
+            free = in.readInt64();
+            available = in.readInt64();
+            if (protobufStreamInput.getVersion().onOrAfter(Version.V_2_7_0)) {
+                fileCacheReserved = in.readInt64();
+                fileCacheUtilized = in.readInt64();
+            }
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+            protobufStreamOutput.writeOptionalString(path); // total aggregates do not have a path
+            protobufStreamOutput.writeOptionalString(mount);
+            protobufStreamOutput.writeOptionalString(type);
+            out.writeInt64NoTag(total);
+            out.writeInt64NoTag(free);
+            out.writeInt64NoTag(available);
+            if (protobufStreamOutput.getVersion().onOrAfter(Version.V_2_7_0)) {
+                out.writeInt64NoTag(fileCacheReserved);
+                out.writeInt64NoTag(fileCacheUtilized);
+            }
+        }
+
+        public String getPath() {
+            return path;
+        }
+
+        public String getMount() {
+            return mount;
+        }
+
+        public String getType() {
+            return type;
+        }
+
+        public ByteSizeValue getTotal() {
+            return new ByteSizeValue(total);
+        }
+
+        public ByteSizeValue getFree() {
+            return new ByteSizeValue(free);
+        }
+
+        public ByteSizeValue getAvailable() {
+            return new ByteSizeValue(available);
+        }
+
+        public ByteSizeValue getFileCacheReserved() {
+            return new ByteSizeValue(fileCacheReserved);
+        }
+
+        public ByteSizeValue getFileCacheUtilized() {
+            return new ByteSizeValue(fileCacheUtilized);
+        }
+
+        private long addLong(long current, long other) {
+            if (current == -1 && other == -1) {
+                return 0;
+            }
+            if (other == -1) {
+                return current;
+            }
+            if (current == -1) {
+                return other;
+            }
+            return current + other;
+        }
+
+        public void add(Path path) {
+            total = FsProbe.adjustForHugeFilesystems(addLong(total, path.total));
+            free = FsProbe.adjustForHugeFilesystems(addLong(free, path.free));
+            fileCacheReserved = FsProbe.adjustForHugeFilesystems(addLong(fileCacheReserved, path.fileCacheReserved));
+            fileCacheUtilized = FsProbe.adjustForHugeFilesystems(addLong(fileCacheUtilized, path.fileCacheUtilized));
+            available = FsProbe.adjustForHugeFilesystems(addLong(available, path.available));
+        }
+
+        static final class Fields {
+            static final String PATH = "path";
+            static final String MOUNT = "mount";
+            static final String TYPE = "type";
+            static final String TOTAL = "total";
+            static final String TOTAL_IN_BYTES = "total_in_bytes";
+            static final String FREE = "free";
+            static final String FREE_IN_BYTES = "free_in_bytes";
+            static final String AVAILABLE = "available";
+            static final String AVAILABLE_IN_BYTES = "available_in_bytes";
+            static final String CACHE_RESERVED = "cache_reserved";
+            static final String CACHE_RESERVED_IN_BYTES = "cache_reserved_in_bytes";
+            static final String CACHE_UTILIZED = "cache_utilized";
+            static final String CACHE_UTILIZED_IN_BYTES = "cache_utilized_in_bytes";
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.startObject();
+            if (path != null) {
+                builder.field(Fields.PATH, path);
+            }
+            if (mount != null) {
+                builder.field(Fields.MOUNT, mount);
+            }
+            if (type != null) {
+                builder.field(Fields.TYPE, type);
+            }
+
+            if (total != -1) {
+                builder.humanReadableField(Fields.TOTAL_IN_BYTES, Fields.TOTAL, getTotal());
+            }
+            if (free != -1) {
+                builder.humanReadableField(Fields.FREE_IN_BYTES, Fields.FREE, getFree());
+            }
+            if (available != -1) {
+                builder.humanReadableField(Fields.AVAILABLE_IN_BYTES, Fields.AVAILABLE, getAvailable());
+            }
+            if (fileCacheReserved != -1) {
+                builder.humanReadableField(Fields.CACHE_RESERVED_IN_BYTES, Fields.CACHE_RESERVED, getFileCacheReserved());
+            }
+            if (fileCacheReserved != 0) {
+                builder.humanReadableField(Fields.CACHE_UTILIZED, Fields.CACHE_UTILIZED_IN_BYTES, getFileCacheUtilized());
+            }
+
+            builder.endObject();
+            return builder;
+        }
+    }
+
+    /**
+     * The device status.
+    *
+    * @opensearch.internal
+    */
+    public static class DeviceStats implements ProtobufWriteable, ToXContentFragment {
+
+        final int majorDeviceNumber;
+        final int minorDeviceNumber;
+        final String deviceName;
+        final long currentReadsCompleted;
+        final long previousReadsCompleted;
+        final long currentSectorsRead;
+        final long previousSectorsRead;
+        final long currentWritesCompleted;
+        final long previousWritesCompleted;
+        final long currentSectorsWritten;
+        final long previousSectorsWritten;
+
+        public DeviceStats(
+            final int majorDeviceNumber,
+            final int minorDeviceNumber,
+            final String deviceName,
+            final long currentReadsCompleted,
+            final long currentSectorsRead,
+            final long currentWritesCompleted,
+            final long currentSectorsWritten,
+            final DeviceStats previousDeviceStats
+        ) {
+            this(
+                majorDeviceNumber,
+                minorDeviceNumber,
+                deviceName,
+                currentReadsCompleted,
+                previousDeviceStats != null ? previousDeviceStats.currentReadsCompleted : -1,
+                currentSectorsWritten,
+                previousDeviceStats != null ? previousDeviceStats.currentSectorsWritten : -1,
+                currentSectorsRead,
+                previousDeviceStats != null ? previousDeviceStats.currentSectorsRead : -1,
+                currentWritesCompleted,
+                previousDeviceStats != null ? previousDeviceStats.currentWritesCompleted : -1
+            );
+        }
+
+        private DeviceStats(
+            final int majorDeviceNumber,
+            final int minorDeviceNumber,
+            final String deviceName,
+            final long currentReadsCompleted,
+            final long previousReadsCompleted,
+            final long currentSectorsWritten,
+            final long previousSectorsWritten,
+            final long currentSectorsRead,
+            final long previousSectorsRead,
+            final long currentWritesCompleted,
+            final long previousWritesCompleted
+        ) {
+            this.majorDeviceNumber = majorDeviceNumber;
+            this.minorDeviceNumber = minorDeviceNumber;
+            this.deviceName = deviceName;
+            this.currentReadsCompleted = currentReadsCompleted;
+            this.previousReadsCompleted = previousReadsCompleted;
+            this.currentWritesCompleted = currentWritesCompleted;
+            this.previousWritesCompleted = previousWritesCompleted;
+            this.currentSectorsRead = currentSectorsRead;
+            this.previousSectorsRead = previousSectorsRead;
+            this.currentSectorsWritten = currentSectorsWritten;
+            this.previousSectorsWritten = previousSectorsWritten;
+        }
+
+        public DeviceStats(CodedInputStream in) throws IOException {
+            majorDeviceNumber = in.readInt32();
+            minorDeviceNumber = in.readInt32();
+            deviceName = in.readString();
+            currentReadsCompleted = in.readInt64();
+            previousReadsCompleted = in.readInt64();
+            currentWritesCompleted = in.readInt64();
+            previousWritesCompleted = in.readInt64();
+            currentSectorsRead = in.readInt64();
+            previousSectorsRead = in.readInt64();
+            currentSectorsWritten = in.readInt64();
+            previousSectorsWritten = in.readInt64();
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeInt32NoTag(majorDeviceNumber);
+            out.writeInt32NoTag(minorDeviceNumber);
+            out.writeStringNoTag(deviceName);
+            out.writeInt64NoTag(currentReadsCompleted);
+            out.writeInt64NoTag(previousReadsCompleted);
+            out.writeInt64NoTag(currentWritesCompleted);
+            out.writeInt64NoTag(previousWritesCompleted);
+            out.writeInt64NoTag(currentSectorsRead);
+            out.writeInt64NoTag(previousSectorsRead);
+            out.writeInt64NoTag(currentSectorsWritten);
+            out.writeInt64NoTag(previousSectorsWritten);
+        }
+
+        public long operations() {
+            if (previousReadsCompleted == -1 || previousWritesCompleted == -1) return -1;
+
+            return (currentReadsCompleted - previousReadsCompleted) + (currentWritesCompleted - previousWritesCompleted);
+        }
+
+        public long readOperations() {
+            if (previousReadsCompleted == -1) return -1;
+
+            return (currentReadsCompleted - previousReadsCompleted);
+        }
+
+        public long writeOperations() {
+            if (previousWritesCompleted == -1) return -1;
+
+            return (currentWritesCompleted - previousWritesCompleted);
+        }
+
+        public long readKilobytes() {
+            if (previousSectorsRead == -1) return -1;
+
+            return (currentSectorsRead - previousSectorsRead) / 2;
+        }
+
+        public long writeKilobytes() {
+            if (previousSectorsWritten == -1) return -1;
+
+            return (currentSectorsWritten - previousSectorsWritten) / 2;
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.field("device_name", deviceName);
+            builder.field(IoStats.OPERATIONS, operations());
+            builder.field(IoStats.READ_OPERATIONS, readOperations());
+            builder.field(IoStats.WRITE_OPERATIONS, writeOperations());
+            builder.field(IoStats.READ_KILOBYTES, readKilobytes());
+            builder.field(IoStats.WRITE_KILOBYTES, writeKilobytes());
+            return builder;
+        }
+
+    }
+
+    /**
+     * The I/O statistics.
+    *
+    * @opensearch.internal
+    */
+    public static class IoStats implements ProtobufWriteable, ToXContentFragment {
+
+        private static final String OPERATIONS = "operations";
+        private static final String READ_OPERATIONS = "read_operations";
+        private static final String WRITE_OPERATIONS = "write_operations";
+        private static final String READ_KILOBYTES = "read_kilobytes";
+        private static final String WRITE_KILOBYTES = "write_kilobytes";
+
+        final DeviceStats[] devicesStats;
+        final long totalOperations;
+        final long totalReadOperations;
+        final long totalWriteOperations;
+        final long totalReadKilobytes;
+        final long totalWriteKilobytes;
+
+        public IoStats(final DeviceStats[] devicesStats) {
+            this.devicesStats = devicesStats;
+            long totalOperations = 0;
+            long totalReadOperations = 0;
+            long totalWriteOperations = 0;
+            long totalReadKilobytes = 0;
+            long totalWriteKilobytes = 0;
+            for (DeviceStats deviceStats : devicesStats) {
+                totalOperations += deviceStats.operations() != -1 ? deviceStats.operations() : 0;
+                totalReadOperations += deviceStats.readOperations() != -1 ? deviceStats.readOperations() : 0;
+                totalWriteOperations += deviceStats.writeOperations() != -1 ? deviceStats.writeOperations() : 0;
+                totalReadKilobytes += deviceStats.readKilobytes() != -1 ? deviceStats.readKilobytes() : 0;
+                totalWriteKilobytes += deviceStats.writeKilobytes() != -1 ? deviceStats.writeKilobytes() : 0;
+            }
+            this.totalOperations = totalOperations;
+            this.totalReadOperations = totalReadOperations;
+            this.totalWriteOperations = totalWriteOperations;
+            this.totalReadKilobytes = totalReadKilobytes;
+            this.totalWriteKilobytes = totalWriteKilobytes;
+        }
+
+        public IoStats(CodedInputStream in) throws IOException {
+            final int length = in.readInt32();
+            final DeviceStats[] devicesStats = new DeviceStats[length];
+            for (int i = 0; i < length; i++) {
+                devicesStats[i] = new DeviceStats(in);
+            }
+            this.devicesStats = devicesStats;
+            this.totalOperations = in.readInt64();
+            this.totalReadOperations = in.readInt64();
+            this.totalWriteOperations = in.readInt64();
+            this.totalReadKilobytes = in.readInt64();
+            this.totalWriteKilobytes = in.readInt64();
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeInt32NoTag(devicesStats.length);
+            for (int i = 0; i < devicesStats.length; i++) {
+                devicesStats[i].writeTo(out);
+            }
+            out.writeInt64NoTag(totalOperations);
+            out.writeInt64NoTag(totalReadOperations);
+            out.writeInt64NoTag(totalWriteOperations);
+            out.writeInt64NoTag(totalReadKilobytes);
+            out.writeInt64NoTag(totalWriteKilobytes);
+        }
+
+        public DeviceStats[] getDevicesStats() {
+            return devicesStats;
+        }
+
+        public long getTotalOperations() {
+            return totalOperations;
+        }
+
+        public long getTotalReadOperations() {
+            return totalReadOperations;
+        }
+
+        public long getTotalWriteOperations() {
+            return totalWriteOperations;
+        }
+
+        public long getTotalReadKilobytes() {
+            return totalReadKilobytes;
+        }
+
+        public long getTotalWriteKilobytes() {
+            return totalWriteKilobytes;
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            if (devicesStats.length > 0) {
+                builder.startArray("devices");
+                for (DeviceStats deviceStats : devicesStats) {
+                    builder.startObject();
+                    deviceStats.toXContent(builder, params);
+                    builder.endObject();
+                }
+                builder.endArray();
+
+                builder.startObject("total");
+                builder.field(OPERATIONS, totalOperations);
+                builder.field(READ_OPERATIONS, totalReadOperations);
+                builder.field(WRITE_OPERATIONS, totalWriteOperations);
+                builder.field(READ_KILOBYTES, totalReadKilobytes);
+                builder.field(WRITE_KILOBYTES, totalWriteKilobytes);
+                builder.endObject();
+            }
+            return builder;
+        }
+
+    }
+
+    private final long timestamp;
+    private final Path[] paths;
+    private final IoStats ioStats;
+    private final Path total;
+
+    public ProtobufFsInfo(long timestamp, IoStats ioStats, Path[] paths) {
+        this.timestamp = timestamp;
+        this.ioStats = ioStats;
+        this.paths = paths;
+        this.total = total();
+    }
+
+    /**
+     * Read from a stream.
+    */
+    public ProtobufFsInfo(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        timestamp = in.readInt64();
+        ioStats = protobufStreamInput.readOptionalWriteable(IoStats::new);
+        paths = new Path[in.readInt32()];
+        for (int i = 0; i < paths.length; i++) {
+            paths[i] = new Path(in);
+        }
+        this.total = total();
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        out.writeInt64NoTag(timestamp);
+        protobufStreamOutput.writeOptionalWriteable(ioStats);
+        out.writeInt32NoTag(paths.length);
+        for (Path path : paths) {
+            path.writeTo(out);
+        }
+    }
+
+    public Path getTotal() {
+        return total;
+    }
+
+    private Path total() {
+        Path res = new Path();
+        Set<String> seenDevices = new HashSet<>(paths.length);
+        for (Path subPath : paths) {
+            if (subPath.path != null) {
+                if (!seenDevices.add(subPath.path)) {
+                    continue; // already added numbers for this device;
+                }
+            }
+            res.add(subPath);
+        }
+        return res;
+    }
+
+    public long getTimestamp() {
+        return timestamp;
+    }
+
+    public IoStats getIoStats() {
+        return ioStats;
+    }
+
+    @Override
+    public Iterator<Path> iterator() {
+        return Arrays.stream(paths).iterator();
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.FS);
+        builder.field(Fields.TIMESTAMP, timestamp);
+        builder.field(Fields.TOTAL);
+        total().toXContent(builder, params);
+
+        builder.startArray(Fields.DATA);
+        for (Path path : paths) {
+            path.toXContent(builder, params);
+        }
+        builder.endArray();
+        if (ioStats != null) {
+            builder.startObject(Fields.IO_STATS);
+            ioStats.toXContent(builder, params);
+            builder.endObject();
+        }
+        builder.endObject();
+        return builder;
+    }
+
+    static final class Fields {
+        static final String FS = "fs";
+        static final String TIMESTAMP = "timestamp";
+        static final String DATA = "data";
+        static final String TOTAL = "total";
+        static final String IO_STATS = "io_stats";
+    }
+}
diff --git a/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java b/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java
index 03add10433c54..6216248191550 100644
--- a/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java
+++ b/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java
@@ -276,14 +276,14 @@ private ProtobufJvmInfo(
     }
 
     public ProtobufJvmInfo(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
         pid = in.readInt64();
         version = in.readString();
         vmName = in.readString();
         vmVersion = in.readString();
         vmVendor = in.readString();
         bundledJdk = in.readBool();
-        usingBundledJdk = protobufStreamInput.readOptionalBoolean(in);
+        usingBundledJdk = protobufStreamInput.readOptionalBoolean();
         startTime = in.readInt64();
         inputArguments = new String[in.readInt32()];
         for (int i = 0; i < inputArguments.length; i++) {
@@ -291,10 +291,10 @@ public ProtobufJvmInfo(CodedInputStream in) throws IOException {
         }
         bootClassPath = in.readString();
         classPath = in.readString();
-        systemProperties = protobufStreamInput.readMap(CodedInputStream::readString, CodedInputStream::readString, in);
+        systemProperties = protobufStreamInput.readMap(CodedInputStream::readString, CodedInputStream::readString);
         mem = new Mem(in);
-        gcCollectors = protobufStreamInput.readStringArray(in);
-        memoryPools = protobufStreamInput.readStringArray(in);
+        gcCollectors = protobufStreamInput.readStringArray();
+        memoryPools = protobufStreamInput.readStringArray();
         useCompressedOops = in.readString();
         // the following members are only used locally for bootstrap checks, never serialized nor printed out
         this.configuredMaxHeapSize = -1;
@@ -308,14 +308,14 @@ public ProtobufJvmInfo(CodedInputStream in) throws IOException {
 
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         out.writeInt64NoTag(pid);
         out.writeStringNoTag(version);
         out.writeStringNoTag(vmName);
         out.writeStringNoTag(vmVersion);
         out.writeStringNoTag(vmVendor);
         out.writeBoolNoTag(bundledJdk);
-        protobufStreamOutput.writeOptionalBoolean(usingBundledJdk, out);
+        protobufStreamOutput.writeOptionalBoolean(usingBundledJdk);
         out.writeInt64NoTag(startTime);
         out.writeInt32NoTag(inputArguments.length);
         for (String inputArgument : inputArguments) {
@@ -329,8 +329,8 @@ public void writeTo(CodedOutputStream out) throws IOException {
             out.writeStringNoTag(entry.getValue());
         }
         mem.writeTo(out);
-        protobufStreamOutput.writeStringArray(gcCollectors, out);
-        protobufStreamOutput.writeStringArray(memoryPools, out);
+        protobufStreamOutput.writeStringArray(gcCollectors);
+        protobufStreamOutput.writeStringArray(memoryPools);
         out.writeStringNoTag(useCompressedOops);
     }
 
diff --git a/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmStats.java b/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmStats.java
new file mode 100644
index 0000000000000..7327840db296e
--- /dev/null
+++ b/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmStats.java
@@ -0,0 +1,755 @@
+/*
+* 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.
+*/
+
+package org.opensearch.monitor.jvm;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.lang.management.BufferPoolMXBean;
+import java.lang.management.ClassLoadingMXBean;
+import java.lang.management.GarbageCollectorMXBean;
+import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryMXBean;
+import java.lang.management.MemoryPoolMXBean;
+import java.lang.management.MemoryUsage;
+import java.lang.management.RuntimeMXBean;
+import java.lang.management.ThreadMXBean;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Holds JVM statistics
+*
+* @opensearch.internal
+*/
+public class ProtobufJvmStats implements ProtobufWriteable, ToXContentFragment {
+
+    private static final RuntimeMXBean runtimeMXBean;
+    private static final MemoryMXBean memoryMXBean;
+    private static final ThreadMXBean threadMXBean;
+    private static final ClassLoadingMXBean classLoadingMXBean;
+
+    static {
+        runtimeMXBean = ManagementFactory.getRuntimeMXBean();
+        memoryMXBean = ManagementFactory.getMemoryMXBean();
+        threadMXBean = ManagementFactory.getThreadMXBean();
+        classLoadingMXBean = ManagementFactory.getClassLoadingMXBean();
+    }
+
+    public static ProtobufJvmStats jvmStats() {
+        MemoryUsage memUsage = memoryMXBean.getHeapMemoryUsage();
+        long heapUsed = memUsage.getUsed() < 0 ? 0 : memUsage.getUsed();
+        long heapCommitted = memUsage.getCommitted() < 0 ? 0 : memUsage.getCommitted();
+        long heapMax = memUsage.getMax() < 0 ? 0 : memUsage.getMax();
+        memUsage = memoryMXBean.getNonHeapMemoryUsage();
+        long nonHeapUsed = memUsage.getUsed() < 0 ? 0 : memUsage.getUsed();
+        long nonHeapCommitted = memUsage.getCommitted() < 0 ? 0 : memUsage.getCommitted();
+        List<MemoryPoolMXBean> memoryPoolMXBeans = ManagementFactory.getMemoryPoolMXBeans();
+        List<MemoryPool> pools = new ArrayList<>();
+        for (MemoryPoolMXBean memoryPoolMXBean : memoryPoolMXBeans) {
+            try {
+                MemoryUsage usage = memoryPoolMXBean.getUsage();
+                MemoryUsage peakUsage = memoryPoolMXBean.getPeakUsage();
+                MemoryUsage collectionUsage = memoryPoolMXBean.getCollectionUsage();
+                // For some pools, the collection usage may not be supported and the method returns null.
+                if (collectionUsage == null) {
+                    collectionUsage = new MemoryUsage(0, 0, 0, 0);
+                }
+                String name = GcNames.getByMemoryPoolName(memoryPoolMXBean.getName(), null);
+                if (name == null) { // if we can't resolve it, its not interesting.... (Per Gen, Code Cache)
+                    continue;
+                }
+                pools.add(
+                    new MemoryPool(
+                        name,
+                        usage.getUsed() < 0 ? 0 : usage.getUsed(),
+                        usage.getMax() < 0 ? 0 : usage.getMax(),
+                        peakUsage.getUsed() < 0 ? 0 : peakUsage.getUsed(),
+                        peakUsage.getMax() < 0 ? 0 : peakUsage.getMax(),
+                        new MemoryPoolGcStats(
+                            collectionUsage.getUsed() < 0 ? 0 : collectionUsage.getUsed(),
+                            collectionUsage.getMax() < 0 ? 0 : collectionUsage.getMax()
+                        )
+                    )
+                );
+
+            } catch (final Exception ignored) {
+
+            }
+        }
+        Mem mem = new Mem(heapCommitted, heapUsed, heapMax, nonHeapCommitted, nonHeapUsed, Collections.unmodifiableList(pools));
+        Threads threads = new Threads(threadMXBean.getThreadCount(), threadMXBean.getPeakThreadCount());
+
+        List<GarbageCollectorMXBean> gcMxBeans = ManagementFactory.getGarbageCollectorMXBeans();
+        GarbageCollector[] collectors = new GarbageCollector[gcMxBeans.size()];
+        for (int i = 0; i < collectors.length; i++) {
+            GarbageCollectorMXBean gcMxBean = gcMxBeans.get(i);
+            collectors[i] = new GarbageCollector(
+                GcNames.getByGcName(gcMxBean.getName(), gcMxBean.getName()),
+                gcMxBean.getCollectionCount(),
+                gcMxBean.getCollectionTime()
+            );
+        }
+        GarbageCollectors garbageCollectors = new GarbageCollectors(collectors);
+        List<BufferPool> bufferPoolsList = Collections.emptyList();
+        try {
+            List<BufferPoolMXBean> bufferPools = ManagementFactory.getPlatformMXBeans(BufferPoolMXBean.class);
+            bufferPoolsList = new ArrayList<>(bufferPools.size());
+            for (BufferPoolMXBean bufferPool : bufferPools) {
+                bufferPoolsList.add(
+                    new BufferPool(bufferPool.getName(), bufferPool.getCount(), bufferPool.getTotalCapacity(), bufferPool.getMemoryUsed())
+                );
+            }
+        } catch (Exception e) {
+            // buffer pools are not available
+        }
+
+        Classes classes = new Classes(
+            classLoadingMXBean.getLoadedClassCount(),
+            classLoadingMXBean.getTotalLoadedClassCount(),
+            classLoadingMXBean.getUnloadedClassCount()
+        );
+
+        return new ProtobufJvmStats(
+            System.currentTimeMillis(),
+            runtimeMXBean.getUptime(),
+            mem,
+            threads,
+            garbageCollectors,
+            bufferPoolsList,
+            classes
+        );
+    }
+
+    private final long timestamp;
+    private final long uptime;
+    private final Mem mem;
+    private final Threads threads;
+    private final GarbageCollectors gc;
+    private final List<BufferPool> bufferPools;
+    private final Classes classes;
+
+    public ProtobufJvmStats(
+        long timestamp,
+        long uptime,
+        Mem mem,
+        Threads threads,
+        GarbageCollectors gc,
+        List<BufferPool> bufferPools,
+        Classes classes
+    ) {
+        this.timestamp = timestamp;
+        this.uptime = uptime;
+        this.mem = mem;
+        this.threads = threads;
+        this.gc = gc;
+        this.bufferPools = bufferPools;
+        this.classes = classes;
+    }
+
+    public ProtobufJvmStats(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        timestamp = in.readInt64();
+        uptime = in.readInt64();
+        mem = new Mem(in);
+        threads = new Threads(in);
+        gc = new GarbageCollectors(in);
+        bufferPools = protobufStreamInput.readList(BufferPool::new);
+        classes = new Classes(in);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        out.writeInt64NoTag(timestamp);
+        out.writeInt64NoTag(uptime);
+        mem.writeTo(out);
+        threads.writeTo(out);
+        gc.writeTo(out);
+        protobufStreamOutput.writeCollection(bufferPools, (o, v) -> v.writeTo(o));
+        classes.writeTo(out);
+    }
+
+    public long getTimestamp() {
+        return timestamp;
+    }
+
+    public TimeValue getUptime() {
+        return new TimeValue(uptime);
+    }
+
+    public Mem getMem() {
+        return this.mem;
+    }
+
+    public Threads getThreads() {
+        return threads;
+    }
+
+    public GarbageCollectors getGc() {
+        return gc;
+    }
+
+    public List<BufferPool> getBufferPools() {
+        return bufferPools;
+    }
+
+    public Classes getClasses() {
+        return classes;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.JVM);
+        builder.field(Fields.TIMESTAMP, timestamp);
+        builder.humanReadableField(Fields.UPTIME_IN_MILLIS, Fields.UPTIME, new TimeValue(uptime));
+
+        builder.startObject(Fields.MEM);
+
+        builder.humanReadableField(Fields.HEAP_USED_IN_BYTES, Fields.HEAP_USED, new ByteSizeValue(mem.heapUsed));
+        if (mem.getHeapUsedPercent() >= 0) {
+            builder.field(Fields.HEAP_USED_PERCENT, mem.getHeapUsedPercent());
+        }
+        builder.humanReadableField(Fields.HEAP_COMMITTED_IN_BYTES, Fields.HEAP_COMMITTED, new ByteSizeValue(mem.heapCommitted));
+        builder.humanReadableField(Fields.HEAP_MAX_IN_BYTES, Fields.HEAP_MAX, new ByteSizeValue(mem.heapMax));
+        builder.humanReadableField(Fields.NON_HEAP_USED_IN_BYTES, Fields.NON_HEAP_USED, new ByteSizeValue(mem.nonHeapUsed));
+        builder.humanReadableField(Fields.NON_HEAP_COMMITTED_IN_BYTES, Fields.NON_HEAP_COMMITTED, new ByteSizeValue(mem.nonHeapCommitted));
+
+        builder.startObject(Fields.POOLS);
+        for (MemoryPool pool : mem) {
+            builder.startObject(pool.getName());
+            builder.humanReadableField(Fields.USED_IN_BYTES, Fields.USED, new ByteSizeValue(pool.used));
+            builder.humanReadableField(Fields.MAX_IN_BYTES, Fields.MAX, new ByteSizeValue(pool.max));
+
+            builder.humanReadableField(Fields.PEAK_USED_IN_BYTES, Fields.PEAK_USED, new ByteSizeValue(pool.peakUsed));
+            builder.humanReadableField(Fields.PEAK_MAX_IN_BYTES, Fields.PEAK_MAX, new ByteSizeValue(pool.peakMax));
+
+            builder.startObject(Fields.LAST_GC_STATS);
+            builder.humanReadableField(Fields.USED_IN_BYTES, Fields.USED, new ByteSizeValue(pool.getLastGcStats().used));
+            builder.humanReadableField(Fields.MAX_IN_BYTES, Fields.MAX, new ByteSizeValue(pool.getLastGcStats().max));
+            builder.field(Fields.USAGE_PERCENT, pool.getLastGcStats().getUsagePercent());
+            builder.endObject();
+
+            builder.endObject();
+        }
+        builder.endObject();
+
+        builder.endObject();
+
+        builder.startObject(Fields.THREADS);
+        builder.field(Fields.COUNT, threads.getCount());
+        builder.field(Fields.PEAK_COUNT, threads.getPeakCount());
+        builder.endObject();
+
+        builder.startObject(Fields.GC);
+
+        builder.startObject(Fields.COLLECTORS);
+        for (GarbageCollector collector : gc) {
+            builder.startObject(collector.getName());
+            builder.field(Fields.COLLECTION_COUNT, collector.getCollectionCount());
+            builder.humanReadableField(Fields.COLLECTION_TIME_IN_MILLIS, Fields.COLLECTION_TIME, new TimeValue(collector.collectionTime));
+            builder.endObject();
+        }
+        builder.endObject();
+
+        builder.endObject();
+
+        if (bufferPools != null) {
+            builder.startObject(Fields.BUFFER_POOLS);
+            for (BufferPool bufferPool : bufferPools) {
+                builder.startObject(bufferPool.getName());
+                builder.field(Fields.COUNT, bufferPool.getCount());
+                builder.humanReadableField(Fields.USED_IN_BYTES, Fields.USED, new ByteSizeValue(bufferPool.used));
+                builder.humanReadableField(
+                    Fields.TOTAL_CAPACITY_IN_BYTES,
+                    Fields.TOTAL_CAPACITY,
+                    new ByteSizeValue(bufferPool.totalCapacity)
+                );
+                builder.endObject();
+            }
+            builder.endObject();
+        }
+
+        builder.startObject(Fields.CLASSES);
+        builder.field(Fields.CURRENT_LOADED_COUNT, classes.getLoadedClassCount());
+        builder.field(Fields.TOTAL_LOADED_COUNT, classes.getTotalLoadedClassCount());
+        builder.field(Fields.TOTAL_UNLOADED_COUNT, classes.getUnloadedClassCount());
+        builder.endObject();
+
+        builder.endObject();
+        return builder;
+    }
+
+    static final class Fields {
+        static final String JVM = "jvm";
+        static final String TIMESTAMP = "timestamp";
+        static final String UPTIME = "uptime";
+        static final String UPTIME_IN_MILLIS = "uptime_in_millis";
+
+        static final String MEM = "mem";
+        static final String HEAP_USED = "heap_used";
+        static final String HEAP_USED_IN_BYTES = "heap_used_in_bytes";
+        static final String HEAP_USED_PERCENT = "heap_used_percent";
+        static final String HEAP_MAX = "heap_max";
+        static final String HEAP_MAX_IN_BYTES = "heap_max_in_bytes";
+        static final String HEAP_COMMITTED = "heap_committed";
+        static final String HEAP_COMMITTED_IN_BYTES = "heap_committed_in_bytes";
+
+        static final String NON_HEAP_USED = "non_heap_used";
+        static final String NON_HEAP_USED_IN_BYTES = "non_heap_used_in_bytes";
+        static final String NON_HEAP_COMMITTED = "non_heap_committed";
+        static final String NON_HEAP_COMMITTED_IN_BYTES = "non_heap_committed_in_bytes";
+
+        static final String POOLS = "pools";
+        static final String USED = "used";
+        static final String USED_IN_BYTES = "used_in_bytes";
+        static final String MAX = "max";
+        static final String MAX_IN_BYTES = "max_in_bytes";
+        static final String PEAK_USED = "peak_used";
+        static final String PEAK_USED_IN_BYTES = "peak_used_in_bytes";
+        static final String PEAK_MAX = "peak_max";
+        static final String PEAK_MAX_IN_BYTES = "peak_max_in_bytes";
+        static final String USAGE_PERCENT = "usage_percent";
+        static final String LAST_GC_STATS = "last_gc_stats";
+
+        static final String THREADS = "threads";
+        static final String COUNT = "count";
+        static final String PEAK_COUNT = "peak_count";
+
+        static final String GC = "gc";
+        static final String COLLECTORS = "collectors";
+        static final String COLLECTION_COUNT = "collection_count";
+        static final String COLLECTION_TIME = "collection_time";
+        static final String COLLECTION_TIME_IN_MILLIS = "collection_time_in_millis";
+
+        static final String BUFFER_POOLS = "buffer_pools";
+        static final String TOTAL_CAPACITY = "total_capacity";
+        static final String TOTAL_CAPACITY_IN_BYTES = "total_capacity_in_bytes";
+
+        static final String CLASSES = "classes";
+        static final String CURRENT_LOADED_COUNT = "current_loaded_count";
+        static final String TOTAL_LOADED_COUNT = "total_loaded_count";
+        static final String TOTAL_UNLOADED_COUNT = "total_unloaded_count";
+    }
+
+    /**
+     * Garbage collector references.
+    *
+    * @opensearch.internal
+    */
+    public static class GarbageCollectors implements ProtobufWriteable, Iterable<GarbageCollector> {
+
+        private final GarbageCollector[] collectors;
+
+        public GarbageCollectors(GarbageCollector[] collectors) {
+            this.collectors = collectors;
+        }
+
+        public GarbageCollectors(CodedInputStream in) throws IOException {
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+            collectors = protobufStreamInput.readArray(GarbageCollector::new, GarbageCollector[]::new);
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+            protobufStreamOutput.writeArray((o, v) -> v.writeTo(o), collectors);
+        }
+
+        public GarbageCollector[] getCollectors() {
+            return this.collectors;
+        }
+
+        @Override
+        public Iterator<GarbageCollector> iterator() {
+            return Arrays.stream(collectors).iterator();
+        }
+    }
+
+    /**
+     * The garbage collector.
+    *
+    * @opensearch.internal
+    */
+    public static class GarbageCollector implements ProtobufWriteable {
+
+        private final String name;
+        private final long collectionCount;
+        private final long collectionTime;
+
+        public GarbageCollector(String name, long collectionCount, long collectionTime) {
+            this.name = name;
+            this.collectionCount = collectionCount;
+            this.collectionTime = collectionTime;
+        }
+
+        public GarbageCollector(CodedInputStream in) throws IOException {
+            name = in.readString();
+            collectionCount = in.readInt64();
+            collectionTime = in.readInt64();
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeStringNoTag(name);
+            out.writeInt64NoTag(collectionCount);
+            out.writeInt64NoTag(collectionTime);
+        }
+
+        public String getName() {
+            return this.name;
+        }
+
+        public long getCollectionCount() {
+            return this.collectionCount;
+        }
+
+        public TimeValue getCollectionTime() {
+            return new TimeValue(collectionTime, TimeUnit.MILLISECONDS);
+        }
+    }
+
+    /**
+     * Thread information.
+    *
+    * @opensearch.internal
+    */
+    public static class Threads implements ProtobufWriteable {
+
+        private final int count;
+        private final int peakCount;
+
+        public Threads(int count, int peakCount) {
+            this.count = count;
+            this.peakCount = peakCount;
+        }
+
+        public Threads(CodedInputStream in) throws IOException {
+            count = in.readInt32();
+            peakCount = in.readInt32();
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeInt32NoTag(count);
+            out.writeInt32NoTag(peakCount);
+        }
+
+        public int getCount() {
+            return count;
+        }
+
+        public int getPeakCount() {
+            return peakCount;
+        }
+    }
+
+    /**
+     * Stores the memory usage after the Java virtual machine
+    * most recently expended effort in recycling unused objects
+    * in particular memory pool.
+    *
+    * @opensearch.internal
+    */
+    public static class MemoryPoolGcStats implements ProtobufWriteable {
+
+        private final long used;
+        private final long max;
+
+        public MemoryPoolGcStats(long used, long max) {
+            this.used = used;
+            this.max = max;
+        }
+
+        public MemoryPoolGcStats(CodedInputStream in) throws IOException {
+            used = in.readInt64();
+            max = in.readInt64();
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeInt64NoTag(used);
+            out.writeInt64NoTag(max);
+        }
+
+        public ByteSizeValue getUsed() {
+            return new ByteSizeValue(used);
+        }
+
+        public ByteSizeValue getMax() {
+            return new ByteSizeValue(max);
+        }
+
+        public short getUsagePercent() {
+            if (max == 0) {
+                return -1;
+            }
+            return (short) (used * 100 / max);
+        }
+    }
+
+    /**
+     * A memory pool.
+    *
+    * @opensearch.internal
+    */
+    public static class MemoryPool implements ProtobufWriteable {
+
+        private final String name;
+        private final long used;
+        private final long max;
+        private final long peakUsed;
+        private final long peakMax;
+        private final MemoryPoolGcStats lastGcStats;
+
+        public MemoryPool(String name, long used, long max, long peakUsed, long peakMax, MemoryPoolGcStats lastGcStats) {
+            this.name = name;
+            this.used = used;
+            this.max = max;
+            this.peakUsed = peakUsed;
+            this.peakMax = peakMax;
+            this.lastGcStats = lastGcStats;
+        }
+
+        public MemoryPool(CodedInputStream in) throws IOException {
+            name = in.readString();
+            used = in.readInt64();
+            max = in.readInt64();
+            peakUsed = in.readInt64();
+            peakMax = in.readInt64();
+            lastGcStats = new MemoryPoolGcStats(in);
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeStringNoTag(name);
+            out.writeInt64NoTag(used);
+            out.writeInt64NoTag(max);
+            out.writeInt64NoTag(peakUsed);
+            out.writeInt64NoTag(peakMax);
+            lastGcStats.writeTo(out);
+        }
+
+        public String getName() {
+            return this.name;
+        }
+
+        public ByteSizeValue getUsed() {
+            return new ByteSizeValue(used);
+        }
+
+        public ByteSizeValue getMax() {
+            return new ByteSizeValue(max);
+        }
+
+        public ByteSizeValue getPeakUsed() {
+            return new ByteSizeValue(peakUsed);
+        }
+
+        public ByteSizeValue getPeakMax() {
+            return new ByteSizeValue(peakMax);
+        }
+
+        /**
+         * Returns the heap usage after last garbage collection cycle
+        */
+        public MemoryPoolGcStats getLastGcStats() {
+            return lastGcStats;
+        }
+    }
+
+    /**
+     * Memory data.
+    *
+    * @opensearch.internal
+    */
+    public static class Mem implements ProtobufWriteable, Iterable<MemoryPool> {
+
+        private final long heapCommitted;
+        private final long heapUsed;
+        private final long heapMax;
+        private final long nonHeapCommitted;
+        private final long nonHeapUsed;
+        private final List<MemoryPool> pools;
+
+        public Mem(long heapCommitted, long heapUsed, long heapMax, long nonHeapCommitted, long nonHeapUsed, List<MemoryPool> pools) {
+            this.heapCommitted = heapCommitted;
+            this.heapUsed = heapUsed;
+            this.heapMax = heapMax;
+            this.nonHeapCommitted = nonHeapCommitted;
+            this.nonHeapUsed = nonHeapUsed;
+            this.pools = pools;
+        }
+
+        public Mem(CodedInputStream in) throws IOException {
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+            heapCommitted = in.readInt64();
+            heapUsed = in.readInt64();
+            nonHeapCommitted = in.readInt64();
+            nonHeapUsed = in.readInt64();
+            heapMax = in.readInt64();
+            pools = protobufStreamInput.readList(MemoryPool::new);
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+            out.writeInt64NoTag(heapCommitted);
+            out.writeInt64NoTag(heapUsed);
+            out.writeInt64NoTag(nonHeapCommitted);
+            out.writeInt64NoTag(nonHeapUsed);
+            out.writeInt64NoTag(heapMax);
+            protobufStreamOutput.writeCollection(pools, (o, v) -> v.writeTo(o));
+        }
+
+        @Override
+        public Iterator<MemoryPool> iterator() {
+            return pools.iterator();
+        }
+
+        public ByteSizeValue getHeapCommitted() {
+            return new ByteSizeValue(heapCommitted);
+        }
+
+        public ByteSizeValue getHeapUsed() {
+            return new ByteSizeValue(heapUsed);
+        }
+
+        /**
+         * returns the maximum heap size. 0 bytes signals unknown.
+        */
+        public ByteSizeValue getHeapMax() {
+            return new ByteSizeValue(heapMax);
+        }
+
+        /**
+         * returns the heap usage in percent. -1 signals unknown.
+        */
+        public short getHeapUsedPercent() {
+            if (heapMax == 0) {
+                return -1;
+            }
+            return (short) (heapUsed * 100 / heapMax);
+        }
+
+        public ByteSizeValue getNonHeapCommitted() {
+            return new ByteSizeValue(nonHeapCommitted);
+        }
+
+        public ByteSizeValue getNonHeapUsed() {
+            return new ByteSizeValue(nonHeapUsed);
+        }
+    }
+
+    /**
+     * A buffer pool.
+    *
+    * @opensearch.internal
+    */
+    public static class BufferPool implements ProtobufWriteable {
+
+        private final String name;
+        private final long count;
+        private final long totalCapacity;
+        private final long used;
+
+        public BufferPool(String name, long count, long totalCapacity, long used) {
+            this.name = name;
+            this.count = count;
+            this.totalCapacity = totalCapacity;
+            this.used = used;
+        }
+
+        public BufferPool(CodedInputStream in) throws IOException {
+            name = in.readString();
+            count = in.readInt64();
+            totalCapacity = in.readInt64();
+            used = in.readInt64();
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeStringNoTag(name);
+            out.writeInt64NoTag(count);
+            out.writeInt64NoTag(totalCapacity);
+            out.writeInt64NoTag(used);
+        }
+
+        public String getName() {
+            return this.name;
+        }
+
+        public long getCount() {
+            return this.count;
+        }
+
+        public ByteSizeValue getTotalCapacity() {
+            return new ByteSizeValue(totalCapacity);
+        }
+
+        public ByteSizeValue getUsed() {
+            return new ByteSizeValue(used);
+        }
+    }
+
+    /**
+     * Class information.
+    *
+    * @opensearch.internal
+    */
+    public static class Classes implements ProtobufWriteable {
+
+        private final long loadedClassCount;
+        private final long totalLoadedClassCount;
+        private final long unloadedClassCount;
+
+        public Classes(long loadedClassCount, long totalLoadedClassCount, long unloadedClassCount) {
+            this.loadedClassCount = loadedClassCount;
+            this.totalLoadedClassCount = totalLoadedClassCount;
+            this.unloadedClassCount = unloadedClassCount;
+        }
+
+        public Classes(CodedInputStream in) throws IOException {
+            loadedClassCount = in.readInt64();
+            totalLoadedClassCount = in.readInt64();
+            unloadedClassCount = in.readInt64();
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeInt64NoTag(loadedClassCount);
+            out.writeInt64NoTag(totalLoadedClassCount);
+            out.writeInt64NoTag(unloadedClassCount);
+        }
+
+        public long getLoadedClassCount() {
+            return loadedClassCount;
+        }
+
+        public long getTotalLoadedClassCount() {
+            return totalLoadedClassCount;
+        }
+
+        public long getUnloadedClassCount() {
+            return unloadedClassCount;
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/monitor/os/ProtobufOsInfo.java b/server/src/main/java/org/opensearch/monitor/os/ProtobufOsInfo.java
index e2ce99b62344f..dc898d991626d 100644
--- a/server/src/main/java/org/opensearch/monitor/os/ProtobufOsInfo.java
+++ b/server/src/main/java/org/opensearch/monitor/os/ProtobufOsInfo.java
@@ -51,26 +51,26 @@ public ProtobufOsInfo(
     }
 
     public ProtobufOsInfo(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
         this.refreshInterval = in.readInt64();
         this.availableProcessors = in.readInt32();
         this.allocatedProcessors = in.readInt32();
-        this.name = protobufStreamInput.readOptionalString(in);
-        this.prettyName = protobufStreamInput.readOptionalString(in);
-        this.arch = protobufStreamInput.readOptionalString(in);
-        this.version = protobufStreamInput.readOptionalString(in);
+        this.name = protobufStreamInput.readOptionalString();
+        this.prettyName = protobufStreamInput.readOptionalString();
+        this.arch = protobufStreamInput.readOptionalString();
+        this.version = protobufStreamInput.readOptionalString();
     }
 
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         out.writeInt64NoTag(refreshInterval);
         out.writeInt32NoTag(availableProcessors);
         out.writeInt32NoTag(allocatedProcessors);
-        protobufStreamOutput.writeOptionalString(name, out);
-        protobufStreamOutput.writeOptionalString(prettyName, out);
-        protobufStreamOutput.writeOptionalString(arch, out);
-        protobufStreamOutput.writeOptionalString(version, out);
+        protobufStreamOutput.writeOptionalString(name);
+        protobufStreamOutput.writeOptionalString(prettyName);
+        protobufStreamOutput.writeOptionalString(arch);
+        protobufStreamOutput.writeOptionalString(version);
     }
 
     public long getRefreshInterval() {
diff --git a/server/src/main/java/org/opensearch/monitor/os/ProtobufOsStats.java b/server/src/main/java/org/opensearch/monitor/os/ProtobufOsStats.java
new file mode 100644
index 0000000000000..c822711ea273c
--- /dev/null
+++ b/server/src/main/java/org/opensearch/monitor/os/ProtobufOsStats.java
@@ -0,0 +1,610 @@
+/*
+* 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.
+*/
+
+package org.opensearch.monitor.os;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Objects;
+
+/**
+ * Holds stats for the Operating System
+*
+* @opensearch.internal
+*/
+public class ProtobufOsStats implements ProtobufWriteable, ToXContentFragment {
+
+    private final long timestamp;
+    private final Cpu cpu;
+    private final Mem mem;
+    private final Swap swap;
+    private final Cgroup cgroup;
+
+    public ProtobufOsStats(final long timestamp, final Cpu cpu, final Mem mem, final Swap swap, final Cgroup cgroup) {
+        this.timestamp = timestamp;
+        this.cpu = Objects.requireNonNull(cpu);
+        this.mem = Objects.requireNonNull(mem);
+        this.swap = Objects.requireNonNull(swap);
+        this.cgroup = cgroup;
+    }
+
+    public ProtobufOsStats(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        this.timestamp = in.readInt64();
+        this.cpu = new Cpu(in);
+        this.mem = new Mem(in);
+        this.swap = new Swap(in);
+        this.cgroup = protobufStreamInput.readOptionalWriteable(Cgroup::new);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        out.writeInt64NoTag(timestamp);
+        cpu.writeTo(out);
+        mem.writeTo(out);
+        swap.writeTo(out);
+        protobufStreamOutput.writeOptionalWriteable(cgroup);
+    }
+
+    public long getTimestamp() {
+        return timestamp;
+    }
+
+    public Cpu getCpu() {
+        return cpu;
+    }
+
+    public Mem getMem() {
+        return mem;
+    }
+
+    public Swap getSwap() {
+        return swap;
+    }
+
+    public Cgroup getCgroup() {
+        return cgroup;
+    }
+
+    static final class Fields {
+        static final String OS = "os";
+        static final String TIMESTAMP = "timestamp";
+        static final String CPU = "cpu";
+        static final String PERCENT = "percent";
+        static final String LOAD_AVERAGE = "load_average";
+        static final String LOAD_AVERAGE_1M = "1m";
+        static final String LOAD_AVERAGE_5M = "5m";
+        static final String LOAD_AVERAGE_15M = "15m";
+
+        static final String MEM = "mem";
+        static final String SWAP = "swap";
+        static final String FREE = "free";
+        static final String FREE_IN_BYTES = "free_in_bytes";
+        static final String USED = "used";
+        static final String USED_IN_BYTES = "used_in_bytes";
+        static final String TOTAL = "total";
+        static final String TOTAL_IN_BYTES = "total_in_bytes";
+
+        static final String FREE_PERCENT = "free_percent";
+        static final String USED_PERCENT = "used_percent";
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.OS);
+        builder.field(Fields.TIMESTAMP, getTimestamp());
+        cpu.toXContent(builder, params);
+        mem.toXContent(builder, params);
+        swap.toXContent(builder, params);
+        if (cgroup != null) {
+            cgroup.toXContent(builder, params);
+        }
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * CPU Information.
+    *
+    * @opensearch.internal
+    */
+    public static class Cpu implements ProtobufWriteable, ToXContentFragment {
+
+        private final short percent;
+        private final double[] loadAverage;
+
+        public Cpu(short systemCpuPercent, double[] systemLoadAverage) {
+            this.percent = systemCpuPercent;
+            this.loadAverage = systemLoadAverage;
+        }
+
+        public Cpu(CodedInputStream in) throws IOException {
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+            this.percent = protobufStreamInput.readShort();
+            if (in.readBool()) {
+                this.loadAverage = protobufStreamInput.readDoubleArray();
+            } else {
+                this.loadAverage = null;
+            }
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+            protobufStreamOutput.writeShort(percent);
+            if (loadAverage == null) {
+                out.writeBoolNoTag(false);
+            } else {
+                out.writeBoolNoTag(true);
+                protobufStreamOutput.writeDoubleArray(loadAverage);
+            }
+        }
+
+        public short getPercent() {
+            return percent;
+        }
+
+        public double[] getLoadAverage() {
+            return loadAverage;
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.startObject(Fields.CPU);
+            builder.field(Fields.PERCENT, getPercent());
+            if (getLoadAverage() != null && Arrays.stream(getLoadAverage()).anyMatch(load -> load != -1)) {
+                builder.startObject(Fields.LOAD_AVERAGE);
+                if (getLoadAverage()[0] != -1) {
+                    builder.field(Fields.LOAD_AVERAGE_1M, getLoadAverage()[0]);
+                }
+                if (getLoadAverage()[1] != -1) {
+                    builder.field(Fields.LOAD_AVERAGE_5M, getLoadAverage()[1]);
+                }
+                if (getLoadAverage()[2] != -1) {
+                    builder.field(Fields.LOAD_AVERAGE_15M, getLoadAverage()[2]);
+                }
+                builder.endObject();
+            }
+            builder.endObject();
+            return builder;
+        }
+    }
+
+    /**
+     * Swap information.
+    *
+    * @opensearch.internal
+    */
+    public static class Swap implements ProtobufWriteable, ToXContentFragment {
+
+        private static final Logger logger = LogManager.getLogger(Swap.class);
+
+        private final long total;
+        private final long free;
+
+        public Swap(long total, long free) {
+            assert total >= 0 : "expected total swap to be positive, got: " + total;
+            assert free >= 0 : "expected free swap to be positive, got: " + total;
+            this.total = total;
+            this.free = free;
+        }
+
+        public Swap(CodedInputStream in) throws IOException {
+            this.total = in.readInt64();
+            assert total >= 0 : "expected total swap to be positive, got: " + total;
+            this.free = in.readInt64();
+            assert free >= 0 : "expected free swap to be positive, got: " + total;
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeInt64NoTag(total);
+            out.writeInt64NoTag(free);
+        }
+
+        public ByteSizeValue getFree() {
+            return new ByteSizeValue(free);
+        }
+
+        public ByteSizeValue getUsed() {
+            if (total == 0) {
+                // The work in https://github.com/elastic/elasticsearch/pull/42725 established that total memory
+                // can be reported as negative in some cases. Swap can similarly be reported as negative and in
+                // those cases, we force it to zero in which case we can no longer correctly report the used swap
+                // as (total-free) and should report it as zero.
+                //
+                // We intentionally check for (total == 0) rather than (total - free < 0) so as not to hide
+                // cases where (free > total) which would be a different bug.
+                if (free > 0) {
+                    logger.debug("cannot compute used swap when total swap is 0 and free swap is " + free);
+                }
+                return new ByteSizeValue(0);
+            }
+            return new ByteSizeValue(total - free);
+        }
+
+        public ByteSizeValue getTotal() {
+            return new ByteSizeValue(total);
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.startObject(Fields.SWAP);
+            builder.humanReadableField(Fields.TOTAL_IN_BYTES, Fields.TOTAL, getTotal());
+            builder.humanReadableField(Fields.FREE_IN_BYTES, Fields.FREE, getFree());
+            builder.humanReadableField(Fields.USED_IN_BYTES, Fields.USED, getUsed());
+            builder.endObject();
+            return builder;
+        }
+    }
+
+    /**
+     * OS Memory information.
+    *
+    * @opensearch.internal
+    */
+    public static class Mem implements ProtobufWriteable, ToXContentFragment {
+
+        private static final Logger logger = LogManager.getLogger(Mem.class);
+
+        private final long total;
+        private final long free;
+
+        public Mem(long total, long free) {
+            assert total >= 0 : "expected total memory to be positive, got: " + total;
+            assert free >= 0 : "expected free memory to be positive, got: " + total;
+            this.total = total;
+            this.free = free;
+        }
+
+        public Mem(CodedInputStream in) throws IOException {
+            this.total = in.readInt64();
+            assert total >= 0 : "expected total memory to be positive, got: " + total;
+            this.free = in.readInt64();
+            assert free >= 0 : "expected free memory to be positive, got: " + total;
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeInt64NoTag(total);
+            out.writeInt64NoTag(free);
+        }
+
+        public ByteSizeValue getTotal() {
+            return new ByteSizeValue(total);
+        }
+
+        public ByteSizeValue getUsed() {
+            if (total == 0) {
+                // The work in https://github.com/elastic/elasticsearch/pull/42725 established that total memory
+                // can be reported as negative in some cases. In those cases, we force it to zero in which case
+                // we can no longer correctly report the used memory as (total-free) and should report it as zero.
+                //
+                // We intentionally check for (total == 0) rather than (total - free < 0) so as not to hide
+                // cases where (free > total) which would be a different bug.
+                if (free > 0) {
+                    logger.debug("cannot compute used memory when total memory is 0 and free memory is " + free);
+                }
+                return new ByteSizeValue(0);
+            }
+            return new ByteSizeValue(total - free);
+        }
+
+        public short getUsedPercent() {
+            return calculatePercentage(getUsed().getBytes(), total);
+        }
+
+        public ByteSizeValue getFree() {
+            return new ByteSizeValue(free);
+        }
+
+        public short getFreePercent() {
+            return calculatePercentage(free, total);
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.startObject(Fields.MEM);
+            builder.humanReadableField(Fields.TOTAL_IN_BYTES, Fields.TOTAL, getTotal());
+            builder.humanReadableField(Fields.FREE_IN_BYTES, Fields.FREE, getFree());
+            builder.humanReadableField(Fields.USED_IN_BYTES, Fields.USED, getUsed());
+            builder.field(Fields.FREE_PERCENT, getFreePercent());
+            builder.field(Fields.USED_PERCENT, getUsedPercent());
+            builder.endObject();
+            return builder;
+        }
+    }
+
+    /**
+     * Encapsulates basic cgroup statistics.
+    *
+    * @opensearch.internal
+    */
+    public static class Cgroup implements ProtobufWriteable, ToXContentFragment {
+
+        private final String cpuAcctControlGroup;
+        private final long cpuAcctUsageNanos;
+        private final String cpuControlGroup;
+        private final long cpuCfsPeriodMicros;
+        private final long cpuCfsQuotaMicros;
+        private final CpuStat cpuStat;
+        // These will be null for nodes running versions prior to 6.1.0
+        private final String memoryControlGroup;
+        private final String memoryLimitInBytes;
+        private final String memoryUsageInBytes;
+
+        /**
+         * The control group for the {@code cpuacct} subsystem.
+        *
+        * @return the control group
+        */
+        public String getCpuAcctControlGroup() {
+            return cpuAcctControlGroup;
+        }
+
+        /**
+         * The total CPU time consumed by all tasks in the
+        * {@code cpuacct} control group from
+        * {@link Cgroup#cpuAcctControlGroup}.
+        *
+        * @return the total CPU time in nanoseconds
+        */
+        public long getCpuAcctUsageNanos() {
+            return cpuAcctUsageNanos;
+        }
+
+        /**
+         * The control group for the {@code cpu} subsystem.
+        *
+        * @return the control group
+        */
+        public String getCpuControlGroup() {
+            return cpuControlGroup;
+        }
+
+        /**
+         * The period of time for how frequently the control group from
+        * {@link Cgroup#cpuControlGroup} has its access to CPU
+        * resources reallocated.
+        *
+        * @return the period of time in microseconds
+        */
+        public long getCpuCfsPeriodMicros() {
+            return cpuCfsPeriodMicros;
+        }
+
+        /**
+         * The total amount of time for which all tasks in the control
+        * group from {@link Cgroup#cpuControlGroup} can run in one
+        * period as represented by {@link Cgroup#cpuCfsPeriodMicros}.
+        *
+        * @return the total amount of time in microseconds
+        */
+        public long getCpuCfsQuotaMicros() {
+            return cpuCfsQuotaMicros;
+        }
+
+        /**
+         * The CPU time statistics. See {@link CpuStat}.
+        *
+        * @return the CPU time statistics.
+        */
+        public CpuStat getCpuStat() {
+            return cpuStat;
+        }
+
+        /**
+         * The control group for the {@code memory} subsystem.
+        *
+        * @return the control group
+        */
+        public String getMemoryControlGroup() {
+            return memoryControlGroup;
+        }
+
+        /**
+         * The maximum amount of user memory (including file cache).
+        * This is stored as a <code>String</code> because the value can be too big to fit in a
+        * <code>long</code>.  (The alternative would have been <code>BigInteger</code> but then
+        * it would not be possible to index the OS stats document into OpenSearch without
+        * losing information, as <code>BigInteger</code> is not a supported OpenSearch type.)
+        *
+        * @return the maximum amount of user memory (including file cache).
+        */
+        public String getMemoryLimitInBytes() {
+            return memoryLimitInBytes;
+        }
+
+        /**
+         * The total current memory usage by processes in the cgroup (in bytes).
+        * This is stored as a <code>String</code> for consistency with <code>memoryLimitInBytes</code>.
+        *
+        * @return the total current memory usage by processes in the cgroup (in bytes).
+        */
+        public String getMemoryUsageInBytes() {
+            return memoryUsageInBytes;
+        }
+
+        public Cgroup(
+            final String cpuAcctControlGroup,
+            final long cpuAcctUsageNanos,
+            final String cpuControlGroup,
+            final long cpuCfsPeriodMicros,
+            final long cpuCfsQuotaMicros,
+            final CpuStat cpuStat,
+            final String memoryControlGroup,
+            final String memoryLimitInBytes,
+            final String memoryUsageInBytes
+        ) {
+            this.cpuAcctControlGroup = Objects.requireNonNull(cpuAcctControlGroup);
+            this.cpuAcctUsageNanos = cpuAcctUsageNanos;
+            this.cpuControlGroup = Objects.requireNonNull(cpuControlGroup);
+            this.cpuCfsPeriodMicros = cpuCfsPeriodMicros;
+            this.cpuCfsQuotaMicros = cpuCfsQuotaMicros;
+            this.cpuStat = Objects.requireNonNull(cpuStat);
+            this.memoryControlGroup = memoryControlGroup;
+            this.memoryLimitInBytes = memoryLimitInBytes;
+            this.memoryUsageInBytes = memoryUsageInBytes;
+        }
+
+        Cgroup(final CodedInputStream in) throws IOException {
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+            cpuAcctControlGroup = in.readString();
+            cpuAcctUsageNanos = in.readInt64();
+            cpuControlGroup = in.readString();
+            cpuCfsPeriodMicros = in.readInt64();
+            cpuCfsQuotaMicros = in.readInt64();
+            cpuStat = new CpuStat(in);
+            memoryControlGroup = protobufStreamInput.readOptionalString();
+            memoryLimitInBytes = protobufStreamInput.readOptionalString();
+            memoryUsageInBytes = protobufStreamInput.readOptionalString();
+        }
+
+        @Override
+        public void writeTo(final CodedOutputStream out) throws IOException {
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+            out.writeStringNoTag(cpuAcctControlGroup);
+            out.writeInt64NoTag(cpuAcctUsageNanos);
+            out.writeStringNoTag(cpuControlGroup);
+            out.writeInt64NoTag(cpuCfsPeriodMicros);
+            out.writeInt64NoTag(cpuCfsQuotaMicros);
+            cpuStat.writeTo(out);
+            protobufStreamOutput.writeOptionalString(memoryControlGroup);
+            protobufStreamOutput.writeOptionalString(memoryLimitInBytes);
+            protobufStreamOutput.writeOptionalString(memoryUsageInBytes);
+        }
+
+        @Override
+        public XContentBuilder toXContent(final XContentBuilder builder, final Params params) throws IOException {
+            builder.startObject("cgroup");
+            {
+                builder.startObject("cpuacct");
+                {
+                    builder.field("control_group", cpuAcctControlGroup);
+                    builder.field("usage_nanos", cpuAcctUsageNanos);
+                }
+                builder.endObject();
+                builder.startObject("cpu");
+                {
+                    builder.field("control_group", cpuControlGroup);
+                    builder.field("cfs_period_micros", cpuCfsPeriodMicros);
+                    builder.field("cfs_quota_micros", cpuCfsQuotaMicros);
+                    cpuStat.toXContent(builder, params);
+                }
+                builder.endObject();
+                if (memoryControlGroup != null) {
+                    builder.startObject("memory");
+                    {
+                        builder.field("control_group", memoryControlGroup);
+                        if (memoryLimitInBytes != null) {
+                            builder.field("limit_in_bytes", memoryLimitInBytes);
+                        }
+                        if (memoryUsageInBytes != null) {
+                            builder.field("usage_in_bytes", memoryUsageInBytes);
+                        }
+                    }
+                    builder.endObject();
+                }
+            }
+            builder.endObject();
+            return builder;
+        }
+
+        /**
+         * Encapsulates CPU time statistics.
+        *
+        * @opensearch.internal
+        */
+        public static class CpuStat implements ProtobufWriteable, ToXContentFragment {
+
+            private final long numberOfElapsedPeriods;
+            private final long numberOfTimesThrottled;
+            private final long timeThrottledNanos;
+
+            /**
+             * The number of elapsed periods.
+            *
+            * @return the number of elapsed periods as measured by
+            * {@code cpu.cfs_period_us}
+            */
+            public long getNumberOfElapsedPeriods() {
+                return numberOfElapsedPeriods;
+            }
+
+            /**
+             * The number of times tasks in the control group have been
+            * throttled.
+            *
+            * @return the number of times
+            */
+            public long getNumberOfTimesThrottled() {
+                return numberOfTimesThrottled;
+            }
+
+            /**
+             * The total time duration for which tasks in the control
+            * group have been throttled.
+            *
+            * @return the total time in nanoseconds
+            */
+            public long getTimeThrottledNanos() {
+                return timeThrottledNanos;
+            }
+
+            public CpuStat(final long numberOfElapsedPeriods, final long numberOfTimesThrottled, final long timeThrottledNanos) {
+                this.numberOfElapsedPeriods = numberOfElapsedPeriods;
+                this.numberOfTimesThrottled = numberOfTimesThrottled;
+                this.timeThrottledNanos = timeThrottledNanos;
+            }
+
+            CpuStat(final CodedInputStream in) throws IOException {
+                numberOfElapsedPeriods = in.readInt64();
+                numberOfTimesThrottled = in.readInt64();
+                timeThrottledNanos = in.readInt64();
+            }
+
+            @Override
+            public void writeTo(final CodedOutputStream out) throws IOException {
+                out.writeInt64NoTag(numberOfElapsedPeriods);
+                out.writeInt64NoTag(numberOfTimesThrottled);
+                out.writeInt64NoTag(timeThrottledNanos);
+            }
+
+            @Override
+            public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+                builder.startObject("stat");
+                {
+                    builder.field("number_of_elapsed_periods", numberOfElapsedPeriods);
+                    builder.field("number_of_times_throttled", numberOfTimesThrottled);
+                    builder.field("time_throttled_nanos", timeThrottledNanos);
+                }
+                builder.endObject();
+                return builder;
+            }
+
+        }
+
+    }
+
+    public static short calculatePercentage(long used, long max) {
+        return max <= 0 ? 0 : (short) (Math.round((100d * used) / max));
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessStats.java b/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessStats.java
new file mode 100644
index 0000000000000..ff24e4eb66357
--- /dev/null
+++ b/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessStats.java
@@ -0,0 +1,193 @@
+/*
+* 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.
+*/
+
+package org.opensearch.monitor.process;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+/**
+ * Holds stats for the process
+*
+* @opensearch.internal
+*/
+public class ProtobufProcessStats implements ProtobufWriteable, ToXContentFragment {
+
+    private final long timestamp;
+    private final long openFileDescriptors;
+    private final long maxFileDescriptors;
+    private final Cpu cpu;
+    private final Mem mem;
+
+    public ProtobufProcessStats(long timestamp, long openFileDescriptors, long maxFileDescriptors, Cpu cpu, Mem mem) {
+        this.timestamp = timestamp;
+        this.openFileDescriptors = openFileDescriptors;
+        this.maxFileDescriptors = maxFileDescriptors;
+        this.cpu = cpu;
+        this.mem = mem;
+    }
+
+    public ProtobufProcessStats(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        timestamp = in.readInt64();
+        openFileDescriptors = in.readInt64();
+        maxFileDescriptors = in.readInt64();
+        cpu = protobufStreamInput.readOptionalWriteable(Cpu::new);
+        mem = protobufStreamInput.readOptionalWriteable(Mem::new);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        out.writeInt64NoTag(timestamp);
+        out.writeInt64NoTag(openFileDescriptors);
+        out.writeInt64NoTag(maxFileDescriptors);
+        protobufStreamOutput.writeOptionalWriteable(cpu);
+        protobufStreamOutput.writeOptionalWriteable(mem);
+    }
+
+    public long getTimestamp() {
+        return timestamp;
+    }
+
+    public long getOpenFileDescriptors() {
+        return openFileDescriptors;
+    }
+
+    public long getMaxFileDescriptors() {
+        return maxFileDescriptors;
+    }
+
+    public Cpu getCpu() {
+        return cpu;
+    }
+
+    public Mem getMem() {
+        return mem;
+    }
+
+    static final class Fields {
+        static final String PROCESS = "process";
+        static final String TIMESTAMP = "timestamp";
+        static final String OPEN_FILE_DESCRIPTORS = "open_file_descriptors";
+        static final String MAX_FILE_DESCRIPTORS = "max_file_descriptors";
+
+        static final String CPU = "cpu";
+        static final String PERCENT = "percent";
+        static final String TOTAL = "total";
+        static final String TOTAL_IN_MILLIS = "total_in_millis";
+
+        static final String MEM = "mem";
+        static final String TOTAL_VIRTUAL = "total_virtual";
+        static final String TOTAL_VIRTUAL_IN_BYTES = "total_virtual_in_bytes";
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.PROCESS);
+        builder.field(Fields.TIMESTAMP, timestamp);
+        builder.field(Fields.OPEN_FILE_DESCRIPTORS, openFileDescriptors);
+        builder.field(Fields.MAX_FILE_DESCRIPTORS, maxFileDescriptors);
+        if (cpu != null) {
+            builder.startObject(Fields.CPU);
+            builder.field(Fields.PERCENT, cpu.percent);
+            builder.humanReadableField(Fields.TOTAL_IN_MILLIS, Fields.TOTAL, new TimeValue(cpu.total));
+            builder.endObject();
+        }
+        if (mem != null) {
+            builder.startObject(Fields.MEM);
+            builder.humanReadableField(Fields.TOTAL_VIRTUAL_IN_BYTES, Fields.TOTAL_VIRTUAL, new ByteSizeValue(mem.totalVirtual));
+            builder.endObject();
+        }
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * Process memory information.
+    *
+    * @opensearch.internal
+    */
+    public static class Mem implements ProtobufWriteable {
+
+        private final long totalVirtual;
+
+        public Mem(long totalVirtual) {
+            this.totalVirtual = totalVirtual;
+        }
+
+        public Mem(CodedInputStream in) throws IOException {
+            totalVirtual = in.readInt64();
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeInt64NoTag(totalVirtual);
+        }
+
+        public ByteSizeValue getTotalVirtual() {
+            return new ByteSizeValue(totalVirtual);
+        }
+    }
+
+    /**
+     * Process CPU information.
+    *
+    * @opensearch.internal
+    */
+    public static class Cpu implements ProtobufWriteable {
+
+        private final short percent;
+        private final long total;
+
+        public Cpu(short percent, long total) {
+            this.percent = percent;
+            this.total = total;
+        }
+
+        public Cpu(CodedInputStream in) throws IOException {
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+            percent = protobufStreamInput.readShort();
+            total = in.readInt64();
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+            protobufStreamOutput.writeShort(percent);
+            out.writeInt64NoTag(total);
+        }
+
+        /**
+         * Get the Process cpu usage.
+        * <p>
+        * Supported Platforms: All.
+        */
+        public short getPercent() {
+            return percent;
+        }
+
+        /**
+         * Get the Process cpu time (sum of User and Sys).
+        * <p>
+        * Supported Platforms: All.
+        */
+        public TimeValue getTotal() {
+            return new TimeValue(total);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/node/ProtobufAdaptiveSelectionStats.java b/server/src/main/java/org/opensearch/node/ProtobufAdaptiveSelectionStats.java
new file mode 100644
index 0000000000000..da47e0226b69a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/node/ProtobufAdaptiveSelectionStats.java
@@ -0,0 +1,121 @@
+/*
+* 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.
+*/
+
+package org.opensearch.node;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.set.Sets;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+/**
+ * Class representing statistics about adaptive replica selection. This includes
+* EWMA of queue size, service time, and response time, as well as outgoing
+* searches to each node and the "rank" based on the ARS formula.
+*
+* @opensearch.internal
+*/
+public class ProtobufAdaptiveSelectionStats implements ProtobufWriteable, ToXContentFragment {
+
+    private final Map<String, Long> clientOutgoingConnections;
+    private final Map<String, ResponseCollectorService.ProtobufComputedNodeStats> nodeComputedStats;
+
+    public ProtobufAdaptiveSelectionStats(
+        Map<String, Long> clientConnections,
+        Map<String, ResponseCollectorService.ProtobufComputedNodeStats> nodeComputedStats
+    ) {
+        this.clientOutgoingConnections = clientConnections;
+        this.nodeComputedStats = nodeComputedStats;
+    }
+
+    public ProtobufAdaptiveSelectionStats(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        this.clientOutgoingConnections = protobufStreamInput.readMap(CodedInputStream::readString, CodedInputStream::readInt64);
+        this.nodeComputedStats = protobufStreamInput.readMap(
+            CodedInputStream::readString,
+            ResponseCollectorService.ProtobufComputedNodeStats::new
+        );
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeMap(
+            this.clientOutgoingConnections,
+            CodedOutputStream::writeStringNoTag,
+            CodedOutputStream::writeInt64NoTag
+        );
+        protobufStreamOutput.writeMap(
+            this.nodeComputedStats,
+            CodedOutputStream::writeStringNoTag,
+            (stream, stats) -> stats.writeTo(stream)
+        );
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject("adaptive_selection");
+        Set<String> allNodeIds = Sets.union(clientOutgoingConnections.keySet(), nodeComputedStats.keySet());
+        for (String nodeId : allNodeIds) {
+            builder.startObject(nodeId);
+            ResponseCollectorService.ProtobufComputedNodeStats stats = nodeComputedStats.get(nodeId);
+            if (stats != null) {
+                long outgoingSearches = clientOutgoingConnections.getOrDefault(nodeId, 0L);
+                builder.field("outgoing_searches", outgoingSearches);
+                builder.field("avg_queue_size", stats.queueSize);
+                if (builder.humanReadable()) {
+                    builder.field("avg_service_time", new TimeValue((long) stats.serviceTime, TimeUnit.NANOSECONDS).toString());
+                }
+                builder.field("avg_service_time_ns", (long) stats.serviceTime);
+                if (builder.humanReadable()) {
+                    builder.field("avg_response_time", new TimeValue((long) stats.responseTime, TimeUnit.NANOSECONDS).toString());
+                }
+                builder.field("avg_response_time_ns", (long) stats.responseTime);
+                builder.field("rank", String.format(Locale.ROOT, "%.1f", stats.rank(outgoingSearches)));
+            }
+            builder.endObject();
+        }
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * Returns a map of node id to the outgoing search requests to that node
+    */
+    public Map<String, Long> getOutgoingConnections() {
+        return clientOutgoingConnections;
+    }
+
+    /**
+     * Returns a map of node id to the computed stats
+    */
+    public Map<String, ResponseCollectorService.ProtobufComputedNodeStats> getComputedStats() {
+        return nodeComputedStats;
+    }
+
+    /**
+     * Returns a map of node id to the ranking of the nodes based on the adaptive replica formula
+    */
+    public Map<String, Double> getRanks() {
+        return nodeComputedStats.entrySet()
+            .stream()
+            .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().rank(clientOutgoingConnections.getOrDefault(e.getKey(), 0L))));
+    }
+}
diff --git a/server/src/main/java/org/opensearch/node/ProtobufNodeClosedException.java b/server/src/main/java/org/opensearch/node/ProtobufNodeClosedException.java
new file mode 100644
index 0000000000000..cf5ab03c8bb91
--- /dev/null
+++ b/server/src/main/java/org/opensearch/node/ProtobufNodeClosedException.java
@@ -0,0 +1,31 @@
+/*
+* 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.
+*/
+
+package org.opensearch.node;
+
+import com.google.protobuf.CodedInputStream;
+import org.opensearch.ProtobufOpenSearchException;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+
+import java.io.IOException;
+
+/**
+ * An exception indicating that node is closed.
+*
+* @opensearch.internal
+*/
+public class ProtobufNodeClosedException extends ProtobufOpenSearchException {
+
+    public ProtobufNodeClosedException(ProtobufDiscoveryNode node) {
+        super("node closed " + node);
+    }
+
+    public ProtobufNodeClosedException(CodedInputStream in) throws IOException {
+        super(in);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/node/ResponseCollectorService.java b/server/src/main/java/org/opensearch/node/ResponseCollectorService.java
index 3b73ec8f9622d..88b29764e4f07 100644
--- a/server/src/main/java/org/opensearch/node/ResponseCollectorService.java
+++ b/server/src/main/java/org/opensearch/node/ResponseCollectorService.java
@@ -6,37 +6,16 @@
  * 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.node;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
 import org.opensearch.cluster.ClusterChangedEvent;
 import org.opensearch.cluster.ClusterStateListener;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.ExponentiallyWeightedMovingAverage;
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
@@ -219,6 +198,109 @@ public String toString() {
         }
     }
 
+    /**
+     * Struct-like class encapsulating a point-in-time snapshot of a particular
+     * node's statistics. This includes the EWMA of queue size, response time,
+     * and service time.
+     */
+    public static class ProtobufComputedNodeStats implements ProtobufWriteable {
+        // We store timestamps with nanosecond precision, however, the
+        // formula specifies milliseconds, therefore we need to convert
+        // the values so the times don't unduely weight the formula
+        private final double FACTOR = 1000000.0;
+        private final int clientNum;
+
+        private double cachedRank = 0;
+
+        public final String nodeId;
+        public final int queueSize;
+        public final double responseTime;
+        public final double serviceTime;
+
+        public ProtobufComputedNodeStats(String nodeId, int clientNum, int queueSize, double responseTime, double serviceTime) {
+            this.nodeId = nodeId;
+            this.clientNum = clientNum;
+            this.queueSize = queueSize;
+            this.responseTime = responseTime;
+            this.serviceTime = serviceTime;
+        }
+
+        ProtobufComputedNodeStats(int clientNum, NodeStatistics nodeStats) {
+            this(
+                nodeStats.nodeId,
+                clientNum,
+                (int) nodeStats.queueSize.getAverage(),
+                nodeStats.responseTime.getAverage(),
+                nodeStats.serviceTime
+            );
+        }
+
+        ProtobufComputedNodeStats(CodedInputStream in) throws IOException {
+            this.nodeId = in.readString();
+            this.clientNum = in.readInt32();
+            this.queueSize = in.readInt32();
+            this.responseTime = in.readDouble();
+            this.serviceTime = in.readDouble();
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeStringNoTag(this.nodeId);
+            out.writeInt32NoTag(this.clientNum);
+            out.writeInt32NoTag(this.queueSize);
+            out.writeDoubleNoTag(this.responseTime);
+            out.writeDoubleNoTag(this.serviceTime);
+        }
+
+        /**
+         * Rank this copy of the data, according to the adaptive replica selection formula from the C3 paper
+         * https://www.usenix.org/system/files/conference/nsdi15/nsdi15-paper-suresh.pdf
+         */
+        private double innerRank(long outstandingRequests) {
+            // the concurrency compensation is defined as the number of
+            // outstanding requests from the client to the node times the number
+            // of clients in the system
+            double concurrencyCompensation = outstandingRequests * clientNum;
+
+            // Cubic queue adjustment factor. The paper chose 3 though we could
+            // potentially make this configurable if desired.
+            int queueAdjustmentFactor = 3;
+
+            // EWMA of queue size
+            double qBar = queueSize;
+            double qHatS = 1 + concurrencyCompensation + qBar;
+
+            // EWMA of response time
+            double rS = responseTime / FACTOR;
+            // EWMA of service time
+            double muBarS = serviceTime / FACTOR;
+
+            // The final formula
+            double rank = rS - (1.0 / muBarS) + (Math.pow(qHatS, queueAdjustmentFactor) / muBarS);
+            return rank;
+        }
+
+        public double rank(long outstandingRequests) {
+            if (cachedRank == 0) {
+                cachedRank = innerRank(outstandingRequests);
+            }
+            return cachedRank;
+        }
+
+        @Override
+        public String toString() {
+            StringBuilder sb = new StringBuilder("ComputedNodeStats[");
+            sb.append(nodeId).append("](");
+            sb.append("nodes: ").append(clientNum);
+            sb.append(", queue: ").append(queueSize);
+            sb.append(", response time: ").append(String.format(Locale.ROOT, "%.1f", responseTime));
+            sb.append(", service time: ").append(String.format(Locale.ROOT, "%.1f", serviceTime));
+            sb.append(", rank: ").append(String.format(Locale.ROOT, "%.1f", rank(1)));
+            sb.append(")");
+            return sb.toString();
+        }
+    }
+
     /**
      * Class encapsulating a node's exponentially weighted queue size, response
      * time, and service time, however, this class is private and intended only
diff --git a/server/src/main/java/org/opensearch/plugins/ProtobufPluginInfo.java b/server/src/main/java/org/opensearch/plugins/ProtobufPluginInfo.java
index fcc06a0d11ba3..29620fb5ee5dd 100644
--- a/server/src/main/java/org/opensearch/plugins/ProtobufPluginInfo.java
+++ b/server/src/main/java/org/opensearch/plugins/ProtobufPluginInfo.java
@@ -127,7 +127,7 @@ public ProtobufPluginInfo(
     * @throws IOException if an I/O exception occurred reading the plugin info from the stream
     */
     public ProtobufPluginInfo(final CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
         this.name = in.readString();
         this.description = in.readString();
         this.version = in.readString();
@@ -135,13 +135,13 @@ public ProtobufPluginInfo(final CodedInputStream in) throws IOException {
         this.javaVersion = in.readString();
         this.classname = in.readString();
         this.customFolderName = in.readString();
-        this.extendedPlugins = protobufStreamInput.readList(CodedInputStream::readString, in);
+        this.extendedPlugins = protobufStreamInput.readList(CodedInputStream::readString);
         this.hasNativeController = in.readBool();
     }
 
     @Override
     public void writeTo(final CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         out.writeStringNoTag(name);
         out.writeStringNoTag(description);
         out.writeStringNoTag(version);
@@ -153,7 +153,7 @@ public void writeTo(final CodedOutputStream out) throws IOException {
         } else {
             out.writeStringNoTag(name);
         }
-        protobufStreamOutput.writeCollection(extendedPlugins, CodedOutputStream::writeStringNoTag, out);
+        protobufStreamOutput.writeCollection(extendedPlugins, CodedOutputStream::writeStringNoTag);
         out.writeBoolNoTag(hasNativeController);
     }
 
diff --git a/server/src/main/java/org/opensearch/rest/ClientAgnosticRestHandler.java b/server/src/main/java/org/opensearch/rest/ClientAgnosticRestHandler.java
new file mode 100644
index 0000000000000..f37b1f3cee272
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/ClientAgnosticRestHandler.java
@@ -0,0 +1,27 @@
+/*
+* 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.
+*/
+
+package org.opensearch.rest;
+
+/**
+ * Handler for REST requests
+*
+* @opensearch.api
+*/
+@FunctionalInterface
+public interface ClientAgnosticRestHandler<T> {
+
+    /**
+     * Handles a rest request.
+    * @param request The request to handle
+    * @param channel The channel to write the request response to
+    * @param client A client to use to make internal requests on behalf of the original request
+    */
+    void handleRequest(RestRequest request, RestChannel channel, T client) throws Exception;
+
+}
diff --git a/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java b/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java
new file mode 100644
index 0000000000000..42dd853e87aba
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java
@@ -0,0 +1,309 @@
+/*
+* 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.
+*/
+
+package org.opensearch.rest;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.search.spell.LevenshteinDistance;
+import org.apache.lucene.util.CollectionUtil;
+import org.opensearch.OpenSearchParseException;
+import org.opensearch.action.support.clustermanager.ProtobufClusterManagerNodeRequest;
+import org.opensearch.client.node.ProtobufNodeClient;
+import org.opensearch.common.CheckedConsumer;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.logging.DeprecationLogger;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Setting.Property;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.plugins.ActionPlugin;
+import org.opensearch.rest.action.admin.cluster.RestNodesUsageAction;
+import org.opensearch.tasks.ProtobufTask;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.concurrent.atomic.LongAdder;
+import java.util.stream.Collectors;
+
+/**
+ * Base handler for REST requests.
+* <p>
+* This handler makes sure that the headers &amp; context of the handled {@link RestRequest requests} are copied over to
+* the transport requests executed by the associated client. While the context is fully copied over, not all the headers
+* are copied, but a selected few. It is possible to control what headers are copied over by returning them in
+* {@link ActionPlugin#getRestHeaders()}.
+*
+* @opensearch.api
+*/
+public abstract class ProtobufBaseRestHandler implements ProtobufRestHandler {
+
+    public static final Setting<Boolean> MULTI_ALLOW_EXPLICIT_INDEX = Setting.boolSetting(
+        "rest.action.multi.allow_explicit_index",
+        true,
+        Property.NodeScope
+    );
+
+    private final LongAdder usageCount = new LongAdder();
+    /**
+     * @deprecated declare your own logger.
+    */
+    @Deprecated
+    protected Logger logger = LogManager.getLogger(getClass());
+
+    public final long getUsageCount() {
+        return usageCount.sum();
+    }
+
+    /**
+     * @return the name of this handler. The name should be human readable and
+    *         should describe the action that will performed when this API is
+    *         called. This name is used in the response to the
+    *         {@link RestNodesUsageAction}.
+    */
+    public abstract String getName();
+
+    @Override
+    public final void handleRequest(RestRequest request, RestChannel channel, ProtobufNodeClient client) throws Exception {
+        // prepare the request for execution; has the side effect of touching the request parameters
+        final RestChannelConsumer action = prepareRequest(request, client);
+
+        // validate unconsumed params, but we must exclude params used to format the response
+        // use a sorted set so the unconsumed parameters appear in a reliable sorted order
+        final SortedSet<String> unconsumedParams = request.unconsumedParams()
+            .stream()
+            .filter(p -> !responseParams().contains(p))
+            .collect(Collectors.toCollection(TreeSet::new));
+
+        // validate the non-response params
+        if (!unconsumedParams.isEmpty()) {
+            final Set<String> candidateParams = new HashSet<>();
+            candidateParams.addAll(request.consumedParams());
+            candidateParams.addAll(responseParams());
+            throw new IllegalArgumentException(unrecognized(request, unconsumedParams, candidateParams, "parameter"));
+        }
+
+        if (request.hasContent() && request.isContentConsumed() == false) {
+            throw new IllegalArgumentException("request [" + request.method() + " " + request.path() + "] does not support having a body");
+        }
+
+        usageCount.increment();
+        // execute the action
+        action.accept(channel);
+    }
+
+    public static String unrecognizedStrings(
+        final RestRequest request,
+        final Set<String> invalids,
+        final Set<String> candidates,
+        final String detail
+    ) {
+        StringBuilder message = new StringBuilder(
+            String.format(Locale.ROOT, "request [%s] contains unrecognized %s%s: ", request.path(), detail, invalids.size() > 1 ? "s" : "")
+        );
+        boolean first = true;
+        for (final String invalid : invalids) {
+            final LevenshteinDistance ld = new LevenshteinDistance();
+            final List<Tuple<Float, String>> scoredParams = new ArrayList<>();
+            for (final String candidate : candidates) {
+                final float distance = ld.getDistance(invalid, candidate);
+                if (distance > 0.5f) {
+                    scoredParams.add(new Tuple<>(distance, candidate));
+                }
+            }
+            CollectionUtil.timSort(scoredParams, (a, b) -> {
+                // sort by distance in reverse order, then parameter name for equal distances
+                int compare = a.v1().compareTo(b.v1());
+                if (compare != 0) return -compare;
+                else return a.v2().compareTo(b.v2());
+            });
+            if (first == false) {
+                message.append(", ");
+            }
+            message.append("[").append(invalid).append("]");
+            final List<String> keys = scoredParams.stream().map(Tuple::v2).collect(Collectors.toList());
+            if (keys.isEmpty() == false) {
+                message.append(" -> did you mean ");
+                if (keys.size() == 1) {
+                    message.append("[").append(keys.get(0)).append("]");
+                } else {
+                    message.append("any of ").append(keys.toString());
+                }
+                message.append("?");
+            }
+            first = false;
+        }
+
+        return message.toString();
+    }
+
+    /**
+     * Returns a String message of the detail of any unrecognized error occurred. The string is intended for use in error messages to be returned to the user.
+    *
+    * @param request The request that caused the exception
+    * @param invalids Strings from the request which were unable to be understood.
+    * @param candidates A set of words that are most likely to be the valid strings determined invalid, to be suggested to the user.
+    * @param detail The parameter contains the details of the exception.
+    * @return a String that contains the message.
+    */
+    protected final String unrecognized(
+        final RestRequest request,
+        final Set<String> invalids,
+        final Set<String> candidates,
+        final String detail
+    ) {
+        return unrecognizedStrings(request, invalids, candidates, detail);
+    }
+
+    /**
+     * REST requests are handled by preparing a channel consumer that represents the execution of
+    * the request against a channel.
+    */
+    @FunctionalInterface
+    protected interface RestChannelConsumer extends CheckedConsumer<RestChannel, Exception> {}
+
+    /**
+     * Prepare the request for execution. Implementations should consume all request params before
+    * returning the runnable for actual execution. Unconsumed params will immediately terminate
+    * execution of the request. However, some params are only used in processing the response;
+    * implementations can override {@link ProtobufBaseRestHandler#responseParams()} to indicate such
+    * params.
+    *
+    * @param request the request to execute
+    * @param client  client for executing actions on the local node
+    * @return the action to execute
+    * @throws IOException if an I/O exception occurred parsing the request and preparing for
+    *                     execution
+    */
+    protected abstract RestChannelConsumer prepareRequest(RestRequest request, ProtobufNodeClient client) throws IOException;
+
+    /**
+     * Parameters used for controlling the response and thus might not be consumed during
+    * preparation of the request execution in
+    * {@link ProtobufBaseRestHandler#prepareRequest(RestRequest, ProtobufNodeClient)}.
+    *
+    * @return a set of parameters used to control the response and thus should not trip strict
+    * URL parameter checks.
+    */
+    protected Set<String> responseParams() {
+        return Collections.emptySet();
+    }
+
+    /**
+     * Parse the deprecated request parameter 'master_timeout', and add deprecated log if the parameter is used.
+    * It also validates whether the two parameters 'master_timeout' and 'cluster_manager_timeout' are not assigned together.
+    * The method is temporarily added in 2.0 duing applying inclusive language. Remove the method along with MASTER_ROLE.
+    * @param mnr the action request
+    * @param request the REST request to handle
+    * @param logger the logger that logs deprecation notices
+    * @param logMsgKeyPrefix the key prefix of a deprecation message to avoid duplicate messages.
+    */
+    public static void parseDeprecatedMasterTimeoutParameter(
+        ProtobufClusterManagerNodeRequest mnr,
+        RestRequest request,
+        DeprecationLogger logger,
+        String logMsgKeyPrefix
+    ) {
+        final String MASTER_TIMEOUT_DEPRECATED_MESSAGE =
+            "Parameter [master_timeout] is deprecated and will be removed in 3.0. To support inclusive language, please use [cluster_manager_timeout] instead.";
+        final String DUPLICATE_PARAMETER_ERROR_MESSAGE =
+            "Please only use one of the request parameters [master_timeout, cluster_manager_timeout].";
+        if (request.hasParam("master_timeout")) {
+            logger.deprecate(logMsgKeyPrefix + "_master_timeout_parameter", MASTER_TIMEOUT_DEPRECATED_MESSAGE);
+            if (request.hasParam("cluster_manager_timeout")) {
+                throw new OpenSearchParseException(DUPLICATE_PARAMETER_ERROR_MESSAGE);
+            }
+            mnr.clusterManagerNodeTimeout(request.paramAsTime("master_timeout", mnr.clusterManagerNodeTimeout()));
+        }
+    }
+
+    /**
+     * A wrapper for the base handler.
+    *
+    * @opensearch.internal
+    */
+    public static class Wrapper extends ProtobufBaseRestHandler {
+
+        protected final ProtobufBaseRestHandler delegate;
+
+        public Wrapper(ProtobufBaseRestHandler delegate) {
+            this.delegate = Objects.requireNonNull(delegate, "ProtobufBaseRestHandler delegate can not be null");
+        }
+
+        @Override
+        public String getName() {
+            return delegate.getName();
+        }
+
+        @Override
+        public List<Route> routes() {
+            return delegate.routes();
+        }
+
+        @Override
+        public List<DeprecatedRoute> deprecatedRoutes() {
+            return delegate.deprecatedRoutes();
+        }
+
+        @Override
+        public List<ReplacedRoute> replacedRoutes() {
+            return delegate.replacedRoutes();
+        }
+
+        @Override
+        protected RestChannelConsumer prepareRequest(RestRequest request, ProtobufNodeClient client) throws IOException {
+            return delegate.prepareRequest(request, client);
+        }
+
+        @Override
+        protected Set<String> responseParams() {
+            return delegate.responseParams();
+        }
+
+        @Override
+        public boolean canTripCircuitBreaker() {
+            return delegate.canTripCircuitBreaker();
+        }
+
+        @Override
+        public boolean supportsContentStream() {
+            return delegate.supportsContentStream();
+        }
+
+        @Override
+        public boolean allowsUnsafeBuffers() {
+            return delegate.allowsUnsafeBuffers();
+        }
+
+        @Override
+        public boolean allowSystemIndexAccessByDefault() {
+            return delegate.allowSystemIndexAccessByDefault();
+        }
+    }
+
+    /**
+     * Return a task immediately when executing some long-running operations asynchronously, like reindex, resize, open, force merge
+    */
+    public RestChannelConsumer sendTask(String nodeId, ProtobufTask task) {
+        return channel -> {
+            try (XContentBuilder builder = channel.newBuilder()) {
+                builder.startObject();
+                builder.field("task", nodeId + ":" + task.getId());
+                builder.endObject();
+                channel.sendResponse(new BytesRestResponse(RestStatus.OK, builder));
+            }
+        };
+    }
+}
diff --git a/server/src/main/java/org/opensearch/rest/ProtobufRestHandler.java b/server/src/main/java/org/opensearch/rest/ProtobufRestHandler.java
new file mode 100644
index 0000000000000..7224847832d5b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/ProtobufRestHandler.java
@@ -0,0 +1,259 @@
+/*
+* 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.
+*/
+
+package org.opensearch.rest;
+
+import org.opensearch.client.node.ProtobufNodeClient;
+import org.opensearch.core.xcontent.XContent;
+import org.opensearch.rest.RestRequest.Method;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * Handler for REST requests
+*
+* @opensearch.api
+*/
+@FunctionalInterface
+public interface ProtobufRestHandler extends ClientAgnosticRestHandler<ProtobufNodeClient> {
+
+    /**
+     * Handles a rest request.
+    * @param request The request to handle
+    * @param channel The channel to write the request response to
+    * @param client A client to use to make internal requests on behalf of the original request
+    */
+    void handleRequest(RestRequest request, RestChannel channel, ProtobufNodeClient client) throws Exception;
+
+    default boolean canTripCircuitBreaker() {
+        return true;
+    }
+
+    /**
+     * Indicates if the ProtobufRestHandler supports content as a stream. A stream would be multiple objects delineated by
+    * {@link XContent#streamSeparator()}. If a handler returns true this will affect the types of content that can be sent to
+    * this endpoint.
+    */
+    default boolean supportsContentStream() {
+        return false;
+    }
+
+    /**
+     * Indicates if the ProtobufRestHandler supports working with pooled buffers. If the request handler will not escape the return
+    * {@link RestRequest#content()} or any buffers extracted from it then there is no need to make a copies of any pooled buffers in the
+    * {@link RestRequest} instance before passing a request to this handler. If this instance does not support pooled/unsafe buffers
+    * {@link RestRequest#ensureSafeBuffers()} should be called on any request before passing it to {@link #handleRequest}.
+    *
+    * @return true iff the handler supports requests that make use of pooled buffers
+    */
+    default boolean allowsUnsafeBuffers() {
+        return false;
+    }
+
+    /**
+     * The list of {@link Route}s that this ProtobufRestHandler is responsible for handling.
+    */
+    default List<Route> routes() {
+        return Collections.emptyList();
+    }
+
+    /**
+     * A list of routes handled by this ProtobufRestHandler that are deprecated and do not have a direct
+    * replacement. If changing the {@code path} or {@code method} of a route,
+    * use {@link #replacedRoutes()}.
+    */
+    default List<DeprecatedRoute> deprecatedRoutes() {
+        return Collections.emptyList();
+    }
+
+    /**
+     * A list of routes handled by this ProtobufRestHandler that have had their {@code path} and/or
+    * {@code method} changed. The pre-existing {@code route} will be registered
+    * as deprecated alongside the updated {@code route}.
+    */
+    default List<ReplacedRoute> replacedRoutes() {
+        return Collections.emptyList();
+    }
+
+    /**
+     * Controls whether requests handled by this class are allowed to to access system indices by default.
+    * @return {@code true} if requests handled by this class should be allowed to access system indices.
+    */
+    default boolean allowSystemIndexAccessByDefault() {
+        return false;
+    }
+
+    static ProtobufRestHandler wrapper(ProtobufRestHandler delegate) {
+        return new Wrapper(delegate);
+    }
+
+    /**
+     * Wrapper for a handler.
+    *
+    * @opensearch.internal
+    */
+    class Wrapper implements ProtobufRestHandler {
+        private final ProtobufRestHandler delegate;
+
+        public Wrapper(ProtobufRestHandler delegate) {
+            this.delegate = Objects.requireNonNull(delegate, "ProtobufRestHandler delegate can not be null");
+        }
+
+        @Override
+        public String toString() {
+            return delegate.toString();
+        }
+
+        @Override
+        public void handleRequest(RestRequest request, RestChannel channel, ProtobufNodeClient client) throws Exception {
+            delegate.handleRequest(request, channel, client);
+        }
+
+        @Override
+        public boolean canTripCircuitBreaker() {
+            return delegate.canTripCircuitBreaker();
+        }
+
+        @Override
+        public boolean supportsContentStream() {
+            return delegate.supportsContentStream();
+        }
+
+        @Override
+        public boolean allowsUnsafeBuffers() {
+            return delegate.allowsUnsafeBuffers();
+        }
+
+        @Override
+        public List<Route> routes() {
+            return delegate.routes();
+        }
+
+        @Override
+        public List<DeprecatedRoute> deprecatedRoutes() {
+            return delegate.deprecatedRoutes();
+        }
+
+        @Override
+        public List<ReplacedRoute> replacedRoutes() {
+            return delegate.replacedRoutes();
+        }
+
+        @Override
+        public boolean allowSystemIndexAccessByDefault() {
+            return delegate.allowSystemIndexAccessByDefault();
+        }
+    }
+
+    /**
+     * Route for the request.
+    *
+    * @opensearch.internal
+    */
+    class Route {
+
+        private final String path;
+        private final Method method;
+
+        public Route(Method method, String path) {
+            this.path = path;
+            this.method = method;
+        }
+
+        public String getPath() {
+            return path;
+        }
+
+        public Method getMethod() {
+            return method;
+        }
+    }
+
+    /**
+     * Represents an API that has been deprecated and is slated for removal.
+    */
+    class DeprecatedRoute extends Route {
+
+        private final String deprecationMessage;
+
+        public DeprecatedRoute(Method method, String path, String deprecationMessage) {
+            super(method, path);
+            this.deprecationMessage = deprecationMessage;
+        }
+
+        public String getDeprecationMessage() {
+            return deprecationMessage;
+        }
+    }
+
+    /**
+     * Represents an API that has had its {@code path} or {@code method} changed. Holds both the
+    * new and previous {@code path} and {@code method} combination.
+    */
+    class ReplacedRoute extends Route {
+
+        private final String deprecatedPath;
+        private final Method deprecatedMethod;
+
+        /**
+         * Construct replaced routes using new and deprocated methods and new and deprecated paths
+        * @param method route method
+        * @param path new route path
+        * @param deprecatedMethod deprecated method
+        * @param deprecatedPath deprecated path
+        */
+        public ReplacedRoute(Method method, String path, Method deprecatedMethod, String deprecatedPath) {
+            super(method, path);
+            this.deprecatedMethod = deprecatedMethod;
+            this.deprecatedPath = deprecatedPath;
+        }
+
+        /**
+         * Construct replaced routes using route method, new and deprecated paths
+        * This constructor can be used when both new and deprecated paths use the same method
+        * @param method route method
+        * @param path new route path
+        * @param deprecatedPath deprecated path
+        */
+        public ReplacedRoute(Method method, String path, String deprecatedPath) {
+            this(method, path, method, deprecatedPath);
+        }
+
+        /**
+         * Construct replaced routes using route, new and deprecated prefixes
+        * @param route route
+        * @param prefix new route prefix
+        * @param deprecatedPrefix deprecated prefix
+        */
+        public ReplacedRoute(Route route, String prefix, String deprecatedPrefix) {
+            this(route.getMethod(), prefix + route.getPath(), deprecatedPrefix + route.getPath());
+        }
+
+        public String getDeprecatedPath() {
+            return deprecatedPath;
+        }
+
+        public Method getDeprecatedMethod() {
+            return deprecatedMethod;
+        }
+    }
+
+    /**
+     * Construct replaced routes using routes template and prefixes for new and deprecated paths
+    * @param routes routes
+    * @param prefix new prefix
+    * @param deprecatedPrefix deprecated prefix
+    * @return new list of API routes prefixed with the prefix string
+    */
+    static List<ReplacedRoute> replaceRoutes(List<Route> routes, final String prefix, final String deprecatedPrefix) {
+        return routes.stream().map(route -> new ReplacedRoute(route, prefix, deprecatedPrefix)).collect(Collectors.toList());
+    }
+}
diff --git a/server/src/main/java/org/opensearch/rest/RestHandler.java b/server/src/main/java/org/opensearch/rest/RestHandler.java
index 7832649e8ad32..5b1583f260da0 100644
--- a/server/src/main/java/org/opensearch/rest/RestHandler.java
+++ b/server/src/main/java/org/opensearch/rest/RestHandler.java
@@ -47,7 +47,7 @@
  * @opensearch.api
  */
 @FunctionalInterface
-public interface RestHandler {
+public interface RestHandler extends ClientAgnosticRestHandler<NodeClient> {
 
     /**
      * Handles a rest request.
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufAbstractCatAction.java b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufAbstractCatAction.java
new file mode 100644
index 0000000000000..55653f5e738c9
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufAbstractCatAction.java
@@ -0,0 +1,78 @@
+/*
+* 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.
+*/
+
+package org.opensearch.rest.action.cat;
+
+import org.opensearch.client.node.ProtobufNodeClient;
+import org.opensearch.common.Table;
+import org.opensearch.common.io.Streams;
+import org.opensearch.common.io.UTF8StreamWriter;
+import org.opensearch.common.io.stream.BytesStream;
+import org.opensearch.rest.ProtobufBaseRestHandler;
+import org.opensearch.rest.BytesRestResponse;
+import org.opensearch.rest.RestRequest;
+import org.opensearch.rest.RestStatus;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import static org.opensearch.rest.action.cat.RestTable.buildHelpWidths;
+import static org.opensearch.rest.action.cat.RestTable.pad;
+
+/**
+ * Base Transport action class for _cat API
+*
+* @opensearch.api
+*/
+public abstract class ProtobufAbstractCatAction extends ProtobufBaseRestHandler {
+
+    protected abstract RestChannelConsumer doCatRequest(RestRequest request, ProtobufNodeClient client);
+
+    protected abstract void documentation(StringBuilder sb);
+
+    protected abstract Table getTableWithHeader(RestRequest request);
+
+    @Override
+    public RestChannelConsumer prepareRequest(final RestRequest request, final ProtobufNodeClient client) throws IOException {
+        boolean helpWanted = request.paramAsBoolean("help", false);
+        if (helpWanted) {
+            return channel -> {
+                Table table = getTableWithHeader(request);
+                int[] width = buildHelpWidths(table, request);
+                BytesStream bytesOutput = Streams.flushOnCloseStream(channel.bytesOutput());
+                UTF8StreamWriter out = new UTF8StreamWriter().setOutput(bytesOutput);
+                for (Table.Cell cell : table.getHeaders()) {
+                    // need to do left-align always, so create new cells
+                    pad(new Table.Cell(cell.value), width[0], request, out);
+                    out.append(" | ");
+                    pad(new Table.Cell(cell.attr.containsKey("alias") ? cell.attr.get("alias") : ""), width[1], request, out);
+                    out.append(" | ");
+                    pad(new Table.Cell(cell.attr.containsKey("desc") ? cell.attr.get("desc") : "not available"), width[2], request, out);
+                    out.append("\n");
+                }
+                out.close();
+                channel.sendResponse(new BytesRestResponse(RestStatus.OK, BytesRestResponse.TEXT_CONTENT_TYPE, bytesOutput.bytes()));
+            };
+        } else {
+            return doCatRequest(request, client);
+        }
+    }
+
+    static Set<String> RESPONSE_PARAMS = Collections.unmodifiableSet(
+        new HashSet<>(Arrays.asList("format", "h", "v", "ts", "pri", "bytes", "size", "time", "s", "timeout"))
+    );
+
+    @Override
+    protected Set<String> responseParams() {
+        return RESPONSE_PARAMS;
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
new file mode 100644
index 0000000000000..ae0924641a16a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
@@ -0,0 +1,545 @@
+/*
+* 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.
+*/
+
+package org.opensearch.rest.action.cat;
+
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodeInfo;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequest;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoResponse;
+import org.opensearch.action.admin.cluster.node.stats.ProtobufNodeStats;
+import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsRequest;
+import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsResponse;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
+import org.opensearch.client.node.ProtobufNodeClient;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
+import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
+import org.opensearch.common.Strings;
+import org.opensearch.common.Table;
+import org.opensearch.common.logging.DeprecationLogger;
+import org.opensearch.common.network.NetworkAddress;
+import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.http.ProtobufHttpInfo;
+import org.opensearch.index.cache.query.ProtobufQueryCacheStats;
+import org.opensearch.index.cache.request.ProtobufRequestCacheStats;
+import org.opensearch.index.engine.ProtobufSegmentsStats;
+import org.opensearch.index.fielddata.ProtobufFieldDataStats;
+import org.opensearch.index.flush.ProtobufFlushStats;
+import org.opensearch.index.get.ProtobufGetStats;
+import org.opensearch.index.merge.ProtobufMergeStats;
+import org.opensearch.index.refresh.ProtobufRefreshStats;
+import org.opensearch.index.search.stats.ProtobufSearchStats;
+import org.opensearch.index.shard.ProtobufIndexingStats;
+import org.opensearch.indices.ProtobufNodeIndicesStats;
+import org.opensearch.monitor.fs.ProtobufFsInfo;
+import org.opensearch.monitor.jvm.ProtobufJvmInfo;
+import org.opensearch.monitor.jvm.ProtobufJvmStats;
+import org.opensearch.monitor.os.ProtobufOsStats;
+import org.opensearch.monitor.process.ProtobufProcessInfo;
+import org.opensearch.monitor.process.ProtobufProcessStats;
+import org.opensearch.rest.RestRequest;
+import org.opensearch.rest.RestResponse;
+import org.opensearch.rest.action.RestActionListener;
+import org.opensearch.rest.action.RestResponseListener;
+import org.opensearch.script.ProtobufScriptStats;
+import org.opensearch.search.suggest.completion.ProtobufCompletionStats;
+
+import java.util.List;
+import java.util.Locale;
+import java.util.stream.Collectors;
+
+import static java.util.Collections.singletonList;
+import static org.opensearch.rest.RestRequest.Method.GET;
+
+/**
+ * _cat API action to get node information
+*
+* @opensearch.api
+*/
+public class ProtobufRestNodesAction extends ProtobufAbstractCatAction {
+    private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(ProtobufRestNodesAction.class);
+    static final String LOCAL_DEPRECATED_MESSAGE = "Deprecated parameter [local] used. This parameter does not cause this API to act "
+        + "locally, and should not be used. It will be unsupported in version 8.0.";
+
+    @Override
+    public List<Route> routes() {
+        return singletonList(new Route(GET, "/_cat/nodes"));
+    }
+
+    @Override
+    public String getName() {
+        return "cat_nodes_action";
+    }
+
+    @Override
+    protected void documentation(StringBuilder sb) {
+        sb.append("/_cat/nodes\n");
+    }
+
+    @Override
+    public RestChannelConsumer doCatRequest(final RestRequest request, final ProtobufNodeClient client) {
+        final ProtobufClusterStateRequest clusterStateRequest = new ProtobufClusterStateRequest();
+        clusterStateRequest.clear().nodes(true);
+        if (request.hasParam("local")) {
+            deprecationLogger.deprecate("cat_nodes_local_parameter", LOCAL_DEPRECATED_MESSAGE);
+        }
+        clusterStateRequest.local(request.paramAsBoolean("local", clusterStateRequest.local()));
+        clusterStateRequest.clusterManagerNodeTimeout(
+            request.paramAsTime("cluster_manager_timeout", clusterStateRequest.clusterManagerNodeTimeout())
+        );
+        parseDeprecatedMasterTimeoutParameter(clusterStateRequest, request, deprecationLogger, getName());
+        final boolean fullId = request.paramAsBoolean("full_id", false);
+        return channel -> client.admin()
+            .cluster()
+            .state(clusterStateRequest, new RestActionListener<ProtobufClusterStateResponse>(channel) {
+                @Override
+                public void processResponse(final ProtobufClusterStateResponse clusterStateResponse) {
+                    ProtobufNodesInfoRequest nodesInfoRequest = new ProtobufNodesInfoRequest();
+                    nodesInfoRequest.timeout(request.param("timeout"));
+                    nodesInfoRequest.clear()
+                        .addMetrics(
+                            ProtobufNodesInfoRequest.Metric.JVM.metricName(),
+                            ProtobufNodesInfoRequest.Metric.OS.metricName(),
+                            ProtobufNodesInfoRequest.Metric.PROCESS.metricName(),
+                            ProtobufNodesInfoRequest.Metric.HTTP.metricName()
+                        );
+                    client.admin().cluster().nodesInfo(nodesInfoRequest, new RestActionListener<ProtobufNodesInfoResponse>(channel) {
+                        @Override
+                        public void processResponse(final ProtobufNodesInfoResponse nodesInfoResponse) {
+                            ProtobufNodesStatsRequest nodesStatsRequest = new ProtobufNodesStatsRequest();
+                            nodesStatsRequest.timeout(request.param("timeout"));
+                            nodesStatsRequest.clear()
+                                .indices(true)
+                                .addMetrics(
+                                    ProtobufNodesStatsRequest.Metric.JVM.metricName(),
+                                    ProtobufNodesStatsRequest.Metric.OS.metricName(),
+                                    ProtobufNodesStatsRequest.Metric.FS.metricName(),
+                                    ProtobufNodesStatsRequest.Metric.PROCESS.metricName(),
+                                    ProtobufNodesStatsRequest.Metric.SCRIPT.metricName()
+                                );
+                            client.admin()
+                                .cluster()
+                                .nodesStats(nodesStatsRequest, new RestResponseListener<ProtobufNodesStatsResponse>(channel) {
+                                    @Override
+                                    public RestResponse buildResponse(ProtobufNodesStatsResponse nodesStatsResponse) throws Exception {
+                                        return RestTable.buildResponse(
+                                            buildTable(fullId, request, clusterStateResponse, nodesInfoResponse, nodesStatsResponse),
+                                            channel
+                                        );
+                                    }
+                                });
+                        }
+                    });
+                }
+            });
+    }
+
+    @Override
+    protected Table getTableWithHeader(final RestRequest request) {
+        Table table = new Table();
+        table.startHeaders();
+        table.addCell("id", "default:false;alias:id,nodeId;desc:unique node id");
+        table.addCell("pid", "default:false;alias:p;desc:process id");
+        table.addCell("ip", "alias:i;desc:ip address");
+        table.addCell("port", "default:false;alias:po;desc:bound transport port");
+        table.addCell("http_address", "default:false;alias:http;desc:bound http address");
+
+        table.addCell("version", "default:false;alias:v;desc:es version");
+        table.addCell("type", "default:false;alias:t;desc:es distribution type");
+        table.addCell("build", "default:false;alias:b;desc:es build hash");
+        table.addCell("jdk", "default:false;alias:j;desc:jdk version");
+        table.addCell("disk.total", "default:false;alias:dt,diskTotal;text-align:right;desc:total disk space");
+        table.addCell("disk.used", "default:false;alias:du,diskUsed;text-align:right;desc:used disk space");
+        table.addCell("disk.avail", "default:false;alias:d,da,disk,diskAvail;text-align:right;desc:available disk space");
+        table.addCell("disk.used_percent", "default:false;alias:dup,diskUsedPercent;text-align:right;desc:used disk space percentage");
+        table.addCell("heap.current", "default:false;alias:hc,heapCurrent;text-align:right;desc:used heap");
+        table.addCell("heap.percent", "alias:hp,heapPercent;text-align:right;desc:used heap ratio");
+        table.addCell("heap.max", "default:false;alias:hm,heapMax;text-align:right;desc:max configured heap");
+        table.addCell("ram.current", "default:false;alias:rc,ramCurrent;text-align:right;desc:used machine memory");
+        table.addCell("ram.percent", "alias:rp,ramPercent;text-align:right;desc:used machine memory ratio");
+        table.addCell("ram.max", "default:false;alias:rm,ramMax;text-align:right;desc:total machine memory");
+        table.addCell("file_desc.current", "default:false;alias:fdc,fileDescriptorCurrent;text-align:right;desc:used file descriptors");
+        table.addCell(
+            "file_desc.percent",
+            "default:false;alias:fdp,fileDescriptorPercent;text-align:right;desc:used file descriptor ratio"
+        );
+        table.addCell("file_desc.max", "default:false;alias:fdm,fileDescriptorMax;text-align:right;desc:max file descriptors");
+
+        table.addCell("cpu", "alias:cpu;text-align:right;desc:recent cpu usage");
+        table.addCell("load_1m", "alias:l;text-align:right;desc:1m load avg");
+        table.addCell("load_5m", "alias:l;text-align:right;desc:5m load avg");
+        table.addCell("load_15m", "alias:l;text-align:right;desc:15m load avg");
+        table.addCell("uptime", "default:false;alias:u;text-align:right;desc:node uptime");
+        // TODO: Deprecate "node.role", use "node.roles" which shows full node role names
+        table.addCell(
+            "node.role",
+            "alias:r,role,nodeRole;desc:m:master eligible node, d:data node, i:ingest node, -:coordinating node only"
+        );
+        table.addCell("node.roles", "alias:rs,all roles;desc: -:coordinating node only");
+        // TODO: Remove the header alias 'master', after removing MASTER_ROLE. It's added for compatibility when using parameter 'h=master'.
+        table.addCell("cluster_manager", "alias:cm,m,master;desc:*:current cluster manager");
+        table.addCell("name", "alias:n;desc:node name");
+
+        table.addCell("completion.size", "alias:cs,completionSize;default:false;text-align:right;desc:size of completion");
+
+        table.addCell("fielddata.memory_size", "alias:fm,fielddataMemory;default:false;text-align:right;desc:used fielddata cache");
+        table.addCell("fielddata.evictions", "alias:fe,fielddataEvictions;default:false;text-align:right;desc:fielddata evictions");
+
+        table.addCell("query_cache.memory_size", "alias:qcm,queryCacheMemory;default:false;text-align:right;desc:used query cache");
+        table.addCell("query_cache.evictions", "alias:qce,queryCacheEvictions;default:false;text-align:right;desc:query cache evictions");
+        table.addCell("query_cache.hit_count", "alias:qchc,queryCacheHitCount;default:false;text-align:right;desc:query cache hit counts");
+        table.addCell(
+            "query_cache.miss_count",
+            "alias:qcmc,queryCacheMissCount;default:false;text-align:right;desc:query cache miss counts"
+        );
+
+        table.addCell("request_cache.memory_size", "alias:rcm,requestCacheMemory;default:false;text-align:right;desc:used request cache");
+        table.addCell(
+            "request_cache.evictions",
+            "alias:rce,requestCacheEvictions;default:false;text-align:right;desc:request cache evictions"
+        );
+        table.addCell(
+            "request_cache.hit_count",
+            "alias:rchc,requestCacheHitCount;default:false;text-align:right;desc:request cache hit counts"
+        );
+        table.addCell(
+            "request_cache.miss_count",
+            "alias:rcmc,requestCacheMissCount;default:false;text-align:right;desc:request cache miss counts"
+        );
+
+        table.addCell("flush.total", "alias:ft,flushTotal;default:false;text-align:right;desc:number of flushes");
+        table.addCell("flush.total_time", "alias:ftt,flushTotalTime;default:false;text-align:right;desc:time spent in flush");
+
+        table.addCell("get.current", "alias:gc,getCurrent;default:false;text-align:right;desc:number of current get ops");
+        table.addCell("get.time", "alias:gti,getTime;default:false;text-align:right;desc:time spent in get");
+        table.addCell("get.total", "alias:gto,getTotal;default:false;text-align:right;desc:number of get ops");
+        table.addCell("get.exists_time", "alias:geti,getExistsTime;default:false;text-align:right;desc:time spent in successful gets");
+        table.addCell("get.exists_total", "alias:geto,getExistsTotal;default:false;text-align:right;desc:number of successful gets");
+        table.addCell("get.missing_time", "alias:gmti,getMissingTime;default:false;text-align:right;desc:time spent in failed gets");
+        table.addCell("get.missing_total", "alias:gmto,getMissingTotal;default:false;text-align:right;desc:number of failed gets");
+
+        table.addCell(
+            "indexing.delete_current",
+            "alias:idc,indexingDeleteCurrent;default:false;text-align:right;desc:number of current deletions"
+        );
+        table.addCell("indexing.delete_time", "alias:idti,indexingDeleteTime;default:false;text-align:right;desc:time spent in deletions");
+        table.addCell("indexing.delete_total", "alias:idto,indexingDeleteTotal;default:false;text-align:right;desc:number of delete ops");
+        table.addCell(
+            "indexing.index_current",
+            "alias:iic,indexingIndexCurrent;default:false;text-align:right;desc:number of current indexing ops"
+        );
+        table.addCell("indexing.index_time", "alias:iiti,indexingIndexTime;default:false;text-align:right;desc:time spent in indexing");
+        table.addCell("indexing.index_total", "alias:iito,indexingIndexTotal;default:false;text-align:right;desc:number of indexing ops");
+        table.addCell(
+            "indexing.index_failed",
+            "alias:iif,indexingIndexFailed;default:false;text-align:right;desc:number of failed indexing ops"
+        );
+
+        table.addCell("merges.current", "alias:mc,mergesCurrent;default:false;text-align:right;desc:number of current merges");
+        table.addCell(
+            "merges.current_docs",
+            "alias:mcd,mergesCurrentDocs;default:false;text-align:right;desc:number of current merging docs"
+        );
+        table.addCell("merges.current_size", "alias:mcs,mergesCurrentSize;default:false;text-align:right;desc:size of current merges");
+        table.addCell("merges.total", "alias:mt,mergesTotal;default:false;text-align:right;desc:number of completed merge ops");
+        table.addCell("merges.total_docs", "alias:mtd,mergesTotalDocs;default:false;text-align:right;desc:docs merged");
+        table.addCell("merges.total_size", "alias:mts,mergesTotalSize;default:false;text-align:right;desc:size merged");
+        table.addCell("merges.total_time", "alias:mtt,mergesTotalTime;default:false;text-align:right;desc:time spent in merges");
+
+        table.addCell("refresh.total", "alias:rto,refreshTotal;default:false;text-align:right;desc:total refreshes");
+        table.addCell("refresh.time", "alias:rti,refreshTime;default:false;text-align:right;desc:time spent in refreshes");
+        table.addCell("refresh.external_total", "alias:rto,refreshTotal;default:false;text-align:right;desc:total external refreshes");
+        table.addCell(
+            "refresh.external_time",
+            "alias:rti,refreshTime;default:false;text-align:right;desc:time spent in external refreshes"
+        );
+        table.addCell(
+            "refresh.listeners",
+            "alias:rli,refreshListeners;default:false;text-align:right;" + "desc:number of pending refresh listeners"
+        );
+
+        table.addCell("script.compilations", "alias:scrcc,scriptCompilations;default:false;text-align:right;desc:script compilations");
+        table.addCell(
+            "script.cache_evictions",
+            "alias:scrce,scriptCacheEvictions;default:false;text-align:right;desc:script cache evictions"
+        );
+        table.addCell(
+            "script.compilation_limit_triggered",
+            "alias:scrclt,scriptCacheCompilationLimitTriggered;default:false;"
+                + "text-align:right;desc:script cache compilation limit triggered"
+        );
+
+        table.addCell("search.fetch_current", "alias:sfc,searchFetchCurrent;default:false;text-align:right;desc:current fetch phase ops");
+        table.addCell("search.fetch_time", "alias:sfti,searchFetchTime;default:false;text-align:right;desc:time spent in fetch phase");
+        table.addCell("search.fetch_total", "alias:sfto,searchFetchTotal;default:false;text-align:right;desc:total fetch ops");
+        table.addCell("search.open_contexts", "alias:so,searchOpenContexts;default:false;text-align:right;desc:open search contexts");
+        table.addCell("search.query_current", "alias:sqc,searchQueryCurrent;default:false;text-align:right;desc:current query phase ops");
+        table.addCell("search.query_time", "alias:sqti,searchQueryTime;default:false;text-align:right;desc:time spent in query phase");
+        table.addCell("search.query_total", "alias:sqto,searchQueryTotal;default:false;text-align:right;desc:total query phase ops");
+        table.addCell("search.scroll_current", "alias:scc,searchScrollCurrent;default:false;text-align:right;desc:open scroll contexts");
+        table.addCell(
+            "search.scroll_time",
+            "alias:scti,searchScrollTime;default:false;text-align:right;desc:time scroll contexts held open"
+        );
+        table.addCell("search.scroll_total", "alias:scto,searchScrollTotal;default:false;text-align:right;desc:completed scroll contexts");
+
+        table.addCell(
+            "search.point_in_time_current",
+            "alias:scc,searchPointInTimeCurrent;default:false;text-align:right;desc:open point in time contexts"
+        );
+        table.addCell(
+            "search.point_in_time_time",
+            "alias:scti,searchPointInTimeTime;default:false;text-align:right;desc:time point in time contexts held open"
+        );
+        table.addCell(
+            "search.point_in_time_total",
+            "alias:scto,searchPointInTimeTotal;default:false;text-align:right;desc:completed point in time contexts"
+        );
+
+        table.addCell("segments.count", "alias:sc,segmentsCount;default:false;text-align:right;desc:number of segments");
+        table.addCell("segments.memory", "alias:sm,segmentsMemory;default:false;text-align:right;desc:memory used by segments");
+        table.addCell(
+            "segments.index_writer_memory",
+            "alias:siwm,segmentsIndexWriterMemory;default:false;text-align:right;desc:memory used by index writer"
+        );
+        table.addCell(
+            "segments.version_map_memory",
+            "alias:svmm,segmentsVersionMapMemory;default:false;text-align:right;desc:memory used by version map"
+        );
+        table.addCell(
+            "segments.fixed_bitset_memory",
+            "alias:sfbm,fixedBitsetMemory;default:false;text-align:right;desc:memory used by fixed bit sets for nested object field types"
+                + " and type filters for types referred in _parent fields"
+        );
+
+        table.addCell("suggest.current", "alias:suc,suggestCurrent;default:false;text-align:right;desc:number of current suggest ops");
+        table.addCell("suggest.time", "alias:suti,suggestTime;default:false;text-align:right;desc:time spend in suggest");
+        table.addCell("suggest.total", "alias:suto,suggestTotal;default:false;text-align:right;desc:number of suggest ops");
+
+        table.endHeaders();
+        return table;
+    }
+
+    Table buildTable(
+        boolean fullId,
+        RestRequest req,
+        ProtobufClusterStateResponse state,
+        ProtobufNodesInfoResponse nodesInfo,
+        ProtobufNodesStatsResponse nodesStats
+    ) {
+
+        ProtobufDiscoveryNodes nodes = state.getState().nodes();
+        String clusterManagerId = nodes.getClusterManagerNodeId();
+        Table table = getTableWithHeader(req);
+
+        for (ProtobufDiscoveryNode node : nodes) {
+            ProtobufNodeInfo info = nodesInfo.getNodesMap().get(node.getId());
+            ProtobufNodeStats stats = nodesStats.getNodesMap().get(node.getId());
+
+            ProtobufJvmInfo jvmInfo = info == null ? null : info.getInfo(ProtobufJvmInfo.class);
+            ProtobufJvmStats jvmStats = stats == null ? null : stats.getJvm();
+            ProtobufFsInfo fsInfo = stats == null ? null : stats.getFs();
+            ProtobufOsStats osStats = stats == null ? null : stats.getOs();
+            ProtobufProcessStats processStats = stats == null ? null : stats.getProcess();
+            ProtobufNodeIndicesStats indicesStats = stats == null ? null : stats.getIndices();
+
+            table.startRow();
+
+            table.addCell(fullId ? node.getId() : Strings.substring(node.getId(), 0, 4));
+            table.addCell(info == null ? null : info.getInfo(ProtobufProcessInfo.class).getId());
+            table.addCell(node.getHostAddress());
+            table.addCell(node.getAddress().address().getPort());
+            final ProtobufHttpInfo httpInfo = info == null ? null : info.getInfo(ProtobufHttpInfo.class);
+            if (httpInfo != null) {
+                ProtobufTransportAddress transportAddress = httpInfo.getAddress().publishAddress();
+                table.addCell(NetworkAddress.format(transportAddress.address()));
+            } else {
+                table.addCell("-");
+            }
+
+            table.addCell(node.getVersion().toString());
+            table.addCell(info == null ? null : info.getBuild().type().displayName());
+            table.addCell(info == null ? null : info.getBuild().hash());
+            table.addCell(jvmInfo == null ? null : jvmInfo.version());
+
+            ByteSizeValue diskTotal = null;
+            ByteSizeValue diskUsed = null;
+            ByteSizeValue diskAvailable = null;
+            String diskUsedPercent = null;
+            if (fsInfo != null) {
+                diskTotal = fsInfo.getTotal().getTotal();
+                diskAvailable = fsInfo.getTotal().getAvailable();
+                diskUsed = new ByteSizeValue(diskTotal.getBytes() - diskAvailable.getBytes());
+
+                double diskUsedRatio = diskTotal.getBytes() == 0 ? 1.0 : (double) diskUsed.getBytes() / diskTotal.getBytes();
+                diskUsedPercent = String.format(Locale.ROOT, "%.2f", 100.0 * diskUsedRatio);
+            }
+            table.addCell(diskTotal);
+            table.addCell(diskUsed);
+            table.addCell(diskAvailable);
+            table.addCell(diskUsedPercent);
+
+            table.addCell(jvmStats == null ? null : jvmStats.getMem().getHeapUsed());
+            table.addCell(jvmStats == null ? null : jvmStats.getMem().getHeapUsedPercent());
+            table.addCell(jvmInfo == null ? null : jvmInfo.getMem().getHeapMax());
+            table.addCell(osStats == null ? null : osStats.getMem() == null ? null : osStats.getMem().getUsed());
+            table.addCell(osStats == null ? null : osStats.getMem() == null ? null : osStats.getMem().getUsedPercent());
+            table.addCell(osStats == null ? null : osStats.getMem() == null ? null : osStats.getMem().getTotal());
+            table.addCell(processStats == null ? null : processStats.getOpenFileDescriptors());
+            table.addCell(
+                processStats == null
+                    ? null
+                    : calculatePercentage(processStats.getOpenFileDescriptors(), processStats.getMaxFileDescriptors())
+            );
+            table.addCell(processStats == null ? null : processStats.getMaxFileDescriptors());
+
+            table.addCell(osStats == null ? null : Short.toString(osStats.getCpu().getPercent()));
+            boolean hasLoadAverage = osStats != null && osStats.getCpu().getLoadAverage() != null;
+            table.addCell(
+                !hasLoadAverage || osStats.getCpu().getLoadAverage()[0] == -1
+                    ? null
+                    : String.format(Locale.ROOT, "%.2f", osStats.getCpu().getLoadAverage()[0])
+            );
+            table.addCell(
+                !hasLoadAverage || osStats.getCpu().getLoadAverage()[1] == -1
+                    ? null
+                    : String.format(Locale.ROOT, "%.2f", osStats.getCpu().getLoadAverage()[1])
+            );
+            table.addCell(
+                !hasLoadAverage || osStats.getCpu().getLoadAverage()[2] == -1
+                    ? null
+                    : String.format(Locale.ROOT, "%.2f", osStats.getCpu().getLoadAverage()[2])
+            );
+            table.addCell(jvmStats == null ? null : jvmStats.getUptime());
+
+            final String roles;
+            final String allRoles;
+            if (node.getRoles().isEmpty()) {
+                roles = "-";
+                allRoles = "-";
+            } else {
+                List<DiscoveryNodeRole> knownNodeRoles = node.getRoles()
+                    .stream()
+                    .filter(DiscoveryNodeRole::isKnownRole)
+                    .collect(Collectors.toList());
+                roles = knownNodeRoles.size() > 0
+                    ? knownNodeRoles.stream().map(DiscoveryNodeRole::roleNameAbbreviation).sorted().collect(Collectors.joining())
+                    : "-";
+                allRoles = node.getRoles().stream().map(DiscoveryNodeRole::roleName).sorted().collect(Collectors.joining(","));
+            }
+            table.addCell(roles);
+            table.addCell(allRoles);
+            table.addCell(clusterManagerId == null ? "x" : clusterManagerId.equals(node.getId()) ? "*" : "-");
+            table.addCell(node.getName());
+
+            ProtobufCompletionStats completionStats = indicesStats == null ? null : stats.getIndices().getCompletion();
+            table.addCell(completionStats == null ? null : completionStats.getSize());
+
+            ProtobufFieldDataStats fdStats = indicesStats == null ? null : stats.getIndices().getFieldData();
+            table.addCell(fdStats == null ? null : fdStats.getMemorySize());
+            table.addCell(fdStats == null ? null : fdStats.getEvictions());
+
+            ProtobufQueryCacheStats fcStats = indicesStats == null ? null : indicesStats.getQueryCache();
+            table.addCell(fcStats == null ? null : fcStats.getMemorySize());
+            table.addCell(fcStats == null ? null : fcStats.getEvictions());
+            table.addCell(fcStats == null ? null : fcStats.getHitCount());
+            table.addCell(fcStats == null ? null : fcStats.getMissCount());
+
+            ProtobufRequestCacheStats qcStats = indicesStats == null ? null : indicesStats.getRequestCache();
+            table.addCell(qcStats == null ? null : qcStats.getMemorySize());
+            table.addCell(qcStats == null ? null : qcStats.getEvictions());
+            table.addCell(qcStats == null ? null : qcStats.getHitCount());
+            table.addCell(qcStats == null ? null : qcStats.getMissCount());
+
+            ProtobufFlushStats flushStats = indicesStats == null ? null : indicesStats.getFlush();
+            table.addCell(flushStats == null ? null : flushStats.getTotal());
+            table.addCell(flushStats == null ? null : flushStats.getTotalTime());
+
+            ProtobufGetStats getStats = indicesStats == null ? null : indicesStats.getGet();
+            table.addCell(getStats == null ? null : getStats.current());
+            table.addCell(getStats == null ? null : getStats.getTime());
+            table.addCell(getStats == null ? null : getStats.getCount());
+            table.addCell(getStats == null ? null : getStats.getExistsTime());
+            table.addCell(getStats == null ? null : getStats.getExistsCount());
+            table.addCell(getStats == null ? null : getStats.getMissingTime());
+            table.addCell(getStats == null ? null : getStats.getMissingCount());
+
+            ProtobufIndexingStats indexingStats = indicesStats == null ? null : indicesStats.getIndexing();
+            table.addCell(indexingStats == null ? null : indexingStats.getTotal().getDeleteCurrent());
+            table.addCell(indexingStats == null ? null : indexingStats.getTotal().getDeleteTime());
+            table.addCell(indexingStats == null ? null : indexingStats.getTotal().getDeleteCount());
+            table.addCell(indexingStats == null ? null : indexingStats.getTotal().getIndexCurrent());
+            table.addCell(indexingStats == null ? null : indexingStats.getTotal().getIndexTime());
+            table.addCell(indexingStats == null ? null : indexingStats.getTotal().getIndexCount());
+            table.addCell(indexingStats == null ? null : indexingStats.getTotal().getIndexFailedCount());
+
+            ProtobufMergeStats mergeStats = indicesStats == null ? null : indicesStats.getMerge();
+            table.addCell(mergeStats == null ? null : mergeStats.getCurrent());
+            table.addCell(mergeStats == null ? null : mergeStats.getCurrentNumDocs());
+            table.addCell(mergeStats == null ? null : mergeStats.getCurrentSize());
+            table.addCell(mergeStats == null ? null : mergeStats.getTotal());
+            table.addCell(mergeStats == null ? null : mergeStats.getTotalNumDocs());
+            table.addCell(mergeStats == null ? null : mergeStats.getTotalSize());
+            table.addCell(mergeStats == null ? null : mergeStats.getTotalTime());
+
+            ProtobufRefreshStats refreshStats = indicesStats == null ? null : indicesStats.getRefresh();
+            table.addCell(refreshStats == null ? null : refreshStats.getTotal());
+            table.addCell(refreshStats == null ? null : refreshStats.getTotalTime());
+            table.addCell(refreshStats == null ? null : refreshStats.getExternalTotal());
+            table.addCell(refreshStats == null ? null : refreshStats.getExternalTotalTime());
+            table.addCell(refreshStats == null ? null : refreshStats.getListeners());
+
+            ProtobufScriptStats scriptStats = stats == null ? null : stats.getScriptStats();
+            table.addCell(scriptStats == null ? null : scriptStats.getCompilations());
+            table.addCell(scriptStats == null ? null : scriptStats.getCacheEvictions());
+            table.addCell(scriptStats == null ? null : scriptStats.getCompilationLimitTriggered());
+
+            ProtobufSearchStats searchStats = indicesStats == null ? null : indicesStats.getSearch();
+            table.addCell(searchStats == null ? null : searchStats.getTotal().getFetchCurrent());
+            table.addCell(searchStats == null ? null : searchStats.getTotal().getFetchTime());
+            table.addCell(searchStats == null ? null : searchStats.getTotal().getFetchCount());
+            table.addCell(searchStats == null ? null : searchStats.getOpenContexts());
+            table.addCell(searchStats == null ? null : searchStats.getTotal().getQueryCurrent());
+            table.addCell(searchStats == null ? null : searchStats.getTotal().getQueryTime());
+            table.addCell(searchStats == null ? null : searchStats.getTotal().getQueryCount());
+            table.addCell(searchStats == null ? null : searchStats.getTotal().getScrollCurrent());
+            table.addCell(searchStats == null ? null : searchStats.getTotal().getScrollTime());
+            table.addCell(searchStats == null ? null : searchStats.getTotal().getScrollCount());
+            table.addCell(searchStats == null ? null : searchStats.getTotal().getPitCurrent());
+            table.addCell(searchStats == null ? null : searchStats.getTotal().getPitTime());
+            table.addCell(searchStats == null ? null : searchStats.getTotal().getPitCount());
+
+            ProtobufSegmentsStats segmentsStats = indicesStats == null ? null : indicesStats.getSegments();
+            table.addCell(segmentsStats == null ? null : segmentsStats.getCount());
+            table.addCell(segmentsStats == null ? null : segmentsStats.getZeroMemory());
+            table.addCell(segmentsStats == null ? null : segmentsStats.getIndexWriterMemory());
+            table.addCell(segmentsStats == null ? null : segmentsStats.getVersionMapMemory());
+            table.addCell(segmentsStats == null ? null : segmentsStats.getBitsetMemory());
+
+            table.addCell(searchStats == null ? null : searchStats.getTotal().getSuggestCurrent());
+            table.addCell(searchStats == null ? null : searchStats.getTotal().getSuggestTime());
+            table.addCell(searchStats == null ? null : searchStats.getTotal().getSuggestCount());
+
+            table.endRow();
+        }
+
+        return table;
+    }
+
+    /**
+     * Calculate the percentage of {@code used} from the {@code max} number.
+    * @param used The currently used number.
+    * @param max The maximum number.
+    * @return 0 if {@code max} is &lt;= 0. Otherwise 100 * {@code used} / {@code max}.
+    */
+    private short calculatePercentage(long used, long max) {
+        return max <= 0 ? 0 : (short) ((100d * used) / max);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
index 19967097e78b9..b54c8955283a2 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
@@ -35,16 +35,11 @@
 import org.opensearch.action.admin.cluster.node.info.NodeInfo;
 import org.opensearch.action.admin.cluster.node.info.NodesInfoRequest;
 import org.opensearch.action.admin.cluster.node.info.NodesInfoResponse;
-import org.opensearch.action.admin.cluster.node.info.ProtobufNodeInfo;
-import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequest;
-import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoResponse;
 import org.opensearch.action.admin.cluster.node.stats.NodeStats;
 import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
 import org.opensearch.action.admin.cluster.node.stats.NodesStatsResponse;
 import org.opensearch.action.admin.cluster.state.ClusterStateRequest;
 import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
-import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
-import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
 import org.opensearch.client.node.NodeClient;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
@@ -70,7 +65,6 @@
 import org.opensearch.monitor.fs.FsInfo;
 import org.opensearch.monitor.jvm.JvmInfo;
 import org.opensearch.monitor.jvm.JvmStats;
-import org.opensearch.monitor.jvm.ProtobufJvmInfo;
 import org.opensearch.monitor.os.OsStats;
 import org.opensearch.monitor.process.ProcessInfo;
 import org.opensearch.monitor.process.ProcessStats;
@@ -115,7 +109,7 @@ protected void documentation(StringBuilder sb) {
 
     @Override
     public RestChannelConsumer doCatRequest(final RestRequest request, final NodeClient client) {
-        final ProtobufClusterStateRequest clusterStateRequest = new ProtobufClusterStateRequest();
+        final ClusterStateRequest clusterStateRequest = new ClusterStateRequest();
         clusterStateRequest.clear().nodes(true);
         if (request.hasParam("local")) {
             deprecationLogger.deprecate("cat_nodes_local_parameter", LOCAL_DEPRECATED_MESSAGE);
@@ -124,23 +118,23 @@ public RestChannelConsumer doCatRequest(final RestRequest request, final NodeCli
         clusterStateRequest.clusterManagerNodeTimeout(
             request.paramAsTime("cluster_manager_timeout", clusterStateRequest.clusterManagerNodeTimeout())
         );
-        parseDeprecatedMasterTimeoutParameterProtobuf(clusterStateRequest, request, deprecationLogger, getName());
+        parseDeprecatedMasterTimeoutParameter(clusterStateRequest, request, deprecationLogger, getName());
         final boolean fullId = request.paramAsBoolean("full_id", false);
-        return channel -> client.admin().cluster().state(clusterStateRequest, new RestActionListener<ProtobufClusterStateResponse>(channel) {
+        return channel -> client.admin().cluster().state(clusterStateRequest, new RestActionListener<ClusterStateResponse>(channel) {
             @Override
-            public void processResponse(final ProtobufClusterStateResponse clusterStateResponse) {
-                ProtobufNodesInfoRequest nodesInfoRequest = new ProtobufNodesInfoRequest();
+            public void processResponse(final ClusterStateResponse clusterStateResponse) {
+                NodesInfoRequest nodesInfoRequest = new NodesInfoRequest();
                 nodesInfoRequest.timeout(request.param("timeout"));
                 nodesInfoRequest.clear()
                     .addMetrics(
-                        ProtobufNodesInfoRequest.Metric.JVM.metricName(),
-                        ProtobufNodesInfoRequest.Metric.OS.metricName(),
-                        ProtobufNodesInfoRequest.Metric.PROCESS.metricName(),
-                        ProtobufNodesInfoRequest.Metric.HTTP.metricName()
+                        NodesInfoRequest.Metric.JVM.metricName(),
+                        NodesInfoRequest.Metric.OS.metricName(),
+                        NodesInfoRequest.Metric.PROCESS.metricName(),
+                        NodesInfoRequest.Metric.HTTP.metricName()
                     );
-                client.admin().cluster().nodesInfo(nodesInfoRequest, new RestActionListener<ProtobufNodesInfoResponse>(channel) {
+                client.admin().cluster().nodesInfo(nodesInfoRequest, new RestActionListener<NodesInfoResponse>(channel) {
                     @Override
-                    public void processResponse(final ProtobufNodesInfoResponse nodesInfoResponse) {
+                    public void processResponse(final NodesInfoResponse nodesInfoResponse) {
                         NodesStatsRequest nodesStatsRequest = new NodesStatsRequest();
                         nodesStatsRequest.timeout(request.param("timeout"));
                         nodesStatsRequest.clear()
@@ -356,8 +350,8 @@ protected Table getTableWithHeader(final RestRequest request) {
     Table buildTable(
         boolean fullId,
         RestRequest req,
-        ProtobufClusterStateResponse state,
-        ProtobufNodesInfoResponse nodesInfo,
+        ClusterStateResponse state,
+        NodesInfoResponse nodesInfo,
         NodesStatsResponse nodesStats
     ) {
 
@@ -366,10 +360,10 @@ Table buildTable(
         Table table = getTableWithHeader(req);
 
         for (DiscoveryNode node : nodes) {
-            ProtobufNodeInfo info = nodesInfo.getNodesMap().get(node.getId());
+            NodeInfo info = nodesInfo.getNodesMap().get(node.getId());
             NodeStats stats = nodesStats.getNodesMap().get(node.getId());
 
-            ProtobufJvmInfo jvmInfo = info == null ? null : info.getInfo(ProtobufJvmInfo.class);
+            JvmInfo jvmInfo = info == null ? null : info.getInfo(JvmInfo.class);
             JvmStats jvmStats = stats == null ? null : stats.getJvm();
             FsInfo fsInfo = stats == null ? null : stats.getFs();
             OsStats osStats = stats == null ? null : stats.getOs();
diff --git a/server/src/main/java/org/opensearch/script/ProtobufScriptCacheStats.java b/server/src/main/java/org/opensearch/script/ProtobufScriptCacheStats.java
new file mode 100644
index 0000000000000..cf511b4bee309
--- /dev/null
+++ b/server/src/main/java/org/opensearch/script/ProtobufScriptCacheStats.java
@@ -0,0 +1,152 @@
+/*
+* 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.
+*/
+
+package org.opensearch.script;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * Stats for script caching
+*
+* @opensearch.internal
+*
+* @deprecated This class is deprecated in favor of ProtobufScriptStats and ScriptContextStats.  It is removed in OpenSearch 2.0.
+*/
+@Deprecated
+public class ProtobufScriptCacheStats implements ProtobufWriteable, ToXContentFragment {
+    private final Map<String, ProtobufScriptStats> context;
+    private final ProtobufScriptStats general;
+
+    public ProtobufScriptCacheStats(Map<String, ProtobufScriptStats> context) {
+        this.context = Collections.unmodifiableMap(context);
+        this.general = null;
+    }
+
+    public ProtobufScriptCacheStats(ProtobufScriptStats general) {
+        this.general = Objects.requireNonNull(general);
+        this.context = null;
+    }
+
+    public ProtobufScriptCacheStats(CodedInputStream in) throws IOException {
+        boolean isContext = in.readBool();
+        if (isContext == false) {
+            general = new ProtobufScriptStats(in);
+            context = null;
+            return;
+        }
+
+        general = null;
+        int size = in.readInt32();
+        Map<String, ProtobufScriptStats> context = new HashMap<>(size);
+        for (int i = 0; i < size; i++) {
+            String name = in.readString();
+            context.put(name, new ProtobufScriptStats(in));
+        }
+        this.context = Collections.unmodifiableMap(context);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        if (general != null) {
+            out.writeBoolNoTag(false);
+            general.writeTo(out);
+            return;
+        }
+
+        out.writeBoolNoTag(true);
+        out.writeInt32NoTag(context.size());
+        for (String name : context.keySet().stream().sorted().collect(Collectors.toList())) {
+            out.writeStringNoTag(name);
+            context.get(name).writeTo(out);
+        }
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.SCRIPT_CACHE_STATS);
+        builder.startObject(Fields.SUM);
+        if (general != null) {
+            builder.field(ProtobufScriptStats.Fields.COMPILATIONS, general.getCompilations());
+            builder.field(ProtobufScriptStats.Fields.CACHE_EVICTIONS, general.getCacheEvictions());
+            builder.field(ProtobufScriptStats.Fields.COMPILATION_LIMIT_TRIGGERED, general.getCompilationLimitTriggered());
+            builder.endObject().endObject();
+            return builder;
+        }
+
+        ProtobufScriptStats sum = sum();
+        builder.field(ProtobufScriptStats.Fields.COMPILATIONS, sum.getCompilations());
+        builder.field(ProtobufScriptStats.Fields.CACHE_EVICTIONS, sum.getCacheEvictions());
+        builder.field(ProtobufScriptStats.Fields.COMPILATION_LIMIT_TRIGGERED, sum.getCompilationLimitTriggered());
+        builder.endObject();
+
+        builder.startArray(Fields.CONTEXTS);
+        for (String name : context.keySet().stream().sorted().collect(Collectors.toList())) {
+            ProtobufScriptStats stats = context.get(name);
+            builder.startObject();
+            builder.field(Fields.CONTEXT, name);
+            builder.field(ProtobufScriptStats.Fields.COMPILATIONS, stats.getCompilations());
+            builder.field(ProtobufScriptStats.Fields.CACHE_EVICTIONS, stats.getCacheEvictions());
+            builder.field(ProtobufScriptStats.Fields.COMPILATION_LIMIT_TRIGGERED, stats.getCompilationLimitTriggered());
+            builder.endObject();
+        }
+        builder.endArray();
+        builder.endObject();
+
+        return builder;
+    }
+
+    /**
+     * Get the context specific stats, null if using general cache
+    */
+    public Map<String, ProtobufScriptStats> getContextStats() {
+        return context;
+    }
+
+    /**
+     * Get the general stats, null if using context cache
+    */
+    public ProtobufScriptStats getGeneralStats() {
+        return general;
+    }
+
+    /**
+     * The sum of all script stats, either the general stats or the sum of all stats of the context stats.
+    */
+    public ProtobufScriptStats sum() {
+        if (general != null) {
+            return general;
+        }
+        long compilations = 0;
+        long cacheEvictions = 0;
+        long compilationLimitTriggered = 0;
+        for (ProtobufScriptStats stat : context.values()) {
+            compilations += stat.getCompilations();
+            cacheEvictions += stat.getCacheEvictions();
+            compilationLimitTriggered += stat.getCompilationLimitTriggered();
+        }
+        return new ProtobufScriptStats(compilations, cacheEvictions, compilationLimitTriggered);
+    }
+
+    static final class Fields {
+        static final String SCRIPT_CACHE_STATS = "script_cache";
+        static final String CONTEXT = "context";
+        static final String SUM = "sum";
+        static final String CONTEXTS = "contexts";
+    }
+}
diff --git a/server/src/main/java/org/opensearch/script/ProtobufScriptContextStats.java b/server/src/main/java/org/opensearch/script/ProtobufScriptContextStats.java
new file mode 100644
index 0000000000000..52fe4f1bed339
--- /dev/null
+++ b/server/src/main/java/org/opensearch/script/ProtobufScriptContextStats.java
@@ -0,0 +1,91 @@
+/*
+* 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.
+*/
+
+package org.opensearch.script;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Objects;
+
+/**
+ * Stats for a script context
+*
+* @opensearch.internal
+*/
+public class ProtobufScriptContextStats implements ProtobufWriteable, ToXContentFragment, Comparable<ProtobufScriptContextStats> {
+    private final String context;
+    private final long compilations;
+    private final long cacheEvictions;
+    private final long compilationLimitTriggered;
+
+    public ProtobufScriptContextStats(String context, long compilations, long cacheEvictions, long compilationLimitTriggered) {
+        this.context = Objects.requireNonNull(context);
+        this.compilations = compilations;
+        this.cacheEvictions = cacheEvictions;
+        this.compilationLimitTriggered = compilationLimitTriggered;
+    }
+
+    public ProtobufScriptContextStats(CodedInputStream in) throws IOException {
+        context = in.readString();
+        compilations = in.readInt64();
+        cacheEvictions = in.readInt64();
+        compilationLimitTriggered = in.readInt64();
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeStringNoTag(context);
+        out.writeInt64NoTag(compilations);
+        out.writeInt64NoTag(cacheEvictions);
+        out.writeInt64NoTag(compilationLimitTriggered);
+    }
+
+    public String getContext() {
+        return context;
+    }
+
+    public long getCompilations() {
+        return compilations;
+    }
+
+    public long getCacheEvictions() {
+        return cacheEvictions;
+    }
+
+    public long getCompilationLimitTriggered() {
+        return compilationLimitTriggered;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        builder.field(Fields.CONTEXT, getContext());
+        builder.field(Fields.COMPILATIONS, getCompilations());
+        builder.field(Fields.CACHE_EVICTIONS, getCacheEvictions());
+        builder.field(Fields.COMPILATION_LIMIT_TRIGGERED, getCompilationLimitTriggered());
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public int compareTo(ProtobufScriptContextStats o) {
+        return this.context.compareTo(o.context);
+    }
+
+    static final class Fields {
+        static final String CONTEXT = "context";
+        static final String COMPILATIONS = "compilations";
+        static final String CACHE_EVICTIONS = "cache_evictions";
+        static final String COMPILATION_LIMIT_TRIGGERED = "compilation_limit_triggered";
+    }
+}
diff --git a/server/src/main/java/org/opensearch/script/ProtobufScriptStats.java b/server/src/main/java/org/opensearch/script/ProtobufScriptStats.java
new file mode 100644
index 0000000000000..c0366f94748ee
--- /dev/null
+++ b/server/src/main/java/org/opensearch/script/ProtobufScriptStats.java
@@ -0,0 +1,127 @@
+/*
+* 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.
+*/
+
+package org.opensearch.script;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Stats for scripts
+*
+* @opensearch.internal
+*/
+public class ProtobufScriptStats implements ProtobufWriteable, ToXContentFragment {
+    private final List<ProtobufScriptContextStats> contextStats;
+    private final long compilations;
+    private final long cacheEvictions;
+    private final long compilationLimitTriggered;
+
+    public ProtobufScriptStats(List<ProtobufScriptContextStats> contextStats) {
+        ArrayList<ProtobufScriptContextStats> ctxStats = new ArrayList<>(contextStats.size());
+        ctxStats.addAll(contextStats);
+        ctxStats.sort(ProtobufScriptContextStats::compareTo);
+        this.contextStats = Collections.unmodifiableList(ctxStats);
+        long compilations = 0;
+        long cacheEvictions = 0;
+        long compilationLimitTriggered = 0;
+        for (ProtobufScriptContextStats stats : contextStats) {
+            compilations += stats.getCompilations();
+            cacheEvictions += stats.getCacheEvictions();
+            compilationLimitTriggered += stats.getCompilationLimitTriggered();
+        }
+        this.compilations = compilations;
+        this.cacheEvictions = cacheEvictions;
+        this.compilationLimitTriggered = compilationLimitTriggered;
+    }
+
+    public ProtobufScriptStats(long compilations, long cacheEvictions, long compilationLimitTriggered) {
+        this.contextStats = Collections.emptyList();
+        this.compilations = compilations;
+        this.cacheEvictions = cacheEvictions;
+        this.compilationLimitTriggered = compilationLimitTriggered;
+    }
+
+    public ProtobufScriptStats(ProtobufScriptContextStats context) {
+        this(context.getCompilations(), context.getCacheEvictions(), context.getCompilationLimitTriggered());
+    }
+
+    public ProtobufScriptStats(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        compilations = in.readInt64();
+        cacheEvictions = in.readInt64();
+        compilationLimitTriggered = in.readInt64();
+        contextStats = protobufStreamInput.readList(ProtobufScriptContextStats::new);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        out.writeInt64NoTag(compilations);
+        out.writeInt64NoTag(cacheEvictions);
+        out.writeInt64NoTag(compilationLimitTriggered);
+        protobufStreamOutput.writeCollection(contextStats, (o, v) -> v.writeTo(o));
+    }
+
+    public List<ProtobufScriptContextStats> getContextStats() {
+        return contextStats;
+    }
+
+    public long getCompilations() {
+        return compilations;
+    }
+
+    public long getCacheEvictions() {
+        return cacheEvictions;
+    }
+
+    public long getCompilationLimitTriggered() {
+        return compilationLimitTriggered;
+    }
+
+    public ProtobufScriptCacheStats toScriptCacheStats() {
+        if (contextStats.isEmpty()) {
+            return new ProtobufScriptCacheStats(this);
+        }
+        Map<String, ProtobufScriptStats> contexts = new HashMap<>(contextStats.size());
+        for (ProtobufScriptContextStats contextStats : contextStats) {
+            contexts.put(contextStats.getContext(), new ProtobufScriptStats(contextStats));
+        }
+        return new ProtobufScriptCacheStats(contexts);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.SCRIPT_STATS);
+        builder.field(Fields.COMPILATIONS, compilations);
+        builder.field(Fields.CACHE_EVICTIONS, cacheEvictions);
+        builder.field(Fields.COMPILATION_LIMIT_TRIGGERED, compilationLimitTriggered);
+        builder.endObject();
+        return builder;
+    }
+
+    static final class Fields {
+        static final String SCRIPT_STATS = "script";
+        static final String CONTEXTS = "contexts";
+        static final String COMPILATIONS = "compilations";
+        static final String CACHE_EVICTIONS = "cache_evictions";
+        static final String COMPILATION_LIMIT_TRIGGERED = "compilation_limit_triggered";
+    }
+}
diff --git a/server/src/main/java/org/opensearch/search/suggest/completion/ProtobufCompletionStats.java b/server/src/main/java/org/opensearch/search/suggest/completion/ProtobufCompletionStats.java
new file mode 100644
index 0000000000000..cf3f6db462f16
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/suggest/completion/ProtobufCompletionStats.java
@@ -0,0 +1,96 @@
+/*
+* 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.
+*/
+
+package org.opensearch.search.suggest.completion;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.ProtobufFieldMemoryStats;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+/**
+ * Stats for completion suggester
+*
+* @opensearch.internal
+*/
+public class ProtobufCompletionStats implements ProtobufWriteable, ToXContentFragment {
+
+    private static final String COMPLETION = "completion";
+    private static final String SIZE_IN_BYTES = "size_in_bytes";
+    private static final String SIZE = "size";
+    private static final String FIELDS = "fields";
+
+    private long sizeInBytes;
+    @Nullable
+    private ProtobufFieldMemoryStats fields;
+
+    public ProtobufCompletionStats() {}
+
+    public ProtobufCompletionStats(CodedInputStream in) throws IOException {
+        sizeInBytes = in.readInt64();
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        fields = protobufStreamInput.readOptionalWriteable(ProtobufFieldMemoryStats::new);
+    }
+
+    public ProtobufCompletionStats(long size, @Nullable ProtobufFieldMemoryStats fields) {
+        this.sizeInBytes = size;
+        this.fields = fields;
+    }
+
+    public long getSizeInBytes() {
+        return sizeInBytes;
+    }
+
+    public ByteSizeValue getSize() {
+        return new ByteSizeValue(sizeInBytes);
+    }
+
+    public ProtobufFieldMemoryStats getFields() {
+        return fields;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(sizeInBytes);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeOptionalWriteable(fields);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(COMPLETION);
+        builder.humanReadableField(SIZE_IN_BYTES, SIZE, getSize());
+        if (fields != null) {
+            fields.toXContent(builder, FIELDS, SIZE_IN_BYTES, SIZE);
+        }
+        builder.endObject();
+        return builder;
+    }
+
+    public void add(ProtobufCompletionStats completion) {
+        if (completion == null) {
+            return;
+        }
+        sizeInBytes += completion.getSizeInBytes();
+        if (completion.fields != null) {
+            if (fields == null) {
+                fields = completion.fields.copy();
+            } else {
+                fields.add(completion.fields);
+            }
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
index 7236fa2ebdc2f..61e80ad7f242c 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
@@ -8,25 +8,25 @@
 
 package org.opensearch.tasks;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.opensearch.ExceptionsHelper;
 import org.opensearch.OpenSearchSecurityException;
 import org.opensearch.action.ActionListener;
 import org.opensearch.action.StepListener;
-import org.opensearch.action.support.ChannelActionListener;
+import org.opensearch.action.support.ProtobufChannelActionListener;
 import org.opensearch.action.support.GroupedActionListener;
-import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.common.io.stream.StreamInput;
-import org.opensearch.common.io.stream.StreamOutput;
-import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.EmptyTransportResponseHandler;
-import org.opensearch.transport.TransportChannel;
-import org.opensearch.transport.TransportException;
-import org.opensearch.transport.TransportRequest;
-import org.opensearch.transport.TransportRequestHandler;
-import org.opensearch.transport.TransportResponse;
-import org.opensearch.transport.TransportService;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.transport.ProtobufEmptyTransportResponseHandler;
+import org.opensearch.transport.ProtobufTransportChannel;
+import org.opensearch.transport.ProtobufTransportException;
+import org.opensearch.transport.ProtobufTransportRequest;
+import org.opensearch.transport.ProtobufTransportRequestHandler;
+import org.opensearch.transport.ProtobufTransportResponse;
+import org.opensearch.transport.ProtobufTransportService;
 
 import java.io.IOException;
 import java.util.Collection;
@@ -40,15 +40,15 @@
 public class ProtobufTaskCancellationService {
     public static final String BAN_PARENT_ACTION_NAME = "internal:admin/tasks/ban";
     private static final Logger logger = LogManager.getLogger(ProtobufTaskCancellationService.class);
-    private final TransportService transportService;
+    private final ProtobufTransportService transportService;
     private final ProtobufTaskManager taskManager;
 
-    public ProtobufTaskCancellationService(TransportService transportService) {
+    public ProtobufTaskCancellationService(ProtobufTransportService transportService) {
         this.transportService = transportService;
         this.taskManager = transportService.getTaskManager();
         transportService.registerRequestHandler(
             BAN_PARENT_ACTION_NAME,
-            ThreadPool.Names.SAME,
+            ProtobufThreadPool.Names.SAME,
             BanParentTaskRequest::new,
             new BanParentRequestHandler()
         );
@@ -58,13 +58,13 @@ private String localNodeId() {
         return transportService.getLocalNode().getId();
     }
 
-    void cancelTaskAndDescendants(CancellableTask task, String reason, boolean waitForCompletion, ActionListener<Void> listener) {
-        final TaskId taskId = task.taskInfo(localNodeId(), false).getTaskId();
+    void cancelTaskAndDescendants(ProtobufCancellableTask task, String reason, boolean waitForCompletion, ActionListener<Void> listener) {
+        final ProtobufTaskId taskId = task.taskInfo(localNodeId(), false).getTaskId();
         if (task.shouldCancelChildrenOnCancellation()) {
             logger.trace("cancelling task [{}] and its descendants", taskId);
             StepListener<Void> completedListener = new StepListener<>();
             GroupedActionListener<Void> groupedListener = new GroupedActionListener<>(ActionListener.map(completedListener, r -> null), 3);
-            Collection<DiscoveryNode> childrenNodes = taskManager.startBanOnChildrenNodes(task.getId(), () -> {
+            Collection<ProtobufDiscoveryNode> childrenNodes = taskManager.startBanOnChildrenNodes(task.getId(), () -> {
                 logger.trace("child tasks of parent [{}] are completed", taskId);
                 groupedListener.onResponse(null);
             });
@@ -103,35 +103,35 @@ void cancelTaskAndDescendants(CancellableTask task, String reason, boolean waitF
     private void setBanOnNodes(
         String reason,
         boolean waitForCompletion,
-        CancellableTask task,
-        Collection<DiscoveryNode> childNodes,
+        ProtobufCancellableTask task,
+        Collection<ProtobufDiscoveryNode> childNodes,
         ActionListener<Void> listener
     ) {
         if (childNodes.isEmpty()) {
             listener.onResponse(null);
             return;
         }
-        final TaskId taskId = new TaskId(localNodeId(), task.getId());
+        final ProtobufTaskId taskId = new ProtobufTaskId(localNodeId(), task.getId());
         logger.trace("cancelling child tasks of [{}] on child nodes {}", taskId, childNodes);
         GroupedActionListener<Void> groupedListener = new GroupedActionListener<>(
             ActionListener.map(listener, r -> null),
             childNodes.size()
         );
         final BanParentTaskRequest banRequest = BanParentTaskRequest.createSetBanParentTaskRequest(taskId, reason, waitForCompletion);
-        for (DiscoveryNode node : childNodes) {
+        for (ProtobufDiscoveryNode node : childNodes) {
             transportService.sendRequest(
                 node,
                 BAN_PARENT_ACTION_NAME,
                 banRequest,
-                new EmptyTransportResponseHandler(ThreadPool.Names.SAME) {
+                new ProtobufEmptyTransportResponseHandler(ProtobufThreadPool.Names.SAME) {
                     @Override
-                    public void handleResponse(TransportResponse.Empty response) {
+                    public void handleResponse(ProtobufTransportResponse.Empty response) {
                         logger.trace("sent ban for tasks with the parent [{}] to the node [{}]", taskId, node);
                         groupedListener.onResponse(null);
                     }
 
                     @Override
-                    public void handleException(TransportException exp) {
+                    public void handleException(ProtobufTransportException exp) {
                         assert ExceptionsHelper.unwrapCause(exp) instanceof OpenSearchSecurityException == false;
                         logger.warn("Cannot send ban for tasks with the parent [{}] to the node [{}]", taskId, node);
                         groupedListener.onFailure(exp);
@@ -141,72 +141,80 @@ public void handleException(TransportException exp) {
         }
     }
 
-    private void removeBanOnNodes(CancellableTask task, Collection<DiscoveryNode> childNodes) {
-        final BanParentTaskRequest request = BanParentTaskRequest.createRemoveBanParentTaskRequest(new TaskId(localNodeId(), task.getId()));
-        for (DiscoveryNode node : childNodes) {
+    private void removeBanOnNodes(ProtobufCancellableTask task, Collection<ProtobufDiscoveryNode> childNodes) {
+        final BanParentTaskRequest request = BanParentTaskRequest.createRemoveBanParentTaskRequest(
+            new ProtobufTaskId(localNodeId(), task.getId())
+        );
+        for (ProtobufDiscoveryNode node : childNodes) {
             logger.trace("Sending remove ban for tasks with the parent [{}] to the node [{}]", request.parentTaskId, node);
-            transportService.sendRequest(node, BAN_PARENT_ACTION_NAME, request, new EmptyTransportResponseHandler(ThreadPool.Names.SAME) {
-                @Override
-                public void handleException(TransportException exp) {
-                    assert ExceptionsHelper.unwrapCause(exp) instanceof OpenSearchSecurityException == false;
-                    logger.info("failed to remove the parent ban for task {} on node {}", request.parentTaskId, node);
+            transportService.sendRequest(
+                node,
+                BAN_PARENT_ACTION_NAME,
+                request,
+                new ProtobufEmptyTransportResponseHandler(ProtobufThreadPool.Names.SAME) {
+                    @Override
+                    public void handleException(ProtobufTransportException exp) {
+                        assert ExceptionsHelper.unwrapCause(exp) instanceof OpenSearchSecurityException == false;
+                        logger.info("failed to remove the parent ban for task {} on node {}", request.parentTaskId, node);
+                    }
                 }
-            });
+            );
         }
     }
 
-    private static class BanParentTaskRequest extends TransportRequest {
+    private static class BanParentTaskRequest extends ProtobufTransportRequest {
 
-        private final TaskId parentTaskId;
+        private final ProtobufTaskId parentTaskId;
         private final boolean ban;
         private final boolean waitForCompletion;
         private final String reason;
 
-        static BanParentTaskRequest createSetBanParentTaskRequest(TaskId parentTaskId, String reason, boolean waitForCompletion) {
+        static BanParentTaskRequest createSetBanParentTaskRequest(ProtobufTaskId parentTaskId, String reason, boolean waitForCompletion) {
             return new BanParentTaskRequest(parentTaskId, reason, waitForCompletion);
         }
 
-        static BanParentTaskRequest createRemoveBanParentTaskRequest(TaskId parentTaskId) {
+        static BanParentTaskRequest createRemoveBanParentTaskRequest(ProtobufTaskId parentTaskId) {
             return new BanParentTaskRequest(parentTaskId);
         }
 
-        private BanParentTaskRequest(TaskId parentTaskId, String reason, boolean waitForCompletion) {
+        private BanParentTaskRequest(ProtobufTaskId parentTaskId, String reason, boolean waitForCompletion) {
             this.parentTaskId = parentTaskId;
             this.ban = true;
             this.reason = reason;
             this.waitForCompletion = waitForCompletion;
         }
 
-        private BanParentTaskRequest(TaskId parentTaskId) {
+        private BanParentTaskRequest(ProtobufTaskId parentTaskId) {
             this.parentTaskId = parentTaskId;
             this.ban = false;
             this.reason = null;
             this.waitForCompletion = false;
         }
 
-        private BanParentTaskRequest(StreamInput in) throws IOException {
+        private BanParentTaskRequest(CodedInputStream in) throws IOException {
             super(in);
-            parentTaskId = TaskId.readFromStream(in);
-            ban = in.readBoolean();
+            parentTaskId = ProtobufTaskId.readFromStream(in);
+            ban = in.readBool();
             reason = ban ? in.readString() : null;
-            waitForCompletion = in.readBoolean();
+            waitForCompletion = in.readBool();
         }
 
         @Override
-        public void writeTo(StreamOutput out) throws IOException {
+        public void writeTo(CodedOutputStream out) throws IOException {
             super.writeTo(out);
             parentTaskId.writeTo(out);
-            out.writeBoolean(ban);
+            out.writeBoolNoTag(ban);
             if (ban) {
-                out.writeString(reason);
+                out.writeStringNoTag(reason);
             }
-            out.writeBoolean(waitForCompletion);
+            out.writeBoolNoTag(waitForCompletion);
         }
     }
 
-    private class BanParentRequestHandler implements TransportRequestHandler<BanParentTaskRequest> {
+    private class BanParentRequestHandler implements ProtobufTransportRequestHandler<BanParentTaskRequest> {
         @Override
-        public void messageReceived(final BanParentTaskRequest request, final TransportChannel channel, Task task) throws Exception {
+        public void messageReceived(final BanParentTaskRequest request, final ProtobufTransportChannel channel, ProtobufTask task)
+            throws Exception {
             if (request.ban) {
                 logger.debug(
                     "Received ban for the parent [{}] on the node [{}], reason: [{}]",
@@ -214,22 +222,22 @@ public void messageReceived(final BanParentTaskRequest request, final TransportC
                     localNodeId(),
                     request.reason
                 );
-                final List<CancellableTask> childTasks = taskManager.setBan(request.parentTaskId, request.reason);
+                final List<ProtobufCancellableTask> childTasks = taskManager.setBan(request.parentTaskId, request.reason);
                 final GroupedActionListener<Void> listener = new GroupedActionListener<>(
                     ActionListener.map(
-                        new ChannelActionListener<>(channel, BAN_PARENT_ACTION_NAME, request),
-                        r -> TransportResponse.Empty.INSTANCE
+                        new ProtobufChannelActionListener<>(channel, BAN_PARENT_ACTION_NAME, request),
+                        r -> ProtobufTransportResponse.Empty.INSTANCE
                     ),
                     childTasks.size() + 1
                 );
-                for (CancellableTask childTask : childTasks) {
+                for (ProtobufCancellableTask childTask : childTasks) {
                     cancelTaskAndDescendants(childTask, request.reason, request.waitForCompletion, listener);
                 }
                 listener.onResponse(null);
             } else {
                 logger.debug("Removing ban for the parent [{}] on the node [{}]", request.parentTaskId, localNodeId());
                 taskManager.removeBan(request.parentTaskId);
-                channel.sendResponse(TransportResponse.Empty.INSTANCE);
+                channel.sendResponse(ProtobufTransportResponse.Empty.INSTANCE);
             }
         }
     }
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
index 71939b4be2bfb..e8e78dd9cde00 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
@@ -100,11 +100,11 @@ public ProtobufTaskInfo(
     */
     @SuppressWarnings("unchecked")
     public ProtobufTaskInfo(CodedInputStream in) throws IOException {
-        protobufStreamInput = new ProtobufStreamInput();
+        protobufStreamInput = new ProtobufStreamInput(in);
         taskId = ProtobufTaskId.readFromStream(in);
         type = in.readString();
         action = in.readString();
-        description = protobufStreamInput.readOptionalString(in);
+        description = protobufStreamInput.readOptionalString();
         // TODO: fix this
         status = null;
         startTime = in.readInt64();
@@ -119,9 +119,9 @@ public ProtobufTaskInfo(CodedInputStream in) throws IOException {
             throw new IllegalArgumentException("task cannot be cancelled");
         }
         parentTaskId = ProtobufTaskId.readFromStream(in);
-        headers = protobufStreamInput.readMap(CodedInputStream::readString, CodedInputStream::readString, in);
+        headers = protobufStreamInput.readMap(CodedInputStream::readString, CodedInputStream::readString);
         if (protobufStreamInput.getVersion().onOrAfter(Version.V_2_1_0)) {
-            resourceStats = protobufStreamInput.readOptionalWriteable(ProtobufTaskResourceStats::new, in);
+            resourceStats = protobufStreamInput.readOptionalWriteable(ProtobufTaskResourceStats::new);
         } else {
             resourceStats = null;
         }
@@ -129,7 +129,7 @@ public ProtobufTaskInfo(CodedInputStream in) throws IOException {
 
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
-        protobufStreamOutput = new ProtobufStreamOutput();
+        protobufStreamOutput = new ProtobufStreamOutput(out);
         taskId.writeTo(out);
         out.writeStringNoTag(type);
         out.writeStringNoTag(action);
@@ -143,9 +143,9 @@ public void writeTo(CodedOutputStream out) throws IOException {
             out.writeBoolNoTag(cancelled);
         }
         parentTaskId.writeTo(out);
-        protobufStreamOutput.writeMap(headers, CodedOutputStream::writeStringNoTag, CodedOutputStream::writeStringNoTag, out);
+        protobufStreamOutput.writeMap(headers, CodedOutputStream::writeStringNoTag, CodedOutputStream::writeStringNoTag);
         if (protobufStreamOutput.getVersion().onOrAfter(Version.V_2_1_0)) {
-            protobufStreamOutput.writeOptionalWriteable(resourceStats, out);
+            protobufStreamOutput.writeOptionalWriteable(resourceStats);
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskListener.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskListener.java
new file mode 100644
index 0000000000000..67602b0f90b47
--- /dev/null
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskListener.java
@@ -0,0 +1,40 @@
+/*
+* 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.
+*/
+
+package org.opensearch.tasks;
+
+/**
+ * Listener for Task success or failure.
+*
+* @opensearch.internal
+*/
+public interface ProtobufTaskListener<Response> {
+    /**
+     * Handle task response. This response may constitute a failure or a success
+    * but it is up to the listener to make that decision.
+    *
+    * @param task
+    *            the task being executed. May be null if the action doesn't
+    *            create a task
+    * @param response
+    *            the response from the action that executed the task
+    */
+    void onResponse(ProtobufTask task, Response response);
+
+    /**
+     * A failure caused by an exception at some phase of the task.
+    *
+    * @param task
+    *            the task being executed. May be null if the action doesn't
+    *            create a task
+    * @param e
+    *            the failure
+    */
+    void onFailure(ProtobufTask task, Exception e);
+
+}
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskManager.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskManager.java
index 55f9213214ca5..a6e53ebabdd9e 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskManager.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskManager.java
@@ -22,10 +22,8 @@
 import org.opensearch.action.NotifyOnceListener;
 import org.opensearch.cluster.ProtobufClusterChangedEvent;
 import org.opensearch.cluster.ProtobufClusterStateApplier;
-import org.opensearch.cluster.ClusterStateApplier;
 import org.opensearch.cluster.node.ProtobufDiscoveryNode;
 import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
-import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.common.SetOnce;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.lease.Releasables;
@@ -105,7 +103,7 @@ public class ProtobufTaskManager implements ProtobufClusterStateApplier {
 
     private final ByteSizeValue maxHeaderSize;
     private final Map<TcpChannel, ChannelPendingTaskTracker> channelPendingTaskTrackers = ConcurrentCollections.newConcurrentMap();
-    private final SetOnce<TaskCancellationService> cancellationService = new SetOnce<>();
+    private final SetOnce<ProtobufTaskCancellationService> cancellationService = new SetOnce<>();
 
     private volatile boolean taskResourceConsumersEnabled;
     private final Set<Consumer<ProtobufTask>> taskResourceConsumer;
@@ -138,7 +136,7 @@ public void setTaskResultsService(TaskResultsService taskResultsService) {
         this.taskResultsService = taskResultsService;
     }
 
-    public void setTaskCancellationService(TaskCancellationService taskCancellationService) {
+    public void setTaskCancellationService(ProtobufTaskCancellationService taskCancellationService) {
         this.cancellationService.set(taskCancellationService);
     }
 
@@ -302,7 +300,11 @@ public ProtobufDiscoveryNode localNode() {
     /**
      * Stores the task failure
     */
-    public <Response extends ProtobufActionResponse> void storeResult(ProtobufTask task, Exception error, ActionListener<Response> listener) {
+    public <Response extends ProtobufActionResponse> void storeResult(
+        ProtobufTask task,
+        Exception error,
+        ActionListener<Response> listener
+    ) {
         ProtobufDiscoveryNode localNode = lastDiscoveryNodes.getLocalNode();
         if (localNode == null) {
             // too early to store anything, shouldn't really be here - just pass the error along
@@ -334,7 +336,11 @@ public void onFailure(Exception e) {
     /**
      * Stores the task result
     */
-    public <Response extends ProtobufActionResponse> void storeResult(ProtobufTask task, Response response, ActionListener<Response> listener) {
+    public <Response extends ProtobufActionResponse> void storeResult(
+        ProtobufTask task,
+        Response response,
+        ActionListener<Response> listener
+    ) {
         ProtobufDiscoveryNode localNode = lastDiscoveryNodes.getLocalNode();
         if (localNode == null) {
             // too early to store anything, shouldn't really be here - just pass the response along
@@ -740,13 +746,18 @@ protected void doRun() {
         }
     }
 
-    public void cancelTaskAndDescendants(ProtobufCancellableTask task, String reason, boolean waitForCompletion, ActionListener<Void> listener) {
-        final TaskCancellationService service = cancellationService.get();
+    public void cancelTaskAndDescendants(
+        ProtobufCancellableTask task,
+        String reason,
+        boolean waitForCompletion,
+        ActionListener<Void> listener
+    ) {
+        final ProtobufTaskCancellationService service = cancellationService.get();
         if (service != null) {
             service.cancelTaskAndDescendants(task, reason, waitForCompletion, listener);
         } else {
-            assert false : "TaskCancellationService is not initialized";
-            throw new IllegalStateException("TaskCancellationService is not initialized");
+            assert false : "ProtobufTaskCancellationService is not initialized";
+            throw new IllegalStateException("ProtobufTaskCancellationService is not initialized");
         }
     }
 }
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceTrackingService.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceTrackingService.java
index 8b67855d2fc98..8c165e9237047 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceTrackingService.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceTrackingService.java
@@ -50,7 +50,8 @@ public class ProtobufTaskResourceTrackingService implements RunnableTaskExecutio
 
     private static final ThreadMXBean threadMXBean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
 
-    private final ConcurrentMapLong<ProtobufTask> resourceAwareTasks = ConcurrentCollections.newConcurrentMapLongWithAggressiveConcurrency();
+    private final ConcurrentMapLong<ProtobufTask> resourceAwareTasks = ConcurrentCollections
+        .newConcurrentMapLongWithAggressiveConcurrency();
     private final List<TaskCompletionListener> taskCompletionListeners = new ArrayList<>();
     private final ProtobufThreadPool threadPool;
     private volatile boolean taskResourceTrackingEnabled;
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
index d4a2402961cc1..1c3128309f00e 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
@@ -81,11 +81,11 @@ public ProtobufTaskResult(boolean completed, ProtobufTaskInfo task, @Nullable By
     * Read from a stream.
     */
     public ProtobufTaskResult(CodedInputStream in) throws IOException {
-        protobufStreamInput = new ProtobufStreamInput();
+        protobufStreamInput = new ProtobufStreamInput(in);
         completed = in.readBool();
         task = new ProtobufTaskInfo(in);
-        error = protobufStreamInput.readOptionalBytesReference(in);
-        response = protobufStreamInput.readOptionalBytesReference(in);
+        error = protobufStreamInput.readOptionalBytesReference();
+        response = protobufStreamInput.readOptionalBytesReference();
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPool.java b/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPool.java
index d48704fa5777a..c77984a5a5953 100644
--- a/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPool.java
+++ b/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPool.java
@@ -716,7 +716,7 @@ public Info(
         }
 
         public Info(CodedInputStream in) throws IOException {
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
             name = in.readString();
             final String typeStr = in.readString();
             // Opensearch on or after 3.0.0 version doesn't know about "fixed_auto_queue_size" thread pool. Convert it to RESIZABLE.
@@ -727,13 +727,13 @@ public Info(CodedInputStream in) throws IOException {
             }
             min = in.readInt32();
             max = in.readInt32();
-            keepAlive = protobufStreamInput.readOptionalTimeValue(in);
-            queueSize = protobufStreamInput.readOptionalWriteable(ProtobufSizeValue::new, in);
+            keepAlive = protobufStreamInput.readOptionalTimeValue();
+            queueSize = protobufStreamInput.readOptionalWriteable(ProtobufSizeValue::new);
         }
 
         @Override
         public void writeTo(CodedOutputStream out) throws IOException {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
             out.writeStringNoTag(name);
             if (type == ThreadPoolType.RESIZABLE && protobufStreamOutput.getVersion().before(Version.V_3_0_0)) {
                 // Opensearch on older version doesn't know about "resizable" thread pool. Convert RESIZABLE to FIXED
@@ -744,8 +744,8 @@ public void writeTo(CodedOutputStream out) throws IOException {
             }
             out.writeInt32NoTag(min);
             out.writeInt32NoTag(max);
-            protobufStreamOutput.writeOptionalTimeValue(keepAlive, out);
-            protobufStreamOutput.writeOptionalWriteable(queueSize, out);
+            protobufStreamOutput.writeOptionalTimeValue(keepAlive);
+            protobufStreamOutput.writeOptionalWriteable(queueSize);
         }
 
         public String getName() {
diff --git a/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java b/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java
index 5188abedd67ca..f4a67d306f4bc 100644
--- a/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java
+++ b/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java
@@ -34,14 +34,14 @@ public ProtobufThreadPoolInfo(List<ProtobufThreadPool.Info> infos) {
     }
 
     public ProtobufThreadPoolInfo(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput();
-        this.infos = Collections.unmodifiableList(protobufStreamInput.readList(ProtobufThreadPool.Info::new, in));
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        this.infos = Collections.unmodifiableList(protobufStreamInput.readList(ProtobufThreadPool.Info::new));
     }
 
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
-        protobufStreamOutput.writeCollection(infos, (o, v) -> v.writeTo(o), out);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeCollection(infos, (o, v) -> v.writeTo(o));
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolStats.java b/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolStats.java
new file mode 100644
index 0000000000000..b4c8c4d612cd8
--- /dev/null
+++ b/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolStats.java
@@ -0,0 +1,191 @@
+/*
+* 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.
+*/
+
+package org.opensearch.threadpool;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Stats for a threadpool
+*
+* @opensearch.internal
+*/
+public class ProtobufThreadPoolStats implements ProtobufWriteable, ToXContentFragment, Iterable<ProtobufThreadPoolStats.Stats> {
+
+    /**
+     * The statistics.
+    *
+    * @opensearch.internal
+    */
+    public static class Stats implements ProtobufWriteable, ToXContentFragment, Comparable<Stats> {
+
+        private final String name;
+        private final int threads;
+        private final int queue;
+        private final int active;
+        private final long rejected;
+        private final int largest;
+        private final long completed;
+
+        public Stats(String name, int threads, int queue, int active, long rejected, int largest, long completed) {
+            this.name = name;
+            this.threads = threads;
+            this.queue = queue;
+            this.active = active;
+            this.rejected = rejected;
+            this.largest = largest;
+            this.completed = completed;
+        }
+
+        public Stats(CodedInputStream in) throws IOException {
+            name = in.readString();
+            threads = in.readInt32();
+            queue = in.readInt32();
+            active = in.readInt32();
+            rejected = in.readInt64();
+            largest = in.readInt32();
+            completed = in.readInt64();
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeStringNoTag(name);
+            out.writeInt32NoTag(threads);
+            out.writeInt32NoTag(queue);
+            out.writeInt32NoTag(active);
+            out.writeInt64NoTag(rejected);
+            out.writeInt32NoTag(largest);
+            out.writeInt64NoTag(completed);
+        }
+
+        public String getName() {
+            return this.name;
+        }
+
+        public int getThreads() {
+            return this.threads;
+        }
+
+        public int getQueue() {
+            return this.queue;
+        }
+
+        public int getActive() {
+            return this.active;
+        }
+
+        public long getRejected() {
+            return rejected;
+        }
+
+        public int getLargest() {
+            return largest;
+        }
+
+        public long getCompleted() {
+            return this.completed;
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.startObject(name);
+            if (threads != -1) {
+                builder.field(Fields.THREADS, threads);
+            }
+            if (queue != -1) {
+                builder.field(Fields.QUEUE, queue);
+            }
+            if (active != -1) {
+                builder.field(Fields.ACTIVE, active);
+            }
+            if (rejected != -1) {
+                builder.field(Fields.REJECTED, rejected);
+            }
+            if (largest != -1) {
+                builder.field(Fields.LARGEST, largest);
+            }
+            if (completed != -1) {
+                builder.field(Fields.COMPLETED, completed);
+            }
+            builder.endObject();
+            return builder;
+        }
+
+        @Override
+        public int compareTo(Stats other) {
+            if ((getName() == null) && (other.getName() == null)) {
+                return 0;
+            } else if ((getName() != null) && (other.getName() == null)) {
+                return 1;
+            } else if (getName() == null) {
+                return -1;
+            } else {
+                int compare = getName().compareTo(other.getName());
+                if (compare == 0) {
+                    compare = Integer.compare(getThreads(), other.getThreads());
+                }
+                return compare;
+            }
+        }
+    }
+
+    private List<Stats> stats;
+
+    public ProtobufThreadPoolStats(List<Stats> stats) {
+        Collections.sort(stats);
+        this.stats = stats;
+    }
+
+    public ProtobufThreadPoolStats(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        stats = protobufStreamInput.readList(Stats::new);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeCollection(stats, (o, v) -> v.writeTo(o));
+    }
+
+    @Override
+    public Iterator<Stats> iterator() {
+        return stats.iterator();
+    }
+
+    static final class Fields {
+        static final String THREAD_POOL = "thread_pool";
+        static final String THREADS = "threads";
+        static final String QUEUE = "queue";
+        static final String ACTIVE = "active";
+        static final String REJECTED = "rejected";
+        static final String LARGEST = "largest";
+        static final String COMPLETED = "completed";
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params params) throws IOException {
+        builder.startObject(Fields.THREAD_POOL);
+        for (Stats stat : stats) {
+            stat.toXContent(builder, params);
+        }
+        builder.endObject();
+        return builder;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufActionTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufActionTransportException.java
new file mode 100644
index 0000000000000..495bd02f4b070
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufActionTransportException.java
@@ -0,0 +1,88 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.transport.ProtobufTransportAddress;
+
+import java.io.IOException;
+
+/**
+ * An action invocation failure.
+*
+* @opensearch.internal
+*/
+public class ProtobufActionTransportException extends ProtobufTransportException {
+
+    private final ProtobufTransportAddress address;
+
+    private final String action;
+
+    public ProtobufActionTransportException(CodedInputStream in) throws IOException {
+        super(in);
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        address = protobufStreamInput.readOptionalWriteable(ProtobufTransportAddress::new);
+        action = protobufStreamInput.readOptionalString();
+    }
+
+    public ProtobufActionTransportException(String name, ProtobufTransportAddress address, String action, Throwable cause) {
+        super(buildMessage(name, address, action, null), cause);
+        this.address = address;
+        this.action = action;
+    }
+
+    public ProtobufActionTransportException(String name, ProtobufTransportAddress address, String action, String msg, Throwable cause) {
+        super(buildMessage(name, address, action, msg), cause);
+        this.address = address;
+        this.action = action;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        super.writeTo(out);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeOptionalWriteable(address);
+        protobufStreamOutput.writeOptionalString(action);
+    }
+
+    /**
+     * The target address to invoke the action on.
+    */
+    public ProtobufTransportAddress address() {
+        return address;
+    }
+
+    /**
+     * The action to invoke.
+    */
+    public String action() {
+        return action;
+    }
+
+    private static String buildMessage(String name, ProtobufTransportAddress address, String action, String msg) {
+        StringBuilder sb = new StringBuilder();
+        if (name != null) {
+            sb.append('[').append(name).append(']');
+        }
+        if (address != null) {
+            sb.append('[').append(address).append(']');
+        }
+        if (action != null) {
+            sb.append('[').append(action).append(']');
+        }
+        if (msg != null) {
+            sb.append(" ").append(msg);
+        }
+        return sb.toString();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufBytesTransportRequest.java b/server/src/main/java/org/opensearch/transport/ProtobufBytesTransportRequest.java
new file mode 100644
index 0000000000000..ff684a7909915
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufBytesTransportRequest.java
@@ -0,0 +1,66 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.Version;
+import org.opensearch.common.bytes.BytesReference;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+
+import java.io.IOException;
+
+/**
+ * A specialized, bytes only request, that can potentially be optimized on the network
+* layer, specifically for the same large buffer send to several nodes.
+*
+* @opensearch.internal
+*/
+public class ProtobufBytesTransportRequest extends ProtobufTransportRequest {
+
+    BytesReference bytes;
+    Version version;
+
+    public ProtobufBytesTransportRequest(CodedInputStream in) throws IOException {
+        super(in);
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        bytes = protobufStreamInput.readBytesReference();
+        version = protobufStreamInput.getVersion();
+    }
+
+    public ProtobufBytesTransportRequest(BytesReference bytes, Version version) {
+        this.bytes = bytes;
+        this.version = version;
+    }
+
+    public Version version() {
+        return this.version;
+    }
+
+    public BytesReference bytes() {
+        return this.bytes;
+    }
+
+    /**
+     * Writes the data in a "thin" manner, without the actual bytes, assumes
+    * the actual bytes will be appended right after this content.
+    */
+    public void writeThin(CodedOutputStream out) throws IOException {
+        super.writeTo(out);
+        out.writeInt32NoTag(bytes.length());
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        super.writeTo(out);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        out.writeByteArrayNoTag(BytesReference.toBytes(bytes));
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java b/server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java
new file mode 100644
index 0000000000000..d8a3a7e87c80b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java
@@ -0,0 +1,290 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.action.ActionListener;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.concurrent.AbstractRefCounted;
+import org.opensearch.common.util.concurrent.ConcurrentCollections;
+import org.opensearch.common.util.concurrent.OpenSearchExecutors;
+import org.opensearch.common.util.concurrent.ListenableFuture;
+import org.opensearch.common.util.concurrent.RunOnce;
+import org.opensearch.common.util.io.IOUtils;
+
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * This class manages node connections within a cluster. The connection is opened by the underlying transport.
+* Once the connection is opened, this class manages the connection. This includes closing the connection when
+* the connection manager is closed.
+*
+* @opensearch.internal
+*/
+public class ProtobufClusterConnectionManager implements ProtobufConnectionManager {
+
+    private static final Logger logger = LogManager.getLogger(ProtobufClusterConnectionManager.class);
+
+    private final ConcurrentMap<ProtobufDiscoveryNode, ProtobufTransport.Connection> connectedNodes = ConcurrentCollections
+        .newConcurrentMap();
+    private final ConcurrentMap<ProtobufDiscoveryNode, ListenableFuture<Void>> pendingConnections = ConcurrentCollections
+        .newConcurrentMap();
+    private final AbstractRefCounted connectingRefCounter = new AbstractRefCounted("connection manager") {
+        @Override
+        protected void closeInternal() {
+            Iterator<Map.Entry<ProtobufDiscoveryNode, ProtobufTransport.Connection>> iterator = connectedNodes.entrySet().iterator();
+            while (iterator.hasNext()) {
+                Map.Entry<ProtobufDiscoveryNode, ProtobufTransport.Connection> next = iterator.next();
+                try {
+                    IOUtils.closeWhileHandlingException(next.getValue());
+                } finally {
+                    iterator.remove();
+                }
+            }
+            closeLatch.countDown();
+        }
+    };
+    private final ProtobufTransport transport;
+    private final ProtobufConnectionProfile defaultProfile;
+    private final AtomicBoolean closing = new AtomicBoolean(false);
+    private final CountDownLatch closeLatch = new CountDownLatch(1);
+    private final DelegatingNodeConnectionListener connectionListener = new DelegatingNodeConnectionListener();
+
+    public ProtobufClusterConnectionManager(Settings settings, ProtobufTransport transport) {
+        this(ProtobufConnectionProfile.buildDefaultConnectionProfile(settings), transport);
+    }
+
+    public ProtobufClusterConnectionManager(ProtobufConnectionProfile connectionProfile, ProtobufTransport transport) {
+        this.transport = transport;
+        this.defaultProfile = connectionProfile;
+    }
+
+    @Override
+    public void addListener(ProtobufTransportConnectionListener listener) {
+        this.connectionListener.addListener(listener);
+    }
+
+    @Override
+    public void removeListener(ProtobufTransportConnectionListener listener) {
+        this.connectionListener.removeListener(listener);
+    }
+
+    @Override
+    public void openConnection(
+        ProtobufDiscoveryNode node,
+        ProtobufConnectionProfile connectionProfile,
+        ActionListener<ProtobufTransport.Connection> listener
+    ) {
+        ProtobufConnectionProfile resolvedProfile = ProtobufConnectionProfile.resolveConnectionProfile(connectionProfile, defaultProfile);
+        internalOpenConnection(node, resolvedProfile, listener);
+    }
+
+    /**
+     * Connects to a node with the given connection profile. If the node is already connected this method has no effect.
+    * Once a successful is established, it can be validated before being exposed.
+    * The ActionListener will be called on the calling thread or the generic thread pool.
+    */
+    @Override
+    public void connectToNode(
+        ProtobufDiscoveryNode node,
+        ProtobufConnectionProfile connectionProfile,
+        ConnectionValidator connectionValidator,
+        ActionListener<Void> listener
+    ) throws ProtobufConnectTransportException {
+        ProtobufConnectionProfile resolvedProfile = ProtobufConnectionProfile.resolveConnectionProfile(connectionProfile, defaultProfile);
+        if (node == null) {
+            listener.onFailure(new ProtobufConnectTransportException(null, "can't connect to a null node"));
+            return;
+        }
+
+        if (connectingRefCounter.tryIncRef() == false) {
+            listener.onFailure(new IllegalStateException("connection manager is closed"));
+            return;
+        }
+
+        if (connectedNodes.containsKey(node)) {
+            connectingRefCounter.decRef();
+            listener.onResponse(null);
+            return;
+        }
+
+        final ListenableFuture<Void> currentListener = new ListenableFuture<>();
+        final ListenableFuture<Void> existingListener = pendingConnections.putIfAbsent(node, currentListener);
+        if (existingListener != null) {
+            try {
+                // wait on previous entry to complete connection attempt
+                existingListener.addListener(listener, OpenSearchExecutors.newDirectExecutorService());
+            } finally {
+                connectingRefCounter.decRef();
+            }
+            return;
+        }
+
+        currentListener.addListener(listener, OpenSearchExecutors.newDirectExecutorService());
+
+        final RunOnce releaseOnce = new RunOnce(connectingRefCounter::decRef);
+        internalOpenConnection(node, resolvedProfile, ActionListener.wrap(conn -> {
+            connectionValidator.validate(conn, resolvedProfile, ActionListener.wrap(ignored -> {
+                assert Transports.assertNotTransportThread("connection validator success");
+                try {
+                    if (connectedNodes.putIfAbsent(node, conn) != null) {
+                        logger.debug("existing connection to node [{}], closing new redundant connection", node);
+                        IOUtils.closeWhileHandlingException(conn);
+                    } else {
+                        logger.debug("connected to node [{}]", node);
+                        try {
+                            connectionListener.onNodeConnected(node, conn);
+                        } finally {
+                            final ProtobufTransport.Connection finalConnection = conn;
+                            conn.addCloseListener(ActionListener.wrap(() -> {
+                                logger.trace("unregistering {} after connection close and marking as disconnected", node);
+                                connectedNodes.remove(node, finalConnection);
+                                connectionListener.onNodeDisconnected(node, conn);
+                            }));
+                        }
+                    }
+                } finally {
+                    ListenableFuture<Void> future = pendingConnections.remove(node);
+                    assert future == currentListener : "Listener in pending map is different than the expected listener";
+                    releaseOnce.run();
+                    future.onResponse(null);
+                }
+            }, e -> {
+                assert Transports.assertNotTransportThread("connection validator failure");
+                IOUtils.closeWhileHandlingException(conn);
+                failConnectionListeners(node, releaseOnce, e, currentListener);
+            }));
+        }, e -> {
+            assert Transports.assertNotTransportThread("internalOpenConnection failure");
+            failConnectionListeners(node, releaseOnce, e, currentListener);
+        }));
+    }
+
+    /**
+     * Returns a connection for the given node if the node is connected.
+    * Connections returned from this method must not be closed. The lifecycle of this connection is
+    * maintained by this connection manager
+    *
+    * @throws ProtobufNodeNotConnectedException if the node is not connected
+    * @see #connectToNode(ProtobufDiscoveryNode, ProtobufConnectionProfile, ConnectionValidator, ActionListener)
+    */
+    @Override
+    public ProtobufTransport.Connection getConnection(ProtobufDiscoveryNode node) {
+        ProtobufTransport.Connection connection = connectedNodes.get(node);
+        if (connection == null) {
+            throw new ProtobufNodeNotConnectedException(node, "Node not connected");
+        }
+        return connection;
+    }
+
+    /**
+     * Returns {@code true} if the node is connected.
+    */
+    @Override
+    public boolean nodeConnected(ProtobufDiscoveryNode node) {
+        return connectedNodes.containsKey(node);
+    }
+
+    /**
+     * Disconnected from the given node, if not connected, will do nothing.
+    */
+    @Override
+    public void disconnectFromNode(ProtobufDiscoveryNode node) {
+        ProtobufTransport.Connection nodeChannels = connectedNodes.remove(node);
+        if (nodeChannels != null) {
+            // if we found it and removed it we close
+            nodeChannels.close();
+        }
+    }
+
+    /**
+     * Returns the number of nodes this manager is connected to.
+    */
+    @Override
+    public int size() {
+        return connectedNodes.size();
+    }
+
+    @Override
+    public Set<ProtobufDiscoveryNode> getAllConnectedNodes() {
+        return Collections.unmodifiableSet(connectedNodes.keySet());
+    }
+
+    @Override
+    public void close() {
+        internalClose(true);
+    }
+
+    @Override
+    public void closeNoBlock() {
+        internalClose(false);
+    }
+
+    private void internalClose(boolean waitForPendingConnections) {
+        assert Transports.assertNotTransportThread("Closing ProtobufConnectionManager");
+        if (closing.compareAndSet(false, true)) {
+            connectingRefCounter.decRef();
+            if (waitForPendingConnections) {
+                try {
+                    closeLatch.await();
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    throw new IllegalStateException(e);
+                }
+            }
+        }
+    }
+
+    private void internalOpenConnection(
+        ProtobufDiscoveryNode node,
+        ProtobufConnectionProfile connectionProfile,
+        ActionListener<ProtobufTransport.Connection> listener
+    ) {
+        transport.openConnection(node, connectionProfile, ActionListener.map(listener, connection -> {
+            assert Transports.assertNotTransportThread("internalOpenConnection success");
+            try {
+                connectionListener.onConnectionOpened(connection);
+            } finally {
+                connection.addCloseListener(ActionListener.wrap(() -> connectionListener.onConnectionClosed(connection)));
+            }
+            if (connection.isClosed()) {
+                throw new ProtobufConnectTransportException(node, "a channel closed while connecting");
+            }
+            return connection;
+        }));
+    }
+
+    private void failConnectionListeners(
+        ProtobufDiscoveryNode node,
+        RunOnce releaseOnce,
+        Exception e,
+        ListenableFuture<Void> expectedListener
+    ) {
+        ListenableFuture<Void> future = pendingConnections.remove(node);
+        releaseOnce.run();
+        if (future != null) {
+            assert future == expectedListener : "Listener in pending map is different than the expected listener";
+            future.onFailure(e);
+        }
+    }
+
+    @Override
+    public ProtobufConnectionProfile getConnectionProfile() {
+        return defaultProfile;
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufConnectTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufConnectTransportException.java
new file mode 100644
index 0000000000000..ebb7e37b7010b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufConnectTransportException.java
@@ -0,0 +1,61 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+
+import java.io.IOException;
+
+/**
+ * Transport connection exception
+*
+* @opensearch.internal
+*/
+public class ProtobufConnectTransportException extends ProtobufActionTransportException {
+
+    private final ProtobufDiscoveryNode node;
+
+    public ProtobufConnectTransportException(ProtobufDiscoveryNode node, String msg) {
+        this(node, msg, null, null);
+    }
+
+    public ProtobufConnectTransportException(ProtobufDiscoveryNode node, String msg, String action) {
+        this(node, msg, action, null);
+    }
+
+    public ProtobufConnectTransportException(ProtobufDiscoveryNode node, String msg, Throwable cause) {
+        this(node, msg, null, cause);
+    }
+
+    public ProtobufConnectTransportException(ProtobufDiscoveryNode node, String msg, String action, Throwable cause) {
+        super(node == null ? null : node.getName(), node == null ? null : node.getAddress(), action, msg, cause);
+        this.node = node;
+    }
+
+    public ProtobufConnectTransportException(CodedInputStream in) throws IOException {
+        super(in);
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        node = protobufStreamInput.readOptionalWriteable(ProtobufDiscoveryNode::new);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        super.writeTo(out);
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeOptionalWriteable(node);
+    }
+
+    public ProtobufDiscoveryNode node() {
+        return node;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java b/server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java
new file mode 100644
index 0000000000000..8e94a43d53d37
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java
@@ -0,0 +1,114 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import org.opensearch.action.ActionListener;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+
+import java.io.Closeable;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+/**
+ * ProtobufTransport connection manager.
+*
+* @opensearch.internal
+*/
+public interface ProtobufConnectionManager extends Closeable {
+
+    void addListener(ProtobufTransportConnectionListener listener);
+
+    void removeListener(ProtobufTransportConnectionListener listener);
+
+    void openConnection(
+        ProtobufDiscoveryNode node,
+        ProtobufConnectionProfile connectionProfile,
+        ActionListener<ProtobufTransport.Connection> listener
+    );
+
+    void connectToNode(
+        ProtobufDiscoveryNode node,
+        ProtobufConnectionProfile connectionProfile,
+        ConnectionValidator connectionValidator,
+        ActionListener<Void> listener
+    ) throws ConnectTransportException;
+
+    ProtobufTransport.Connection getConnection(ProtobufDiscoveryNode node);
+
+    boolean nodeConnected(ProtobufDiscoveryNode node);
+
+    void disconnectFromNode(ProtobufDiscoveryNode node);
+
+    Set<ProtobufDiscoveryNode> getAllConnectedNodes();
+
+    int size();
+
+    @Override
+    void close();
+
+    void closeNoBlock();
+
+    ProtobufConnectionProfile getConnectionProfile();
+
+    /**
+     * Validates a connection
+    *
+    * @opensearch.internal
+    */
+    @FunctionalInterface
+    interface ConnectionValidator {
+        void validate(ProtobufTransport.Connection connection, ProtobufConnectionProfile profile, ActionListener<Void> listener);
+    }
+
+    /**
+     * Connection listener for a delegating node
+    *
+    * @opensearch.internal
+    */
+    final class DelegatingNodeConnectionListener implements ProtobufTransportConnectionListener {
+
+        private final CopyOnWriteArrayList<ProtobufTransportConnectionListener> listeners = new CopyOnWriteArrayList<>();
+
+        @Override
+        public void onNodeDisconnected(ProtobufDiscoveryNode key, ProtobufTransport.Connection connection) {
+            for (ProtobufTransportConnectionListener listener : listeners) {
+                listener.onNodeDisconnected(key, connection);
+            }
+        }
+
+        @Override
+        public void onNodeConnected(ProtobufDiscoveryNode node, ProtobufTransport.Connection connection) {
+            for (ProtobufTransportConnectionListener listener : listeners) {
+                listener.onNodeConnected(node, connection);
+            }
+        }
+
+        @Override
+        public void onConnectionOpened(ProtobufTransport.Connection connection) {
+            for (ProtobufTransportConnectionListener listener : listeners) {
+                listener.onConnectionOpened(connection);
+            }
+        }
+
+        @Override
+        public void onConnectionClosed(ProtobufTransport.Connection connection) {
+            for (ProtobufTransportConnectionListener listener : listeners) {
+                listener.onConnectionClosed(connection);
+            }
+        }
+
+        public void addListener(ProtobufTransportConnectionListener listener) {
+            listeners.addIfAbsent(listener);
+        }
+
+        public void removeListener(ProtobufTransportConnectionListener listener) {
+            listeners.remove(listener);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufConnectionProfile.java b/server/src/main/java/org/opensearch/transport/ProtobufConnectionProfile.java
new file mode 100644
index 0000000000000..a2e10d03bd189
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufConnectionProfile.java
@@ -0,0 +1,362 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * A connection profile describes how many connection are established to specific node for each of the available request types.
+* ({@link org.opensearch.transport.TransportRequestOptions.Type}). This allows to tailor a connection towards a specific usage.
+*
+* @opensearch.internal
+*/
+public final class ProtobufConnectionProfile {
+
+    /**
+     * takes a {@link ProtobufConnectionProfile} resolves it to a fully specified (i.e., no nulls) profile
+    */
+    public static ProtobufConnectionProfile resolveConnectionProfile(
+        @Nullable ProtobufConnectionProfile profile,
+        ProtobufConnectionProfile fallbackProfile
+    ) {
+        Objects.requireNonNull(fallbackProfile);
+        if (profile == null) {
+            return fallbackProfile;
+        } else if (profile.getConnectTimeout() != null
+            && profile.getHandshakeTimeout() != null
+            && profile.getPingInterval() != null
+            && profile.getCompressionEnabled() != null) {
+                return profile;
+            } else {
+                ProtobufConnectionProfile.Builder builder = new ProtobufConnectionProfile.Builder(profile);
+                if (profile.getConnectTimeout() == null) {
+                    builder.setConnectTimeout(fallbackProfile.getConnectTimeout());
+                }
+                if (profile.getHandshakeTimeout() == null) {
+                    builder.setHandshakeTimeout(fallbackProfile.getHandshakeTimeout());
+                }
+                if (profile.getPingInterval() == null) {
+                    builder.setPingInterval(fallbackProfile.getPingInterval());
+                }
+                if (profile.getCompressionEnabled() == null) {
+                    builder.setCompressionEnabled(fallbackProfile.getCompressionEnabled());
+                }
+                return builder.build();
+            }
+    }
+
+    /**
+     * Builds a default connection profile based on the provided settings.
+    *
+    * @param settings to build the connection profile from
+    * @return the connection profile
+    */
+    public static ProtobufConnectionProfile buildDefaultConnectionProfile(Settings settings) {
+        int connectionsPerNodeRecovery = TransportSettings.CONNECTIONS_PER_NODE_RECOVERY.get(settings);
+        int connectionsPerNodeBulk = TransportSettings.CONNECTIONS_PER_NODE_BULK.get(settings);
+        int connectionsPerNodeReg = TransportSettings.CONNECTIONS_PER_NODE_REG.get(settings);
+        int connectionsPerNodeState = TransportSettings.CONNECTIONS_PER_NODE_STATE.get(settings);
+        int connectionsPerNodePing = TransportSettings.CONNECTIONS_PER_NODE_PING.get(settings);
+        Builder builder = new Builder();
+        builder.setConnectTimeout(TransportSettings.CONNECT_TIMEOUT.get(settings));
+        builder.setHandshakeTimeout(TransportSettings.CONNECT_TIMEOUT.get(settings));
+        builder.setPingInterval(TransportSettings.PING_SCHEDULE.get(settings));
+        builder.setCompressionEnabled(TransportSettings.TRANSPORT_COMPRESS.get(settings));
+        builder.addConnections(connectionsPerNodeBulk, TransportRequestOptions.Type.BULK);
+        builder.addConnections(connectionsPerNodePing, TransportRequestOptions.Type.PING);
+        // if we are not cluster-manager eligible we don't need a dedicated channel to publish the state
+        builder.addConnections(
+            ProtobufDiscoveryNode.isClusterManagerNode(settings) ? connectionsPerNodeState : 0,
+            TransportRequestOptions.Type.STATE
+        );
+        // if we are not a data-node we don't need any dedicated channels for recovery
+        builder.addConnections(
+            ProtobufDiscoveryNode.isDataNode(settings) ? connectionsPerNodeRecovery : 0,
+            TransportRequestOptions.Type.RECOVERY
+        );
+        builder.addConnections(connectionsPerNodeReg, TransportRequestOptions.Type.REG);
+        return builder.build();
+    }
+
+    /**
+     * Builds a connection profile that is dedicated to a single channel type. Use this
+    * when opening single use connections
+    */
+    public static ProtobufConnectionProfile buildSingleChannelProfile(TransportRequestOptions.Type channelType) {
+        return buildSingleChannelProfile(channelType, null, null, null, null);
+    }
+
+    /**
+     * Builds a connection profile that is dedicated to a single channel type. Allows passing connection and
+    * handshake timeouts and compression settings.
+    */
+    public static ProtobufConnectionProfile buildSingleChannelProfile(
+        TransportRequestOptions.Type channelType,
+        @Nullable TimeValue connectTimeout,
+        @Nullable TimeValue handshakeTimeout,
+        @Nullable TimeValue pingInterval,
+        @Nullable Boolean compressionEnabled
+    ) {
+        Builder builder = new Builder();
+        builder.addConnections(1, channelType);
+        final EnumSet<TransportRequestOptions.Type> otherTypes = EnumSet.allOf(TransportRequestOptions.Type.class);
+        otherTypes.remove(channelType);
+        builder.addConnections(0, otherTypes.toArray(new TransportRequestOptions.Type[0]));
+        if (connectTimeout != null) {
+            builder.setConnectTimeout(connectTimeout);
+        }
+        if (handshakeTimeout != null) {
+            builder.setHandshakeTimeout(handshakeTimeout);
+        }
+        if (pingInterval != null) {
+            builder.setPingInterval(pingInterval);
+        }
+        if (compressionEnabled != null) {
+            builder.setCompressionEnabled(compressionEnabled);
+        }
+        return builder.build();
+    }
+
+    private final List<ConnectionTypeHandle> handles;
+    private final int numConnections;
+    private final TimeValue connectTimeout;
+    private final TimeValue handshakeTimeout;
+    private final TimeValue pingInterval;
+    private final Boolean compressionEnabled;
+
+    private ProtobufConnectionProfile(
+        List<ConnectionTypeHandle> handles,
+        int numConnections,
+        TimeValue connectTimeout,
+        TimeValue handshakeTimeout,
+        TimeValue pingInterval,
+        Boolean compressionEnabled
+    ) {
+        this.handles = handles;
+        this.numConnections = numConnections;
+        this.connectTimeout = connectTimeout;
+        this.handshakeTimeout = handshakeTimeout;
+        this.pingInterval = pingInterval;
+        this.compressionEnabled = compressionEnabled;
+    }
+
+    /**
+     * A builder to build a new {@link ProtobufConnectionProfile}
+    *
+    * @opensearch.internal
+    */
+    public static class Builder {
+        private final List<ConnectionTypeHandle> handles = new ArrayList<>();
+        private final Set<TransportRequestOptions.Type> addedTypes = EnumSet.noneOf(TransportRequestOptions.Type.class);
+        private int numConnections = 0;
+        private TimeValue connectTimeout;
+        private TimeValue handshakeTimeout;
+        private Boolean compressionEnabled;
+        private TimeValue pingInterval;
+
+        /** create an empty builder */
+        public Builder() {}
+
+        /** copy constructor, using another profile as a base */
+        public Builder(ProtobufConnectionProfile source) {
+            handles.addAll(source.getHandles());
+            numConnections = source.getNumConnections();
+            handles.forEach(th -> addedTypes.addAll(th.types));
+            connectTimeout = source.getConnectTimeout();
+            handshakeTimeout = source.getHandshakeTimeout();
+            compressionEnabled = source.getCompressionEnabled();
+            pingInterval = source.getPingInterval();
+        }
+
+        /**
+         * Sets a connect timeout for this connection profile
+        */
+        public Builder setConnectTimeout(TimeValue connectTimeout) {
+            if (connectTimeout.millis() < 0) {
+                throw new IllegalArgumentException("connectTimeout must be non-negative but was: " + connectTimeout);
+            }
+            this.connectTimeout = connectTimeout;
+            return this;
+        }
+
+        /**
+         * Sets a handshake timeout for this connection profile
+        */
+        public Builder setHandshakeTimeout(TimeValue handshakeTimeout) {
+            if (handshakeTimeout.millis() < 0) {
+                throw new IllegalArgumentException("handshakeTimeout must be non-negative but was: " + handshakeTimeout);
+            }
+            this.handshakeTimeout = handshakeTimeout;
+            return this;
+        }
+
+        /**
+         * Sets a ping interval for this connection profile
+        */
+        public Builder setPingInterval(TimeValue pingInterval) {
+            this.pingInterval = pingInterval;
+            return this;
+        }
+
+        /**
+         * Sets compression enabled for this connection profile
+        */
+        public Builder setCompressionEnabled(boolean compressionEnabled) {
+            this.compressionEnabled = compressionEnabled;
+            return this;
+        }
+
+        /**
+         * Adds a number of connections for one or more types. Each type can only be added once.
+        * @param numConnections the number of connections to use in the pool for the given connection types
+        * @param types a set of types that should share the given number of connections
+        */
+        public Builder addConnections(int numConnections, TransportRequestOptions.Type... types) {
+            if (types == null || types.length == 0) {
+                throw new IllegalArgumentException("types must not be null");
+            }
+            for (TransportRequestOptions.Type type : types) {
+                if (addedTypes.contains(type)) {
+                    throw new IllegalArgumentException("type [" + type + "] is already registered");
+                }
+            }
+            addedTypes.addAll(Arrays.asList(types));
+            handles.add(new ConnectionTypeHandle(this.numConnections, numConnections, EnumSet.copyOf(Arrays.asList(types))));
+            this.numConnections += numConnections;
+            return this;
+        }
+
+        /**
+         * Creates a new {@link ProtobufConnectionProfile} based on the added connections.
+        * @throws IllegalStateException if any of the {@link org.opensearch.transport.TransportRequestOptions.Type} enum is missing
+        */
+        public ProtobufConnectionProfile build() {
+            EnumSet<TransportRequestOptions.Type> types = EnumSet.allOf(TransportRequestOptions.Type.class);
+            types.removeAll(addedTypes);
+            if (types.isEmpty() == false) {
+                throw new IllegalStateException("not all types are added for this connection profile - missing types: " + types);
+            }
+            return new ProtobufConnectionProfile(
+                Collections.unmodifiableList(handles),
+                numConnections,
+                connectTimeout,
+                handshakeTimeout,
+                pingInterval,
+                compressionEnabled
+            );
+        }
+
+    }
+
+    /**
+     * Returns the connect timeout or <code>null</code> if no explicit timeout is set on this profile.
+    */
+    public TimeValue getConnectTimeout() {
+        return connectTimeout;
+    }
+
+    /**
+     * Returns the handshake timeout or <code>null</code> if no explicit timeout is set on this profile.
+    */
+    public TimeValue getHandshakeTimeout() {
+        return handshakeTimeout;
+    }
+
+    /**
+     * Returns the ping interval or <code>null</code> if no explicit ping interval is set on this profile.
+    */
+    public TimeValue getPingInterval() {
+        return pingInterval;
+    }
+
+    /**
+     * Returns boolean indicating if compression is enabled or <code>null</code> if no explicit compression
+    * is set on this profile.
+    */
+    public Boolean getCompressionEnabled() {
+        return compressionEnabled;
+    }
+
+    /**
+     * Returns the total number of connections for this profile
+    */
+    public int getNumConnections() {
+        return numConnections;
+    }
+
+    /**
+     * Returns the number of connections per type for this profile. This might return a count that is shared with other types such
+    * that the sum of all connections per type might be higher than {@link #getNumConnections()}. For instance if
+    * {@link org.opensearch.transport.TransportRequestOptions.Type#BULK} shares connections with
+    * {@link org.opensearch.transport.TransportRequestOptions.Type#REG} they will return both the same number of connections from
+    * this method but the connections are not distinct.
+    */
+    public int getNumConnectionsPerType(TransportRequestOptions.Type type) {
+        for (ConnectionTypeHandle handle : handles) {
+            if (handle.getTypes().contains(type)) {
+                return handle.length;
+            }
+        }
+        throw new AssertionError("no handle found for type: " + type);
+    }
+
+    /**
+     * Returns the type handles for this connection profile
+    */
+    List<ConnectionTypeHandle> getHandles() {
+        return Collections.unmodifiableList(handles);
+    }
+
+    /**
+     * Connection type handle encapsulates the logic which connection
+    */
+    static final class ConnectionTypeHandle {
+        public final int length;
+        public final int offset;
+        private final Set<TransportRequestOptions.Type> types;
+        private final AtomicInteger counter = new AtomicInteger();
+
+        private ConnectionTypeHandle(int offset, int length, Set<TransportRequestOptions.Type> types) {
+            this.length = length;
+            this.offset = offset;
+            this.types = types;
+        }
+
+        /**
+         * Returns one of the channels out configured for this handle. The channel is selected in a round-robin
+        * fashion.
+        */
+        <T> T getChannel(List<T> channels) {
+            if (length == 0) {
+                throw new IllegalStateException("can't select channel size is 0 for types: " + types);
+            }
+            assert channels.size() >= offset + length : "illegal size: " + channels.size() + " expected >= " + (offset + length);
+            return channels.get(offset + Math.floorMod(counter.incrementAndGet(), length));
+        }
+
+        /**
+         * Returns all types for this handle
+        */
+        Set<TransportRequestOptions.Type> getTypes() {
+            return types;
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java
new file mode 100644
index 0000000000000..53286266bb015
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java
@@ -0,0 +1,46 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import org.opensearch.threadpool.ThreadPool;
+
+/**
+ * Handler for empty transport response
+*
+* @opensearch.internal
+*/
+public class ProtobufEmptyTransportResponseHandler implements ProtobufTransportResponseHandler<ProtobufTransportResponse.Empty> {
+
+    public static final ProtobufEmptyTransportResponseHandler INSTANCE_SAME = new ProtobufEmptyTransportResponseHandler(
+        ThreadPool.Names.SAME
+    );
+
+    private final String executor;
+
+    public ProtobufEmptyTransportResponseHandler(String executor) {
+        this.executor = executor;
+    }
+
+    @Override
+    public ProtobufTransportResponse.Empty read(CodedInputStream in) {
+        return ProtobufTransportResponse.Empty.INSTANCE;
+    }
+
+    @Override
+    public void handleResponse(ProtobufTransportResponse.Empty response) {}
+
+    @Override
+    public void handleException(ProtobufTransportException exp) {}
+
+    @Override
+    public String executor() {
+        return executor;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufNetworkMessage.java b/server/src/main/java/org/opensearch/transport/ProtobufNetworkMessage.java
index 89fa327ecc0dd..489e7a42f767f 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufNetworkMessage.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufNetworkMessage.java
@@ -26,7 +26,7 @@ public abstract class ProtobufNetworkMessage {
     protected final byte status;
 
     ProtobufNetworkMessage(ThreadContext threadContext, Version version, byte status, long requestId) {
-        this.threadContext = (ProtobufWriteable) threadContext.captureAsWriteable();
+        this.threadContext = (ProtobufWriteable) threadContext.captureAsProtobufWriteable();
         this.version = version;
         this.requestId = requestId;
         this.status = status;
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufNodeDisconnectedException.java b/server/src/main/java/org/opensearch/transport/ProtobufNodeDisconnectedException.java
new file mode 100644
index 0000000000000..7a46892128218
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufNodeDisconnectedException.java
@@ -0,0 +1,37 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+
+import java.io.IOException;
+
+/**
+ * Exception thrown if a node disconnects
+*
+* @opensearch.internal
+*/
+public class ProtobufNodeDisconnectedException extends ProtobufConnectTransportException {
+
+    public ProtobufNodeDisconnectedException(ProtobufDiscoveryNode node, String action) {
+        super(node, "disconnected", action, null);
+    }
+
+    public ProtobufNodeDisconnectedException(CodedInputStream in) throws IOException {
+        super(in);
+    }
+
+    // stack trace is meaningless...
+
+    @Override
+    public Throwable fillInStackTrace() {
+        return this;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufNodeNotConnectedException.java b/server/src/main/java/org/opensearch/transport/ProtobufNodeNotConnectedException.java
new file mode 100644
index 0000000000000..9b90f26324fb3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufNodeNotConnectedException.java
@@ -0,0 +1,30 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+
+import java.io.IOException;
+
+/**
+ * An exception indicating that a message is sent to a node that is not connected.
+*
+* @opensearch.internal
+*/
+public class ProtobufNodeNotConnectedException extends ProtobufConnectTransportException {
+
+    public ProtobufNodeNotConnectedException(ProtobufDiscoveryNode node, String msg) {
+        super(node, msg, (String) null);
+    }
+
+    public ProtobufNodeNotConnectedException(CodedInputStream in) throws IOException {
+        super(in);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java b/server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java
new file mode 100644
index 0000000000000..e18057f7818df
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java
@@ -0,0 +1,281 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedOutputStream;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.Version;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.NotifyOnceListener;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.common.CheckedSupplier;
+import org.opensearch.common.bytes.BytesReference;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.lease.Releasables;
+import org.opensearch.common.network.CloseableChannel;
+import org.opensearch.common.transport.NetworkExceptionHelper;
+import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.threadpool.ProtobufThreadPool;
+
+import java.io.IOException;
+import java.util.Set;
+
+/**
+ * Outbound data handler
+*
+* @opensearch.internal
+*/
+final class ProtobufOutboundHandler {
+
+    private static final Logger logger = LogManager.getLogger(ProtobufOutboundHandler.class);
+
+    private final String nodeName;
+    private final Version version;
+    private final String[] features;
+    private final StatsTracker statsTracker;
+    private final ProtobufThreadPool threadPool;
+    // private final BigArrays bigArrays;
+    private final byte[] bytes;
+    private volatile ProtobufTransportMessageListener messageListener = ProtobufTransportMessageListener.NOOP_LISTENER;
+
+    ProtobufOutboundHandler(
+        String nodeName,
+        Version version,
+        String[] features,
+        StatsTracker statsTracker,
+        ProtobufThreadPool threadPool,
+        byte[] bytes
+    ) {
+        this.nodeName = nodeName;
+        this.version = version;
+        this.features = features;
+        this.statsTracker = statsTracker;
+        this.threadPool = threadPool;
+        this.bytes = bytes;
+    }
+
+    void sendBytes(TcpChannel channel, BytesReference bytes, ActionListener<Void> listener) {
+        SendContext sendContext = new SendContext(channel, () -> bytes, listener);
+        try {
+            internalSend(channel, sendContext);
+        } catch (IOException e) {
+            // This should not happen as the bytes are already serialized
+            throw new AssertionError(e);
+        }
+    }
+
+    /**
+     * Sends the request to the given channel. This method should be used to send {@link ProtobufTransportRequest}
+    * objects back to the caller.
+    */
+    void sendRequest(
+        final ProtobufDiscoveryNode node,
+        final TcpChannel channel,
+        final long requestId,
+        final String action,
+        final ProtobufTransportRequest request,
+        final TransportRequestOptions options,
+        final Version channelVersion,
+        final boolean compressRequest,
+        final boolean isHandshake
+    ) throws IOException, TransportException {
+        Version version = Version.min(this.version, channelVersion);
+        ProtobufOutboundMessage.Request message = new ProtobufOutboundMessage.Request(
+            threadPool.getThreadContext(),
+            features,
+            request,
+            version,
+            action,
+            requestId,
+            isHandshake,
+            compressRequest
+        );
+        ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onRequestSent(node, requestId, action, request, options));
+        sendMessage(channel, message, listener);
+    }
+
+    /**
+     * Sends the response to the given channel. This method should be used to send {@link ProtobufTransportResponse}
+    * objects back to the caller.
+    *
+    * @see #sendErrorResponse(Version, Set, TcpChannel, long, String, Exception) for sending error responses
+    */
+    void sendResponse(
+        final Version nodeVersion,
+        final Set<String> features,
+        final TcpChannel channel,
+        final long requestId,
+        final String action,
+        final ProtobufTransportResponse response,
+        final boolean compress,
+        final boolean isHandshake
+    ) throws IOException {
+        Version version = Version.min(this.version, nodeVersion);
+        ProtobufOutboundMessage.Response message = new ProtobufOutboundMessage.Response(
+            threadPool.getThreadContext(),
+            features,
+            response,
+            version,
+            requestId,
+            isHandshake,
+            compress
+        );
+        ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onResponseSent(requestId, action, response));
+        sendMessage(channel, message, listener);
+    }
+
+    /**
+     * Sends back an error response to the caller via the given channel
+    */
+    void sendErrorResponse(
+        final Version nodeVersion,
+        final Set<String> features,
+        final TcpChannel channel,
+        final long requestId,
+        final String action,
+        final Exception error
+    ) throws IOException {
+        Version version = Version.min(this.version, nodeVersion);
+        ProtobufTransportAddress address = new ProtobufTransportAddress(channel.getLocalAddress());
+        ProtobufRemoteTransportException tx = new ProtobufRemoteTransportException(nodeName, address, action, error);
+        ProtobufOutboundMessage.Response message = new ProtobufOutboundMessage.Response(
+            threadPool.getThreadContext(),
+            features,
+            tx,
+            version,
+            requestId,
+            false,
+            false
+        );
+        ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onResponseSent(requestId, action, error));
+        sendMessage(channel, message, listener);
+    }
+
+    private void sendMessage(TcpChannel channel, ProtobufOutboundMessage networkMessage, ActionListener<Void> listener) throws IOException {
+        MessageSerializer serializer = new MessageSerializer(networkMessage, bytes);
+        SendContext sendContext = new SendContext(channel, serializer, listener, serializer);
+        internalSend(channel, sendContext);
+    }
+
+    private void internalSend(TcpChannel channel, SendContext sendContext) throws IOException {
+        channel.getChannelStats().markAccessed(threadPool.relativeTimeInMillis());
+        BytesReference reference = sendContext.get();
+        // stash thread context so that channel event loop is not polluted by thread context
+        try (ThreadContext.StoredContext existing = threadPool.getThreadContext().stashContext()) {
+            channel.sendMessage(reference, sendContext);
+        } catch (RuntimeException ex) {
+            sendContext.onFailure(ex);
+            CloseableChannel.closeChannel(channel);
+            throw ex;
+        }
+    }
+
+    void setMessageListener(ProtobufTransportMessageListener listener) {
+        if (messageListener == ProtobufTransportMessageListener.NOOP_LISTENER) {
+            messageListener = listener;
+        } else {
+            throw new IllegalStateException("Cannot set message listener twice");
+        }
+    }
+
+    /**
+     * Internal message serializer
+    *
+    * @opensearch.internal
+    */
+    private static class MessageSerializer implements CheckedSupplier<BytesReference, IOException>, Releasable {
+
+        private final ProtobufOutboundMessage message;
+        private byte[] bytes;
+        // private final BigArrays bigArrays;
+        // private volatile ReleasableBytesStreamOutput bytesStreamOutput;
+
+        private MessageSerializer(ProtobufOutboundMessage message, byte[] bytes) {
+            this.message = message;
+            this.bytes = bytes;
+        }
+
+        @Override
+        public BytesReference get() throws IOException {
+            CodedOutputStream out = CodedOutputStream.newInstance(bytes);
+            return message.serialize(out, bytes);
+        }
+
+        @Override
+        public void close() {
+            // IOUtils.closeWhileHandlingException(bytesStreamOutput);
+        }
+    }
+
+    private class SendContext extends NotifyOnceListener<Void> implements CheckedSupplier<BytesReference, IOException> {
+
+        private final TcpChannel channel;
+        private final CheckedSupplier<BytesReference, IOException> messageSupplier;
+        private final ActionListener<Void> listener;
+        private final Releasable optionalReleasable;
+        private long messageSize = -1;
+
+        private SendContext(
+            TcpChannel channel,
+            CheckedSupplier<BytesReference, IOException> messageSupplier,
+            ActionListener<Void> listener
+        ) {
+            this(channel, messageSupplier, listener, null);
+        }
+
+        private SendContext(
+            TcpChannel channel,
+            CheckedSupplier<BytesReference, IOException> messageSupplier,
+            ActionListener<Void> listener,
+            Releasable optionalReleasable
+        ) {
+            this.channel = channel;
+            this.messageSupplier = messageSupplier;
+            this.listener = listener;
+            this.optionalReleasable = optionalReleasable;
+        }
+
+        public BytesReference get() throws IOException {
+            BytesReference message;
+            try {
+                message = messageSupplier.get();
+                messageSize = message.length();
+                TransportLogger.logOutboundMessage(channel, message);
+                return message;
+            } catch (Exception e) {
+                onFailure(e);
+                throw e;
+            }
+        }
+
+        @Override
+        protected void innerOnResponse(Void v) {
+            assert messageSize != -1 : "If onResponse is being called, the message should have been serialized";
+            statsTracker.markBytesWritten(messageSize);
+            closeAndCallback(() -> listener.onResponse(v));
+        }
+
+        @Override
+        protected void innerOnFailure(Exception e) {
+            if (NetworkExceptionHelper.isCloseConnectionException(e)) {
+                logger.debug(() -> new ParameterizedMessage("send message failed [channel: {}]", channel), e);
+            } else {
+                logger.warn(() -> new ParameterizedMessage("send message failed [channel: {}]", channel), e);
+            }
+            closeAndCallback(() -> listener.onFailure(e));
+        }
+
+        private void closeAndCallback(Runnable runnable) {
+            Releasables.close(optionalReleasable, runnable::run);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java b/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
index 0bfc14e93d7da..a2f5fb571a1f8 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
@@ -12,14 +12,12 @@
 import org.opensearch.Version;
 import org.opensearch.common.bytes.BytesArray;
 import org.opensearch.common.bytes.BytesReference;
-import org.opensearch.common.bytes.CompositeBytesReference;
-import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.StreamOutput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.util.concurrent.ThreadContext;
 
 import java.io.IOException;
+import java.nio.ByteBuffer;
 import java.util.Set;
 
 /**
@@ -36,31 +34,35 @@ abstract class ProtobufOutboundMessage extends ProtobufNetworkMessage {
         this.message = message;
     }
 
-    BytesReference serialize(CodedOutputStream bytesStream) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput();
+    BytesReference serialize(CodedOutputStream out, byte[] bytes) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         protobufStreamOutput.setVersion(version);
         // bytesStream.skip(TcpHeader.headerSize(version));
 
         // The compressible bytes stream will not close the underlying bytes stream
         BytesReference reference;
         int variableHeaderLength = -1;
-        final long preHeaderPosition = bytesStream.position();
-        writeVariableHeader(bytesStream);
-        variableHeaderLength = Math.toIntExact(bytesStream.position() - preHeaderPosition);
+        // final long preHeaderPosition = out.position();
+        writeVariableHeader(out);
+        // variableHeaderLength = Math.toIntExact(out.position() - preHeaderPosition);
 
-        try (CompressibleBytesOutputStream stream = new CompressibleBytesOutputStream(bytesStream, TransportStatus.isCompress(status))) {
-            stream.setVersion(version);
-            stream.setFeatures(bytesStream.getFeatures());
-
-            if (variableHeaderLength == -1) {
-                writeVariableHeader(stream);
-            }
-            reference = writeMessage(stream);
+        if (TransportStatus.isCompress(status)) {
+            protobufStreamOutput.setVersion(version);
+            protobufStreamOutput.setFeatures(protobufStreamOutput.getFeatures());
         }
+        // try (CompressibleBytesOutputStream stream = new CompressibleBytesOutputStream(out, TransportStatus.isCompress(status))) {
+        // stream.setVersion(version);
+        // stream.setFeatures(out.getFeatures());
+
+        // if (variableHeaderLength == -1) {
+        // writeVariableHeader(stream);
+        // }
+        reference = writeMessage(out, bytes);
+        // }
 
-        bytesStream.seek(0);
+        // out.seek(0);
         final int contentSize = reference.length() - TcpHeader.headerSize(version);
-        TcpHeader.writeHeader(bytesStream, requestId, status, version, contentSize, variableHeaderLength);
+        TcpHeader.writeHeaderProtobuf(out, requestId, status, version, contentSize, variableHeaderLength);
         return reference;
     }
 
@@ -68,14 +70,14 @@ protected void writeVariableHeader(CodedOutputStream stream) throws IOException
         threadContext.writeTo(stream);
     }
 
-    protected BytesReference writeMessage(CompressibleBytesOutputStream stream) throws IOException {
+    protected BytesReference writeMessage(CodedOutputStream stream, byte[] bytes) throws IOException {
         final BytesReference zeroCopyBuffer;
-        if (message instanceof BytesTransportRequest) {
-            BytesTransportRequest bRequest = (BytesTransportRequest) message;
+        if (message instanceof ProtobufBytesTransportRequest) {
+            ProtobufBytesTransportRequest bRequest = (ProtobufBytesTransportRequest) message;
             bRequest.writeThin(stream);
             zeroCopyBuffer = bRequest.bytes;
-        } else if (message instanceof RemoteTransportException) {
-            stream.writeException((RemoteTransportException) message);
+        } else if (message instanceof ProtobufRemoteTransportException) {
+            // stream.writeStringNoTag((ProtobufRemoteTransportException) message.toString());
             zeroCopyBuffer = BytesArray.EMPTY;
         } else {
             message.writeTo(stream);
@@ -86,12 +88,14 @@ protected BytesReference writeMessage(CompressibleBytesOutputStream stream) thro
         // are written. Otherwise we barf on the decompressing end when we read past EOF on purpose in the
         // #validateRequest method. this might be a problem in deflate after all but it's important to write
         // the marker bytes.
-        final BytesReference message = stream.materializeBytes();
-        if (zeroCopyBuffer.length() == 0) {
-            return message;
-        } else {
-            return CompositeBytesReference.of(message, zeroCopyBuffer);
-        }
+        ByteBuffer byteBuffer = ByteBuffer.wrap(bytes);
+        final BytesReference message = BytesReference.fromByteBuffer(byteBuffer);
+        // if (zeroCopyBuffer.length() == 0) {
+        // return message;
+        // } else {
+        // return CompositeBytesReference.of(message, zeroCopyBuffer);
+        // }
+        return message;
     }
 
     /**
@@ -120,10 +124,11 @@ static class Request extends ProtobufOutboundMessage {
         }
 
         @Override
-        protected void writeVariableHeader(StreamOutput stream) throws IOException {
-            super.writeVariableHeader(stream);
-            stream.writeStringArray(features);
-            stream.writeString(action);
+        protected void writeVariableHeader(CodedOutputStream out) throws IOException {
+            super.writeVariableHeader(out);
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+            protobufStreamOutput.writeStringArray(features);
+            out.writeStringNoTag(action);
         }
 
         private static byte setStatus(boolean compress, boolean isHandshake, ProtobufWriteable message) {
@@ -163,9 +168,10 @@ static class Response extends ProtobufOutboundMessage {
         }
 
         @Override
-        protected void writeVariableHeader(StreamOutput stream) throws IOException {
-            super.writeVariableHeader(stream);
-            stream.setFeatures(features);
+        protected void writeVariableHeader(CodedOutputStream out) throws IOException {
+            super.writeVariableHeader(out);
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+            protobufStreamOutput.setFeatures(features);
         }
 
         private static byte setStatus(boolean compress, boolean isHandshake, ProtobufWriteable message) {
@@ -186,6 +192,6 @@ private static byte setStatus(boolean compress, boolean isHandshake, ProtobufWri
     }
 
     private static boolean canCompress(ProtobufWriteable message) {
-        return message instanceof BytesTransportRequest == false;
+        return message instanceof ProtobufBytesTransportRequest == false;
     }
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufPlainTransportFuture.java b/server/src/main/java/org/opensearch/transport/ProtobufPlainTransportFuture.java
new file mode 100644
index 0000000000000..259840e96126e
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufPlainTransportFuture.java
@@ -0,0 +1,103 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import org.opensearch.OpenSearchException;
+import org.opensearch.OpenSearchTimeoutException;
+import org.opensearch.common.util.concurrent.BaseFuture;
+
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/**
+ * Future for transporting data
+*
+* @opensearch.internal
+*/
+public class ProtobufPlainTransportFuture<V extends ProtobufTransportResponse> extends BaseFuture<V>
+    implements
+        TransportFuture<V>,
+        ProtobufTransportResponseHandler<V> {
+
+    private final ProtobufTransportResponseHandler<V> handler;
+
+    public ProtobufPlainTransportFuture(ProtobufTransportResponseHandler<V> handler) {
+        this.handler = handler;
+    }
+
+    @Override
+    public V txGet() {
+        try {
+            return get();
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new IllegalStateException("Future got interrupted", e);
+        } catch (ExecutionException e) {
+            if (e.getCause() instanceof OpenSearchException) {
+                throw (OpenSearchException) e.getCause();
+            } else {
+                throw new ProtobufTransportException("Failed execution", e);
+            }
+        }
+    }
+
+    @Override
+    public V txGet(long timeout, TimeUnit unit) {
+        try {
+            return get(timeout, unit);
+        } catch (TimeoutException e) {
+            throw new OpenSearchTimeoutException(e);
+        } catch (InterruptedException e) {
+            throw new IllegalStateException("Future got interrupted", e);
+        } catch (ExecutionException e) {
+            if (e.getCause() instanceof OpenSearchException) {
+                throw (OpenSearchException) e.getCause();
+            } else {
+                throw new ProtobufTransportException("Failed execution", e);
+            }
+        }
+    }
+
+    @Override
+    public V read(CodedInputStream in) throws IOException {
+        return handler.read(in);
+    }
+
+    @Override
+    public String executor() {
+        return handler.executor();
+    }
+
+    @Override
+    public void handleResponse(V response) {
+        try {
+            handler.handleResponse(response);
+            set(response);
+        } catch (Exception e) {
+            handleException(new ProtobufTransportException(e));
+        }
+    }
+
+    @Override
+    public void handleException(ProtobufTransportException exp) {
+        try {
+            handler.handleException(exp);
+        } finally {
+            setException(exp);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "future(" + handler.toString() + ")";
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufProxyConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/ProtobufProxyConnectionStrategy.java
new file mode 100644
index 0000000000000..52fa5f55ad1ff
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufProxyConnectionStrategy.java
@@ -0,0 +1,414 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.Version;
+import org.opensearch.action.ActionListener;
+import org.opensearch.cluster.ProtobufClusterName;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
+import org.opensearch.common.Strings;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.common.util.concurrent.CountDown;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+import static org.opensearch.common.settings.Setting.intSetting;
+
+/**
+ * Connect through a proxy
+*
+* @opensearch.internal
+*/
+public class ProtobufProxyConnectionStrategy extends ProtobufRemoteConnectionStrategy {
+
+    /**
+     * The remote address for the proxy. The connections will be opened to the configured address.
+    */
+    public static final Setting.AffixSetting<String> PROXY_ADDRESS = Setting.affixKeySetting(
+        "cluster.remote.",
+        "proxy_address",
+        (ns, key) -> Setting.simpleString(key, new StrategyValidator<>(ns, key, ProtobufConnectionStrategy.PROXY, s -> {
+            if (Strings.hasLength(s)) {
+                parsePort(s);
+            }
+        }), Setting.Property.Dynamic, Setting.Property.NodeScope)
+    );
+
+    /**
+     * The maximum number of socket connections that will be established to a remote cluster. The default is 18.
+    */
+    public static final Setting.AffixSetting<Integer> REMOTE_SOCKET_CONNECTIONS = Setting.affixKeySetting(
+        "cluster.remote.",
+        "proxy_socket_connections",
+        (ns, key) -> intSetting(
+            key,
+            18,
+            1,
+            new StrategyValidator<>(ns, key, ProtobufConnectionStrategy.PROXY),
+            Setting.Property.Dynamic,
+            Setting.Property.NodeScope
+        )
+    );
+
+    /**
+     * A configurable server_name attribute
+    */
+    public static final Setting.AffixSetting<String> SERVER_NAME = Setting.affixKeySetting(
+        "cluster.remote.",
+        "server_name",
+        (ns, key) -> Setting.simpleString(
+            key,
+            new StrategyValidator<>(ns, key, ProtobufConnectionStrategy.PROXY),
+            Setting.Property.Dynamic,
+            Setting.Property.NodeScope
+        )
+    );
+
+    static final int CHANNELS_PER_CONNECTION = 1;
+
+    private static final int MAX_CONNECT_ATTEMPTS_PER_RUN = 3;
+
+    private final int maxNumConnections;
+    private final String configuredAddress;
+    private final String configuredServerName;
+    private final Supplier<ProtobufTransportAddress> address;
+    private final AtomicReference<ProtobufClusterName> remoteClusterName = new AtomicReference<>();
+    private final ProtobufConnectionManager.ConnectionValidator clusterNameValidator;
+
+    ProtobufProxyConnectionStrategy(
+        String clusterAlias,
+        ProtobufTransportService transportService,
+        ProtobufRemoteConnectionManager connectionManager,
+        Settings settings
+    ) {
+        this(
+            clusterAlias,
+            transportService,
+            connectionManager,
+            settings,
+            REMOTE_SOCKET_CONNECTIONS.getConcreteSettingForNamespace(clusterAlias).get(settings),
+            PROXY_ADDRESS.getConcreteSettingForNamespace(clusterAlias).get(settings),
+            SERVER_NAME.getConcreteSettingForNamespace(clusterAlias).get(settings)
+        );
+    }
+
+    ProtobufProxyConnectionStrategy(
+        String clusterAlias,
+        ProtobufTransportService transportService,
+        ProtobufRemoteConnectionManager connectionManager,
+        Settings settings,
+        int maxNumConnections,
+        String configuredAddress
+    ) {
+        this(
+            clusterAlias,
+            transportService,
+            connectionManager,
+            settings,
+            maxNumConnections,
+            configuredAddress,
+            () -> resolveAddress(configuredAddress),
+            null
+        );
+    }
+
+    ProtobufProxyConnectionStrategy(
+        String clusterAlias,
+        ProtobufTransportService transportService,
+        ProtobufRemoteConnectionManager connectionManager,
+        Settings settings,
+        int maxNumConnections,
+        String configuredAddress,
+        String configuredServerName
+    ) {
+        this(
+            clusterAlias,
+            transportService,
+            connectionManager,
+            settings,
+            maxNumConnections,
+            configuredAddress,
+            () -> resolveAddress(configuredAddress),
+            configuredServerName
+        );
+    }
+
+    ProtobufProxyConnectionStrategy(
+        String clusterAlias,
+        ProtobufTransportService transportService,
+        ProtobufRemoteConnectionManager connectionManager,
+        Settings settings,
+        int maxNumConnections,
+        String configuredAddress,
+        Supplier<ProtobufTransportAddress> address,
+        String configuredServerName
+    ) {
+        super(clusterAlias, transportService, connectionManager, settings);
+        this.maxNumConnections = maxNumConnections;
+        this.configuredAddress = configuredAddress;
+        this.configuredServerName = configuredServerName;
+        assert Strings.isEmpty(configuredAddress) == false : "Cannot use proxy connection strategy with no configured addresses";
+        this.address = address;
+        this.clusterNameValidator = (newConnection, actualProfile, listener) -> transportService.handshake(
+            newConnection,
+            actualProfile.getHandshakeTimeout().millis(),
+            cn -> true,
+            ActionListener.map(listener, resp -> {
+                ProtobufClusterName remote = resp.getClusterName();
+                if (remoteClusterName.compareAndSet(null, remote)) {
+                    return null;
+                } else {
+                    if (remoteClusterName.get().equals(remote) == false) {
+                        ProtobufDiscoveryNode node = newConnection.getNode();
+                        throw new ProtobufConnectTransportException(node, "handshake failed. unexpected remote cluster name " + remote);
+                    }
+                    return null;
+                }
+            })
+        );
+    }
+
+    static Stream<Setting.AffixSetting<?>> enablementSettings() {
+        return Stream.of(ProxyConnectionStrategy.PROXY_ADDRESS);
+    }
+
+    static ProtobufWriteable.Reader<ProtobufRemoteConnectionInfo.ModeInfo> infoReader() {
+        return ProxyModeInfo::new;
+    }
+
+    @Override
+    protected boolean shouldOpenMoreConnections() {
+        return connectionManager.size() < maxNumConnections;
+    }
+
+    @Override
+    protected boolean strategyMustBeRebuilt(Settings newSettings) {
+        String address = PROXY_ADDRESS.getConcreteSettingForNamespace(clusterAlias).get(newSettings);
+        int numOfSockets = REMOTE_SOCKET_CONNECTIONS.getConcreteSettingForNamespace(clusterAlias).get(newSettings);
+        String serverName = SERVER_NAME.getConcreteSettingForNamespace(clusterAlias).get(newSettings);
+        return numOfSockets != maxNumConnections
+            || configuredAddress.equals(address) == false
+            || Objects.equals(serverName, configuredServerName) == false;
+    }
+
+    @Override
+    protected ProtobufConnectionStrategy strategyType() {
+        return ProtobufConnectionStrategy.PROXY;
+    }
+
+    @Override
+    protected void connectImpl(ActionListener<Void> listener) {
+        performProxyConnectionProcess(listener);
+    }
+
+    @Override
+    public ProtobufRemoteConnectionInfo.ModeInfo getModeInfo() {
+        return new ProxyModeInfo(configuredAddress, configuredServerName, maxNumConnections, connectionManager.size());
+    }
+
+    private void performProxyConnectionProcess(ActionListener<Void> listener) {
+        openConnections(listener, 1);
+    }
+
+    private void openConnections(ActionListener<Void> finished, int attemptNumber) {
+        if (attemptNumber <= MAX_CONNECT_ATTEMPTS_PER_RUN) {
+            ProtobufTransportAddress resolved = address.get();
+
+            int remaining = maxNumConnections - connectionManager.size();
+            ActionListener<Void> compositeListener = new ActionListener<Void>() {
+
+                private final AtomicInteger successfulConnections = new AtomicInteger(0);
+                private final CountDown countDown = new CountDown(remaining);
+
+                @Override
+                public void onResponse(Void v) {
+                    successfulConnections.incrementAndGet();
+                    if (countDown.countDown()) {
+                        if (shouldOpenMoreConnections()) {
+                            openConnections(finished, attemptNumber + 1);
+                        } else {
+                            finished.onResponse(v);
+                        }
+                    }
+                }
+
+                @Override
+                public void onFailure(Exception e) {
+                    if (countDown.countDown()) {
+                        openConnections(finished, attemptNumber + 1);
+                    }
+                }
+            };
+
+            for (int i = 0; i < remaining; ++i) {
+                String id = clusterAlias + "#" + resolved;
+                Map<String, String> attributes;
+                if (Strings.isNullOrEmpty(configuredServerName)) {
+                    attributes = Collections.emptyMap();
+                } else {
+                    attributes = Collections.singletonMap("server_name", configuredServerName);
+                }
+                ProtobufDiscoveryNode node = new ProtobufDiscoveryNode(
+                    id,
+                    resolved,
+                    attributes,
+                    DiscoveryNodeRole.BUILT_IN_ROLES,
+                    Version.CURRENT.minimumCompatibilityVersion()
+                );
+
+                connectionManager.connectToNode(node, null, clusterNameValidator, new ActionListener<Void>() {
+                    @Override
+                    public void onResponse(Void v) {
+                        compositeListener.onResponse(v);
+                    }
+
+                    @Override
+                    public void onFailure(Exception e) {
+                        logger.debug(
+                            new ParameterizedMessage(
+                                "failed to open remote connection [remote cluster: {}, address: {}]",
+                                clusterAlias,
+                                resolved
+                            ),
+                            e
+                        );
+                        compositeListener.onFailure(e);
+                    }
+                });
+            }
+        } else {
+            int openConnections = connectionManager.size();
+            if (openConnections == 0) {
+                finished.onFailure(
+                    new IllegalStateException("Unable to open any proxy connections to remote cluster [" + clusterAlias + "]")
+                );
+            } else {
+                logger.debug(
+                    "unable to open maximum number of connections [remote cluster: {}, opened: {}, maximum: {}]",
+                    clusterAlias,
+                    openConnections,
+                    maxNumConnections
+                );
+                finished.onResponse(null);
+            }
+        }
+    }
+
+    private static ProtobufTransportAddress resolveAddress(String address) {
+        return new ProtobufTransportAddress(parseConfiguredAddress(address));
+    }
+
+    /**
+     * Contains information about the proxy mode
+    *
+    * @opensearch.internal
+    */
+    public static class ProxyModeInfo implements ProtobufRemoteConnectionInfo.ModeInfo {
+
+        private final String address;
+        private final String serverName;
+        private final int maxSocketConnections;
+        private final int numSocketsConnected;
+
+        public ProxyModeInfo(String address, String serverName, int maxSocketConnections, int numSocketsConnected) {
+            this.address = address;
+            this.serverName = serverName;
+            this.maxSocketConnections = maxSocketConnections;
+            this.numSocketsConnected = numSocketsConnected;
+        }
+
+        private ProxyModeInfo(CodedInputStream input) throws IOException {
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(input);
+            address = input.readString();
+            serverName = input.readString();
+            maxSocketConnections = protobufStreamInput.readVInt();
+            numSocketsConnected = protobufStreamInput.readVInt();
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.field("proxy_address", address);
+            builder.field("server_name", serverName);
+            builder.field("num_proxy_sockets_connected", numSocketsConnected);
+            builder.field("max_proxy_socket_connections", maxSocketConnections);
+            return builder;
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeStringNoTag(address);
+            out.writeStringNoTag(serverName);
+            out.writeInt32NoTag(maxSocketConnections);
+            out.writeInt32NoTag(numSocketsConnected);
+        }
+
+        @Override
+        public boolean isConnected() {
+            return numSocketsConnected > 0;
+        }
+
+        @Override
+        public String modeName() {
+            return "proxy";
+        }
+
+        public String getAddress() {
+            return address;
+        }
+
+        public String getServerName() {
+            return serverName;
+        }
+
+        public int getMaxSocketConnections() {
+            return maxSocketConnections;
+        }
+
+        public int getNumSocketsConnected() {
+            return numSocketsConnected;
+        }
+
+        @Override
+        public ProtobufRemoteConnectionStrategy.ProtobufConnectionStrategy modeType() {
+            return ProtobufRemoteConnectionStrategy.ProtobufConnectionStrategy.PROXY;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            ProxyModeInfo otherProxy = (ProxyModeInfo) o;
+            return maxSocketConnections == otherProxy.maxSocketConnections
+                && numSocketsConnected == otherProxy.numSocketsConnected
+                && Objects.equals(address, otherProxy.address)
+                && Objects.equals(serverName, otherProxy.serverName);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(address, serverName, maxSocketConnections, numSocketsConnected);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufReceiveTimeoutTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufReceiveTimeoutTransportException.java
new file mode 100644
index 0000000000000..28fb5baa28b2b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufReceiveTimeoutTransportException.java
@@ -0,0 +1,31 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+
+import java.io.IOException;
+
+/**
+ * Thrown when receiving a timeout
+*
+* @opensearch.internal
+*/
+public class ProtobufReceiveTimeoutTransportException extends ProtobufActionTransportException {
+
+    public ProtobufReceiveTimeoutTransportException(ProtobufDiscoveryNode node, String action, String msg) {
+        super(node.getName(), node.getAddress(), action, msg, null);
+    }
+
+    public ProtobufReceiveTimeoutTransportException(CodedInputStream in) throws IOException {
+        super(in);
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java
new file mode 100644
index 0000000000000..c400597c97d4f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java
@@ -0,0 +1,78 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import org.opensearch.action.ProtobufActionType;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.ProtobufActionListenerResponseHandler;
+import org.opensearch.action.ProtobufActionRequest;
+import org.opensearch.action.ProtobufActionResponse;
+import org.opensearch.client.ProtobufClient;
+import org.opensearch.client.support.ProtobufAbstractClient;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.threadpool.ProtobufThreadPool;
+
+/**
+ * ProtobufClient that is aware of remote clusters
+*
+* @opensearch.internal
+*/
+final class ProtobufRemoteClusterAwareClient extends ProtobufAbstractClient {
+
+    private final ProtobufTransportService service;
+    private final String clusterAlias;
+    private final ProtobufRemoteClusterService remoteClusterService;
+
+    ProtobufRemoteClusterAwareClient(
+        Settings settings,
+        ProtobufThreadPool threadPool,
+        ProtobufTransportService service,
+        String clusterAlias
+    ) {
+        super(settings, threadPool);
+        this.service = service;
+        this.clusterAlias = clusterAlias;
+        this.remoteClusterService = service.getRemoteClusterService();
+    }
+
+    @Override
+    protected <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> void doExecute(
+        ProtobufActionType<Response> action,
+        Request request,
+        ActionListener<Response> listener
+    ) {
+        remoteClusterService.ensureConnected(clusterAlias, ActionListener.wrap(v -> {
+            ProtobufTransport.Connection connection;
+            if (request instanceof ProtobufRemoteClusterAwareRequest) {
+                ProtobufDiscoveryNode preferredTargetNode = ((ProtobufRemoteClusterAwareRequest) request).getPreferredTargetNode();
+                connection = remoteClusterService.getConnection(preferredTargetNode, clusterAlias);
+            } else {
+                connection = remoteClusterService.getConnection(clusterAlias);
+            }
+            service.sendRequest(
+                connection,
+                action.name(),
+                request,
+                TransportRequestOptions.EMPTY,
+                new ProtobufActionListenerResponseHandler<>(listener, action.getResponseReader())
+            );
+        }, listener::onFailure));
+    }
+
+    @Override
+    public void close() {
+        // do nothing
+    }
+
+    @Override
+    public ProtobufClient getRemoteClusterClient(String clusterAlias) {
+        return remoteClusterService.getRemoteClusterClient(threadPool(), clusterAlias);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareRequest.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareRequest.java
new file mode 100644
index 0000000000000..80576bd9608bf
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareRequest.java
@@ -0,0 +1,29 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+
+/**
+ * Request for remote clusters
+*
+* @opensearch.internal
+*/
+public interface ProtobufRemoteClusterAwareRequest {
+
+    /**
+     * Returns the preferred discovery node for this request. The remote cluster client will attempt to send
+    * this request directly to this node. Otherwise, it will send the request as a proxy action that will
+    * be routed by the remote cluster to this node.
+    *
+    * @return preferred discovery node
+    */
+    ProtobufDiscoveryNode getPreferredTargetNode();
+
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
new file mode 100644
index 0000000000000..58d90365f0ef5
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
@@ -0,0 +1,229 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.admin.cluster.state.ClusterStateAction;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
+import org.opensearch.action.support.ContextPreservingActionListener;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.threadpool.ProtobufThreadPool;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.function.Function;
+
+/**
+ * Represents a connection to a single remote cluster. In contrast to a local cluster a remote cluster is not joined such that the
+* current node is part of the cluster and it won't receive cluster state updates from the remote cluster. Remote clusters are also not
+* fully connected with the current node. From a connection perspective a local cluster forms a bi-directional star network while in the
+* remote case we only connect to a subset of the nodes in the cluster in an uni-directional fashion.
+*
+* This class also handles the discovery of nodes from the remote cluster. The initial list of seed nodes is only used to discover all nodes
+* in the remote cluster and connects to all eligible nodes, for details see {@link RemoteClusterService#REMOTE_NODE_ATTRIBUTE}.
+*
+* In the case of a disconnection, this class will issue a re-connect task to establish at most
+* {@link SniffConnectionStrategy#REMOTE_CONNECTIONS_PER_CLUSTER} until either all eligible nodes are exhausted or the maximum number of
+* connections per cluster has been reached.
+*
+* @opensearch.internal
+*/
+final class ProtobufRemoteClusterConnection implements Closeable {
+
+    private final ProtobufTransportService transportService;
+    private final ProtobufRemoteConnectionManager remoteConnectionManager;
+    private final ProtobufRemoteConnectionStrategy connectionStrategy;
+    private final String clusterAlias;
+    private final ProtobufThreadPool threadPool;
+    private volatile boolean skipUnavailable;
+    private final TimeValue initialConnectionTimeout;
+
+    /**
+     * Creates a new {@link ProtobufRemoteClusterConnection}
+    * @param settings the nodes settings object
+    * @param clusterAlias the configured alias of the cluster to connect to
+    * @param transportService the local nodes transport service
+    */
+    ProtobufRemoteClusterConnection(Settings settings, String clusterAlias, ProtobufTransportService transportService) {
+        this.transportService = transportService;
+        this.clusterAlias = clusterAlias;
+        ProtobufConnectionProfile profile = ProtobufRemoteConnectionStrategy.buildConnectionProfile(clusterAlias, settings);
+        this.remoteConnectionManager = new ProtobufRemoteConnectionManager(
+            clusterAlias,
+            createConnectionManager(profile, transportService)
+        );
+        this.connectionStrategy = ProtobufRemoteConnectionStrategy.buildStrategy(
+            clusterAlias,
+            transportService,
+            remoteConnectionManager,
+            settings
+        );
+        // we register the transport service here as a listener to make sure we notify handlers on disconnect etc.
+        this.remoteConnectionManager.addListener(transportService);
+        this.skipUnavailable = RemoteClusterService.REMOTE_CLUSTER_SKIP_UNAVAILABLE.getConcreteSettingForNamespace(clusterAlias)
+            .get(settings);
+        this.threadPool = transportService.threadPool;
+        initialConnectionTimeout = RemoteClusterService.REMOTE_INITIAL_CONNECTION_TIMEOUT_SETTING.get(settings);
+    }
+
+    /**
+     * Updates the skipUnavailable flag that can be dynamically set for each remote cluster
+    */
+    void updateSkipUnavailable(boolean skipUnavailable) {
+        this.skipUnavailable = skipUnavailable;
+    }
+
+    /**
+     * Returns whether this cluster is configured to be skipped when unavailable
+    */
+    boolean isSkipUnavailable() {
+        return skipUnavailable;
+    }
+
+    /**
+     * Ensures that this cluster is connected. If the cluster is connected this operation
+    * will invoke the listener immediately.
+    */
+    void ensureConnected(ActionListener<Void> listener) {
+        if (remoteConnectionManager.size() == 0) {
+            connectionStrategy.connect(listener);
+        } else {
+            listener.onResponse(null);
+        }
+    }
+
+    /**
+     * Collects all nodes on the connected cluster and returns / passes a nodeID to {@link ProtobufDiscoveryNode} lookup function
+    * that returns <code>null</code> if the node ID is not found.
+    *
+    * The requests to get cluster state on the connected cluster are made in the system context because logically
+    * they are equivalent to checking a single detail in the local cluster state and should not require that the
+    * user who made the request that is using this method in its implementation is authorized to view the entire
+    * cluster state.
+    */
+    void collectNodes(ActionListener<Function<String, ProtobufDiscoveryNode>> listener) {
+        Runnable runnable = () -> {
+            final ThreadContext threadContext = threadPool.getThreadContext();
+            final ContextPreservingActionListener<Function<String, ProtobufDiscoveryNode>> contextPreservingActionListener =
+                new ContextPreservingActionListener<>(threadContext.newRestorableContext(false), listener);
+            try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
+                // we stash any context here since this is an internal execution and should not leak any existing context information
+                threadContext.markAsSystemContext();
+
+                final ProtobufClusterStateRequest request = new ProtobufClusterStateRequest();
+                request.clear();
+                request.nodes(true);
+                request.local(true); // run this on the node that gets the request it's as good as any other
+                ProtobufTransport.Connection connection = remoteConnectionManager.getAnyRemoteConnection();
+                transportService.sendRequest(
+                    connection,
+                    ClusterStateAction.NAME,
+                    request,
+                    TransportRequestOptions.EMPTY,
+                    new ProtobufTransportResponseHandler<ProtobufClusterStateResponse>() {
+
+                        @Override
+                        public ProtobufClusterStateResponse read(CodedInputStream in) throws IOException {
+                            return new ProtobufClusterStateResponse(in);
+                        }
+
+                        @Override
+                        public void handleResponse(ProtobufClusterStateResponse response) {
+                            ProtobufDiscoveryNodes nodes = response.getState().nodes();
+                            contextPreservingActionListener.onResponse(nodes::get);
+                        }
+
+                        @Override
+                        public void handleException(ProtobufTransportException exp) {
+                            contextPreservingActionListener.onFailure(exp);
+                        }
+
+                        @Override
+                        public String executor() {
+                            return ProtobufThreadPool.Names.SAME;
+                        }
+                    }
+                );
+            }
+        };
+        try {
+            // just in case if we are not connected for some reason we try to connect and if we fail we have to notify the listener
+            // this will cause some back pressure on the search end and eventually will cause rejections but that's fine
+            // we can't proceed with a search on a cluster level.
+            // in the future we might want to just skip the remote nodes in such a case but that can already be implemented on the
+            // caller end since they provide the listener.
+            ensureConnected(ActionListener.wrap((x) -> runnable.run(), listener::onFailure));
+        } catch (Exception ex) {
+            listener.onFailure(ex);
+        }
+    }
+
+    /**
+     * Returns a connection to the remote cluster, preferably a direct connection to the provided {@link ProtobufDiscoveryNode}.
+    * If such node is not connected, the returned connection will be a proxy connection that redirects to it.
+    */
+    ProtobufTransport.Connection getConnection(ProtobufDiscoveryNode remoteClusterNode) {
+        return remoteConnectionManager.getConnection(remoteClusterNode);
+    }
+
+    ProtobufTransport.Connection getConnection() {
+        return remoteConnectionManager.getAnyRemoteConnection();
+    }
+
+    @Override
+    public void close() throws IOException {
+        IOUtils.close(connectionStrategy, remoteConnectionManager);
+    }
+
+    public boolean isClosed() {
+        return connectionStrategy.isClosed();
+    }
+
+    // for testing only
+    boolean assertNoRunningConnections() {
+        return connectionStrategy.assertNoRunningConnections();
+    }
+
+    boolean isNodeConnected(final ProtobufDiscoveryNode node) {
+        return remoteConnectionManager.nodeConnected(node);
+    }
+
+    /**
+     * Get the information about remote nodes to be rendered on {@code _remote/info} requests.
+    */
+    public ProtobufRemoteConnectionInfo getConnectionInfo() {
+        return new ProtobufRemoteConnectionInfo(clusterAlias, connectionStrategy.getModeInfo(), initialConnectionTimeout, skipUnavailable);
+    }
+
+    int getNumNodesConnected() {
+        return remoteConnectionManager.size();
+    }
+
+    private static ProtobufConnectionManager createConnectionManager(
+        ProtobufConnectionProfile connectionProfile,
+        ProtobufTransportService transportService
+    ) {
+        return new ProtobufClusterConnectionManager(connectionProfile, transportService.transport);
+    }
+
+    ProtobufConnectionManager getConnectionManager() {
+        return remoteConnectionManager;
+    }
+
+    boolean shouldRebuildConnection(Settings newSettings) {
+        return connectionStrategy.shouldRebuildConnection(newSettings);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java
new file mode 100644
index 0000000000000..4148beb90c6e1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java
@@ -0,0 +1,454 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.OriginalIndices;
+import org.opensearch.action.support.GroupedActionListener;
+import org.opensearch.action.support.IndicesOptions;
+import org.opensearch.action.support.PlainActionFuture;
+import org.opensearch.client.ProtobufClient;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
+import org.opensearch.common.Strings;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.concurrent.ConcurrentCollections;
+import org.opensearch.common.util.concurrent.CountDown;
+import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.threadpool.ProtobufThreadPool;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+import static org.opensearch.common.settings.Setting.boolSetting;
+import static org.opensearch.common.settings.Setting.timeSetting;
+
+/**
+ * Basic service for accessing remote clusters via gateway nodes
+*
+* @opensearch.internal
+*/
+public final class ProtobufRemoteClusterService extends RemoteClusterAware implements Closeable {
+
+    private final Logger logger = LogManager.getLogger(ProtobufRemoteClusterService.class);
+
+    /**
+     * The initial connect timeout for remote cluster connections
+    */
+    public static final Setting<TimeValue> REMOTE_INITIAL_CONNECTION_TIMEOUT_SETTING = Setting.positiveTimeSetting(
+        "cluster.remote.initial_connect_timeout",
+        TimeValue.timeValueSeconds(30),
+        Setting.Property.NodeScope
+    );
+
+    /**
+     * The name of a node attribute to select nodes that should be connected to in the remote cluster.
+    * For instance a node can be configured with {@code node.attr.gateway: true} in order to be eligible as a gateway node between
+    * clusters. In that case {@code cluster.remote.node.attr: gateway} can be used to filter out other nodes in the remote cluster.
+    * The value of the setting is expected to be a boolean, {@code true} for nodes that can become gateways, {@code false} otherwise.
+    */
+    public static final Setting<String> REMOTE_NODE_ATTRIBUTE = Setting.simpleString(
+        "cluster.remote.node.attr",
+        Setting.Property.NodeScope
+    );
+
+    /**
+     * If <code>true</code> connecting to remote clusters is supported on this node. If <code>false</code> this node will not establish
+    * connections to any remote clusters configured. Search requests executed against this node (where this node is the coordinating node)
+    * will fail if remote cluster syntax is used as an index pattern. The default is <code>true</code>
+    */
+    public static final Setting<Boolean> ENABLE_REMOTE_CLUSTERS = Setting.boolSetting(
+        "cluster.remote.connect",
+        true,
+        Setting.Property.Deprecated,
+        Setting.Property.NodeScope
+    );
+
+    public static final Setting.AffixSetting<Boolean> REMOTE_CLUSTER_SKIP_UNAVAILABLE = Setting.affixKeySetting(
+        "cluster.remote.",
+        "skip_unavailable",
+        (ns, key) -> boolSetting(key, false, new RemoteConnectionEnabled<>(ns, key), Setting.Property.Dynamic, Setting.Property.NodeScope)
+    );
+
+    public static final Setting.AffixSetting<TimeValue> REMOTE_CLUSTER_PING_SCHEDULE = Setting.affixKeySetting(
+        "cluster.remote.",
+        "transport.ping_schedule",
+        (ns, key) -> timeSetting(
+            key,
+            TransportSettings.PING_SCHEDULE,
+            new RemoteConnectionEnabled<>(ns, key),
+            Setting.Property.Dynamic,
+            Setting.Property.NodeScope
+        )
+    );
+
+    public static final Setting.AffixSetting<Boolean> REMOTE_CLUSTER_COMPRESS = Setting.affixKeySetting(
+        "cluster.remote.",
+        "transport.compress",
+        (ns, key) -> boolSetting(
+            key,
+            TransportSettings.TRANSPORT_COMPRESS,
+            new RemoteConnectionEnabled<>(ns, key),
+            Setting.Property.Dynamic,
+            Setting.Property.NodeScope
+        )
+    );
+
+    private final boolean enabled;
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    private final ProtobufTransportService transportService;
+    private final Map<String, ProtobufRemoteClusterConnection> remoteClusters = ConcurrentCollections.newConcurrentMap();
+
+    ProtobufRemoteClusterService(Settings settings, ProtobufTransportService transportService) {
+        super(settings);
+        this.enabled = ProtobufDiscoveryNode.isRemoteClusterClient(settings);
+        this.transportService = transportService;
+    }
+
+    /**
+     * Returns <code>true</code> if at least one remote cluster is configured
+    */
+    public boolean isCrossClusterSearchEnabled() {
+        return remoteClusters.isEmpty() == false;
+    }
+
+    boolean isRemoteNodeConnected(final String remoteCluster, final ProtobufDiscoveryNode node) {
+        return remoteClusters.get(remoteCluster).isNodeConnected(node);
+    }
+
+    public Map<String, OriginalIndices> groupIndices(IndicesOptions indicesOptions, String[] indices, Predicate<String> indexExists) {
+        Map<String, OriginalIndices> originalIndicesMap = new HashMap<>();
+        if (isCrossClusterSearchEnabled()) {
+            final Map<String, List<String>> groupedIndices = groupClusterIndices(getRemoteClusterNames(), indices, indexExists);
+            if (groupedIndices.isEmpty()) {
+                // search on _all in the local cluster if neither local indices nor remote indices were specified
+                originalIndicesMap.put(LOCAL_CLUSTER_GROUP_KEY, new OriginalIndices(Strings.EMPTY_ARRAY, indicesOptions));
+            } else {
+                for (Map.Entry<String, List<String>> entry : groupedIndices.entrySet()) {
+                    String clusterAlias = entry.getKey();
+                    List<String> originalIndices = entry.getValue();
+                    originalIndicesMap.put(clusterAlias, new OriginalIndices(originalIndices.toArray(new String[0]), indicesOptions));
+                }
+            }
+        } else {
+            originalIndicesMap.put(LOCAL_CLUSTER_GROUP_KEY, new OriginalIndices(indices, indicesOptions));
+        }
+        return originalIndicesMap;
+    }
+
+    /**
+     * Returns <code>true</code> iff the given cluster is configured as a remote cluster. Otherwise <code>false</code>
+    */
+    boolean isRemoteClusterRegistered(String clusterName) {
+        return remoteClusters.containsKey(clusterName);
+    }
+
+    /**
+     * Returns the registered remote cluster names.
+    */
+    public Set<String> getRegisteredRemoteClusterNames() {
+        // remoteClusters is unmodifiable so its key set will be unmodifiable too
+        return remoteClusters.keySet();
+    }
+
+    /**
+     * Returns a connection to the given node on the given remote cluster
+    *
+    * @throws IllegalArgumentException if the remote cluster is unknown
+    */
+    public ProtobufTransport.Connection getConnection(ProtobufDiscoveryNode node, String cluster) {
+        return getRemoteClusterConnection(cluster).getConnection(node);
+    }
+
+    /**
+     * Ensures that the given cluster alias is connected. If the cluster is connected this operation
+    * will invoke the listener immediately.
+    */
+    void ensureConnected(String clusterAlias, ActionListener<Void> listener) {
+        getRemoteClusterConnection(clusterAlias).ensureConnected(listener);
+    }
+
+    /**
+     * Returns whether the cluster identified by the provided alias is configured to be skipped when unavailable
+    */
+    public boolean isSkipUnavailable(String clusterAlias) {
+        return getRemoteClusterConnection(clusterAlias).isSkipUnavailable();
+    }
+
+    public ProtobufTransport.Connection getConnection(String cluster) {
+        return getRemoteClusterConnection(cluster).getConnection();
+    }
+
+    ProtobufRemoteClusterConnection getRemoteClusterConnection(String cluster) {
+        if (enabled == false) {
+            throw new IllegalArgumentException(
+                "this node does not have the " + DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName() + " role"
+            );
+        }
+        ProtobufRemoteClusterConnection connection = remoteClusters.get(cluster);
+        if (connection == null) {
+            throw new NoSuchRemoteClusterException(cluster);
+        }
+        return connection;
+    }
+
+    Set<String> getRemoteClusterNames() {
+        return this.remoteClusters.keySet();
+    }
+
+    @Override
+    public void listenForUpdates(ClusterSettings clusterSettings) {
+        super.listenForUpdates(clusterSettings);
+        clusterSettings.addAffixUpdateConsumer(REMOTE_CLUSTER_SKIP_UNAVAILABLE, this::updateSkipUnavailable, (alias, value) -> {});
+    }
+
+    private synchronized void updateSkipUnavailable(String clusterAlias, Boolean skipUnavailable) {
+        ProtobufRemoteClusterConnection remote = this.remoteClusters.get(clusterAlias);
+        if (remote != null) {
+            remote.updateSkipUnavailable(skipUnavailable);
+        }
+    }
+
+    @Override
+    protected void updateRemoteCluster(String clusterAlias, Settings settings) {
+        CountDownLatch latch = new CountDownLatch(1);
+        updateRemoteCluster(clusterAlias, settings, ActionListener.wrap(latch::countDown));
+
+        try {
+            // Wait 10 seconds for a connections. We must use a latch instead of a future because we
+            // are on the cluster state thread and our custom future implementation will throw an
+            // assertion.
+            if (latch.await(10, TimeUnit.SECONDS) == false) {
+                logger.warn("failed to connect to new remote cluster {} within {}", clusterAlias, TimeValue.timeValueSeconds(10));
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    /**
+     * This method updates the list of remote clusters. It's intended to be used as an update consumer on the settings infrastructure
+    *
+    * @param clusterAlias a cluster alias to discovery node mapping representing the remote clusters seeds nodes
+    * @param newSettings the updated settings for the remote connection
+    * @param listener a listener invoked once every configured cluster has been connected to
+    */
+    synchronized void updateRemoteCluster(String clusterAlias, Settings newSettings, ActionListener<Void> listener) {
+        if (LOCAL_CLUSTER_GROUP_KEY.equals(clusterAlias)) {
+            throw new IllegalArgumentException("remote clusters must not have the empty string as its key");
+        }
+
+        ProtobufRemoteClusterConnection remote = this.remoteClusters.get(clusterAlias);
+        if (RemoteConnectionStrategy.isConnectionEnabled(clusterAlias, newSettings) == false) {
+            try {
+                IOUtils.close(remote);
+            } catch (IOException e) {
+                logger.warn("failed to close remote cluster connections for cluster: " + clusterAlias, e);
+            }
+            remoteClusters.remove(clusterAlias);
+            listener.onResponse(null);
+            return;
+        }
+
+        if (remote == null) {
+            // this is a new cluster we have to add a new representation
+            Settings finalSettings = Settings.builder().put(this.settings, false).put(newSettings, false).build();
+            remote = new ProtobufRemoteClusterConnection(finalSettings, clusterAlias, transportService);
+            remoteClusters.put(clusterAlias, remote);
+            remote.ensureConnected(listener);
+        } else if (remote.shouldRebuildConnection(newSettings)) {
+            // Changes to connection configuration. Must tear down existing connection
+            try {
+                IOUtils.close(remote);
+            } catch (IOException e) {
+                logger.warn("failed to close remote cluster connections for cluster: " + clusterAlias, e);
+            }
+            remoteClusters.remove(clusterAlias);
+            Settings finalSettings = Settings.builder().put(this.settings, false).put(newSettings, false).build();
+            remote = new ProtobufRemoteClusterConnection(finalSettings, clusterAlias, transportService);
+            remoteClusters.put(clusterAlias, remote);
+            remote.ensureConnected(listener);
+        } else {
+            // No changes to connection configuration.
+            listener.onResponse(null);
+        }
+    }
+
+    /**
+     * Connects to all remote clusters in a blocking fashion. This should be called on node startup to establish an initial connection
+    * to all configured seed nodes.
+    */
+    void initializeRemoteClusters() {
+        final TimeValue timeValue = REMOTE_INITIAL_CONNECTION_TIMEOUT_SETTING.get(settings);
+        final PlainActionFuture<Collection<Void>> future = new PlainActionFuture<>();
+        Set<String> enabledClusters = RemoteClusterAware.getEnabledRemoteClusters(settings);
+
+        if (enabledClusters.isEmpty()) {
+            return;
+        }
+
+        GroupedActionListener<Void> listener = new GroupedActionListener<>(future, enabledClusters.size());
+        for (String clusterAlias : enabledClusters) {
+            updateRemoteCluster(clusterAlias, settings, listener);
+        }
+
+        if (enabledClusters.isEmpty()) {
+            future.onResponse(null);
+        }
+
+        try {
+            future.get(timeValue.millis(), TimeUnit.MILLISECONDS);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        } catch (TimeoutException ex) {
+            logger.warn("failed to connect to remote clusters within {}", timeValue.toString());
+        } catch (Exception e) {
+            throw new IllegalStateException("failed to connect to remote clusters", e);
+        }
+    }
+
+    @Override
+    public void close() throws IOException {
+        IOUtils.close(remoteClusters.values());
+    }
+
+    public Stream<ProtobufRemoteConnectionInfo> getRemoteConnectionInfos() {
+        return remoteClusters.values().stream().map(ProtobufRemoteClusterConnection::getConnectionInfo);
+    }
+
+    /**
+     * Collects all nodes of the given clusters and returns / passes a (clusterAlias, nodeId) to {@link ProtobufDiscoveryNode}
+    * function on success.
+    */
+    public void collectNodes(Set<String> clusters, ActionListener<BiFunction<String, String, ProtobufDiscoveryNode>> listener) {
+        if (enabled == false) {
+            throw new IllegalArgumentException(
+                "this node does not have the " + DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName() + " role"
+            );
+        }
+        Map<String, ProtobufRemoteClusterConnection> remoteClusters = this.remoteClusters;
+        for (String cluster : clusters) {
+            if (remoteClusters.containsKey(cluster) == false) {
+                listener.onFailure(new NoSuchRemoteClusterException(cluster));
+                return;
+            }
+        }
+
+        final Map<String, Function<String, ProtobufDiscoveryNode>> clusterMap = new HashMap<>();
+        CountDown countDown = new CountDown(clusters.size());
+        Function<String, ProtobufDiscoveryNode> nullFunction = s -> null;
+        for (final String cluster : clusters) {
+            ProtobufRemoteClusterConnection connection = remoteClusters.get(cluster);
+            connection.collectNodes(new ActionListener<Function<String, ProtobufDiscoveryNode>>() {
+                @Override
+                public void onResponse(Function<String, ProtobufDiscoveryNode> nodeLookup) {
+                    synchronized (clusterMap) {
+                        clusterMap.put(cluster, nodeLookup);
+                    }
+                    if (countDown.countDown()) {
+                        listener.onResponse((clusterAlias, nodeId) -> clusterMap.getOrDefault(clusterAlias, nullFunction).apply(nodeId));
+                    }
+                }
+
+                @Override
+                public void onFailure(Exception e) {
+                    if (countDown.fastForward()) { // we need to check if it's true since we could have multiple failures
+                        listener.onFailure(e);
+                    }
+                }
+            });
+        }
+    }
+
+    /**
+     * Returns a client to the remote cluster if the given cluster alias exists.
+    *
+    * @param threadPool   the {@link ProtobufThreadPool} for the client
+    * @param clusterAlias the cluster alias the remote cluster is registered under
+    * @throws IllegalArgumentException if the given clusterAlias doesn't exist
+    */
+    public ProtobufClient getRemoteClusterClient(ProtobufThreadPool threadPool, String clusterAlias) {
+        if (transportService.getRemoteClusterService().isEnabled() == false) {
+            throw new IllegalArgumentException(
+                "this node does not have the " + DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName() + " role"
+            );
+        }
+        if (transportService.getRemoteClusterService().getRemoteClusterNames().contains(clusterAlias) == false) {
+            throw new NoSuchRemoteClusterException(clusterAlias);
+        }
+        return new ProtobufRemoteClusterAwareClient(settings, threadPool, transportService, clusterAlias);
+    }
+
+    Collection<ProtobufRemoteClusterConnection> getConnections() {
+        return remoteClusters.values();
+    }
+
+    /**
+     * Internal class to hold cluster alias and key and track a remote connection
+    *
+    * @opensearch.internal
+    */
+    private static class RemoteConnectionEnabled<T> implements Setting.Validator<T> {
+
+        private final String clusterAlias;
+        private final String key;
+
+        private RemoteConnectionEnabled(String clusterAlias, String key) {
+            this.clusterAlias = clusterAlias;
+            this.key = key;
+        }
+
+        @Override
+        public void validate(T value) {}
+
+        @Override
+        public void validate(T value, Map<Setting<?>, Object> settings, boolean isPresent) {
+            if (isPresent && RemoteConnectionStrategy.isConnectionEnabled(clusterAlias, settings) == false) {
+                throw new IllegalArgumentException("Cannot configure setting [" + key + "] if remote cluster is not enabled.");
+            }
+        }
+
+        @Override
+        public Iterator<Setting<?>> settings() {
+            return Stream.concat(
+                Stream.of(RemoteConnectionStrategy.REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(clusterAlias)),
+                settingsStream()
+            ).iterator();
+        }
+
+        private Stream<Setting<?>> settingsStream() {
+            return Arrays.stream(RemoteConnectionStrategy.ConnectionStrategy.values())
+                .flatMap(strategy -> strategy.getEnablementSettings().get())
+                .map(as -> as.getConcreteSettingForNamespace(clusterAlias));
+        }
+    };
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionInfo.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionInfo.java
new file mode 100644
index 0000000000000..6527c3e0e5814
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionInfo.java
@@ -0,0 +1,132 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Objects;
+
+/**
+ * This class encapsulates all remote cluster information to be rendered on
+* {@code _remote/info} requests.
+*
+* @opensearch.internal
+*/
+public final class ProtobufRemoteConnectionInfo implements ToXContentFragment, ProtobufWriteable {
+
+    final ModeInfo modeInfo;
+    final TimeValue initialConnectionTimeout;
+    final String clusterAlias;
+    final boolean skipUnavailable;
+
+    public ProtobufRemoteConnectionInfo(
+        String clusterAlias,
+        ModeInfo modeInfo,
+        TimeValue initialConnectionTimeout,
+        boolean skipUnavailable
+    ) {
+        this.clusterAlias = clusterAlias;
+        this.modeInfo = modeInfo;
+        this.initialConnectionTimeout = initialConnectionTimeout;
+        this.skipUnavailable = skipUnavailable;
+    }
+
+    public ProtobufRemoteConnectionInfo(CodedInputStream input) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(input);
+        ProtobufRemoteConnectionStrategy.ProtobufConnectionStrategy mode = protobufStreamInput.readEnum(
+            ProtobufRemoteConnectionStrategy.ProtobufConnectionStrategy.class
+        );
+        modeInfo = mode.getReader().read(input);
+        initialConnectionTimeout = protobufStreamInput.readTimeValue();
+        clusterAlias = input.readString();
+        skipUnavailable = input.readBool();
+    }
+
+    public boolean isConnected() {
+        return modeInfo.isConnected();
+    }
+
+    public String getClusterAlias() {
+        return clusterAlias;
+    }
+
+    public ModeInfo getModeInfo() {
+        return modeInfo;
+    }
+
+    public TimeValue getInitialConnectionTimeout() {
+        return initialConnectionTimeout;
+    }
+
+    public boolean isSkipUnavailable() {
+        return skipUnavailable;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeEnum(modeInfo.modeType());
+        modeInfo.writeTo(out);
+        protobufStreamOutput.writeTimeValue(initialConnectionTimeout);
+        out.writeStringNoTag(clusterAlias);
+        out.writeBoolNoTag(skipUnavailable);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(clusterAlias);
+        {
+            builder.field("connected", modeInfo.isConnected());
+            builder.field("mode", modeInfo.modeName());
+            modeInfo.toXContent(builder, params);
+            builder.field("initial_connect_timeout", initialConnectionTimeout);
+            builder.field("skip_unavailable", skipUnavailable);
+        }
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ProtobufRemoteConnectionInfo that = (ProtobufRemoteConnectionInfo) o;
+        return skipUnavailable == that.skipUnavailable
+            && Objects.equals(modeInfo, that.modeInfo)
+            && Objects.equals(initialConnectionTimeout, that.initialConnectionTimeout)
+            && Objects.equals(clusterAlias, that.clusterAlias);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(modeInfo, initialConnectionTimeout, clusterAlias, skipUnavailable);
+    }
+
+    /**
+     * Mode information
+    *
+    * @opensearch.internal
+    */
+    public interface ModeInfo extends ToXContentFragment, ProtobufWriteable {
+
+        boolean isConnected();
+
+        String modeName();
+
+        ProtobufRemoteConnectionStrategy.ProtobufConnectionStrategy modeType();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java
new file mode 100644
index 0000000000000..a8608b80768a6
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java
@@ -0,0 +1,217 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import org.opensearch.Version;
+import org.opensearch.action.ActionListener;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Manager for connecting to remote nodes
+*
+* @opensearch.internal
+*/
+public class ProtobufRemoteConnectionManager implements ProtobufConnectionManager {
+
+    private final String clusterAlias;
+    private final ProtobufConnectionManager delegate;
+    private final AtomicLong counter = new AtomicLong();
+    private volatile List<ProtobufDiscoveryNode> connectedNodes = Collections.emptyList();
+
+    ProtobufRemoteConnectionManager(String clusterAlias, ProtobufConnectionManager delegate) {
+        this.clusterAlias = clusterAlias;
+        this.delegate = delegate;
+        this.delegate.addListener(new ProtobufTransportConnectionListener() {
+            @Override
+            public void onNodeConnected(ProtobufDiscoveryNode node, ProtobufTransport.Connection connection) {
+                addConnectedNode(node);
+            }
+
+            @Override
+            public void onNodeDisconnected(ProtobufDiscoveryNode node, ProtobufTransport.Connection connection) {
+                removeConnectedNode(node);
+            }
+        });
+    }
+
+    @Override
+    public void connectToNode(
+        ProtobufDiscoveryNode node,
+        ProtobufConnectionProfile connectionProfile,
+        ProtobufConnectionManager.ConnectionValidator connectionValidator,
+        ActionListener<Void> listener
+    ) throws ConnectTransportException {
+        delegate.connectToNode(node, connectionProfile, connectionValidator, listener);
+    }
+
+    @Override
+    public void addListener(ProtobufTransportConnectionListener listener) {
+        delegate.addListener(listener);
+    }
+
+    @Override
+    public void removeListener(ProtobufTransportConnectionListener listener) {
+        delegate.removeListener(listener);
+    }
+
+    @Override
+    public void openConnection(
+        ProtobufDiscoveryNode node,
+        ProtobufConnectionProfile profile,
+        ActionListener<ProtobufTransport.Connection> listener
+    ) {
+        delegate.openConnection(node, profile, listener);
+    }
+
+    @Override
+    public ProtobufTransport.Connection getConnection(ProtobufDiscoveryNode node) {
+        try {
+            return delegate.getConnection(node);
+        } catch (NodeNotConnectedException e) {
+            return new ProxyConnection(getAnyRemoteConnection(), node);
+        }
+    }
+
+    @Override
+    public boolean nodeConnected(ProtobufDiscoveryNode node) {
+        return delegate.nodeConnected(node);
+    }
+
+    @Override
+    public void disconnectFromNode(ProtobufDiscoveryNode node) {
+        delegate.disconnectFromNode(node);
+    }
+
+    @Override
+    public ProtobufConnectionProfile getConnectionProfile() {
+        return delegate.getConnectionProfile();
+    }
+
+    public ProtobufTransport.Connection getAnyRemoteConnection() {
+        List<ProtobufDiscoveryNode> localConnectedNodes = this.connectedNodes;
+        long curr;
+        while ((curr = counter.incrementAndGet()) == Long.MIN_VALUE)
+            ;
+        if (localConnectedNodes.isEmpty() == false) {
+            ProtobufDiscoveryNode nextNode = localConnectedNodes.get(
+                Math.toIntExact(Math.floorMod(curr, (long) localConnectedNodes.size()))
+            );
+            try {
+                return delegate.getConnection(nextNode);
+            } catch (NodeNotConnectedException e) {
+                // Ignore. We will manually create an iterator of open nodes
+            }
+        }
+        Set<ProtobufDiscoveryNode> allConnectionNodes = getAllConnectedNodes();
+        for (ProtobufDiscoveryNode connectedNode : allConnectionNodes) {
+            try {
+                return delegate.getConnection(connectedNode);
+            } catch (NodeNotConnectedException e) {
+                // Ignore. We will try the next one until all are exhausted.
+            }
+        }
+        throw new NoSuchRemoteClusterException(clusterAlias);
+    }
+
+    @Override
+    public Set<ProtobufDiscoveryNode> getAllConnectedNodes() {
+        return delegate.getAllConnectedNodes();
+    }
+
+    @Override
+    public int size() {
+        return delegate.size();
+    }
+
+    @Override
+    public void close() {
+        delegate.closeNoBlock();
+    }
+
+    @Override
+    public void closeNoBlock() {
+        delegate.closeNoBlock();
+    }
+
+    private synchronized void addConnectedNode(ProtobufDiscoveryNode addedNode) {
+        ArrayList<ProtobufDiscoveryNode> newConnections = new ArrayList<>(this.connectedNodes);
+        newConnections.add(addedNode);
+        this.connectedNodes = Collections.unmodifiableList(newConnections);
+    }
+
+    private synchronized void removeConnectedNode(ProtobufDiscoveryNode removedNode) {
+        int newSize = this.connectedNodes.size() - 1;
+        ArrayList<ProtobufDiscoveryNode> newConnectedNodes = new ArrayList<>(newSize);
+        for (ProtobufDiscoveryNode connectedNode : this.connectedNodes) {
+            if (connectedNode.equals(removedNode) == false) {
+                newConnectedNodes.add(connectedNode);
+            }
+        }
+        assert newConnectedNodes.size() == newSize : "Expected connection node count: " + newSize + ", Found: " + newConnectedNodes.size();
+        this.connectedNodes = Collections.unmodifiableList(newConnectedNodes);
+    }
+
+    static final class ProxyConnection implements ProtobufTransport.Connection {
+        private final ProtobufTransport.Connection connection;
+        private final ProtobufDiscoveryNode targetNode;
+
+        private ProxyConnection(ProtobufTransport.Connection connection, ProtobufDiscoveryNode targetNode) {
+            this.connection = connection;
+            this.targetNode = targetNode;
+        }
+
+        @Override
+        public ProtobufDiscoveryNode getNode() {
+            return targetNode;
+        }
+
+        @Override
+        public void sendRequest(long requestId, String action, ProtobufTransportRequest request, TransportRequestOptions options)
+            throws IOException, TransportException {
+            connection.sendRequest(
+                requestId,
+                ProtobufTransportActionProxy.getProxyAction(action),
+                ProtobufTransportActionProxy.wrapRequest(targetNode, request),
+                options
+            );
+        }
+
+        @Override
+        public void close() {
+            assert false : "proxy connections must not be closed";
+        }
+
+        @Override
+        public void addCloseListener(ActionListener<Void> listener) {
+            connection.addCloseListener(listener);
+        }
+
+        @Override
+        public boolean isClosed() {
+            return connection.isClosed();
+        }
+
+        @Override
+        public Version getVersion() {
+            return connection.getVersion();
+        }
+
+        @Override
+        public Object getCacheKey() {
+            return connection.getCacheKey();
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java
new file mode 100644
index 0000000000000..0ee4507fc98a8
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java
@@ -0,0 +1,484 @@
+/*
+* 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.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.apache.lucene.store.AlreadyClosedException;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.support.ContextPreservingActionListener;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.common.Strings;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.concurrent.AbstractRunnable;
+import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.Closeable;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * Strategy to connect to remote nodes
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufRemoteConnectionStrategy implements ProtobufTransportConnectionListener, Closeable {
+
+    enum ProtobufConnectionStrategy {
+        SNIFF(
+            ProtobufSniffConnectionStrategy.CHANNELS_PER_CONNECTION,
+            ProtobufSniffConnectionStrategy::enablementSettings,
+            ProtobufSniffConnectionStrategy::infoReader
+        ) {
+            @Override
+            public String toString() {
+                return "sniff";
+            }
+        },
+        PROXY(
+            ProtobufProxyConnectionStrategy.CHANNELS_PER_CONNECTION,
+            ProtobufProxyConnectionStrategy::enablementSettings,
+            ProtobufProxyConnectionStrategy::infoReader
+        ) {
+            @Override
+            public String toString() {
+                return "proxy";
+            }
+        };
+
+        private final int numberOfChannels;
+        private final Supplier<Stream<Setting.AffixSetting<?>>> enablementSettings;
+        private final Supplier<ProtobufWriteable.Reader<ProtobufRemoteConnectionInfo.ModeInfo>> reader;
+
+        ProtobufConnectionStrategy(
+            int numberOfChannels,
+            Supplier<Stream<Setting.AffixSetting<?>>> enablementSettings,
+            Supplier<ProtobufWriteable.Reader<ProtobufRemoteConnectionInfo.ModeInfo>> reader
+        ) {
+            this.numberOfChannels = numberOfChannels;
+            this.enablementSettings = enablementSettings;
+            this.reader = reader;
+        }
+
+        public int getNumberOfChannels() {
+            return numberOfChannels;
+        }
+
+        public Supplier<Stream<Setting.AffixSetting<?>>> getEnablementSettings() {
+            return enablementSettings;
+        }
+
+        public ProtobufWriteable.Reader<ProtobufRemoteConnectionInfo.ModeInfo> getReader() {
+            return reader.get();
+        }
+    }
+
+    public static final Setting.AffixSetting<ProtobufConnectionStrategy> REMOTE_CONNECTION_MODE = Setting.affixKeySetting(
+        "cluster.remote.",
+        "mode",
+        key -> new Setting<>(
+            key,
+            ProtobufConnectionStrategy.SNIFF.name(),
+            value -> ProtobufConnectionStrategy.valueOf(value.toUpperCase(Locale.ROOT)),
+            Setting.Property.NodeScope,
+            Setting.Property.Dynamic
+        )
+    );
+
+    // this setting is intentionally not registered, it is only used in tests
+    public static final Setting<Integer> REMOTE_MAX_PENDING_CONNECTION_LISTENERS = Setting.intSetting(
+        "cluster.remote.max_pending_connection_listeners",
+        1000,
+        Setting.Property.NodeScope
+    );
+
+    private final int maxPendingConnectionListeners;
+
+    protected final Logger logger = LogManager.getLogger(getClass());
+
+    private final AtomicBoolean closed = new AtomicBoolean(false);
+    private final Object mutex = new Object();
+    private List<ActionListener<Void>> listeners = new ArrayList<>();
+
+    protected final ProtobufTransportService transportService;
+    protected final ProtobufRemoteConnectionManager connectionManager;
+    protected final String clusterAlias;
+
+    ProtobufRemoteConnectionStrategy(
+        String clusterAlias,
+        ProtobufTransportService transportService,
+        ProtobufRemoteConnectionManager connectionManager,
+        Settings settings
+    ) {
+        this.clusterAlias = clusterAlias;
+        this.transportService = transportService;
+        this.connectionManager = connectionManager;
+        this.maxPendingConnectionListeners = REMOTE_MAX_PENDING_CONNECTION_LISTENERS.get(settings);
+        connectionManager.addListener(this);
+    }
+
+    static ProtobufConnectionProfile buildConnectionProfile(String clusterAlias, Settings settings) {
+        ProtobufConnectionStrategy mode = REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(clusterAlias).get(settings);
+        ProtobufConnectionProfile.Builder builder = new ProtobufConnectionProfile.Builder().setConnectTimeout(
+            TransportSettings.CONNECT_TIMEOUT.get(settings)
+        )
+            .setHandshakeTimeout(TransportSettings.CONNECT_TIMEOUT.get(settings))
+            .setCompressionEnabled(RemoteClusterService.REMOTE_CLUSTER_COMPRESS.getConcreteSettingForNamespace(clusterAlias).get(settings))
+            .setPingInterval(RemoteClusterService.REMOTE_CLUSTER_PING_SCHEDULE.getConcreteSettingForNamespace(clusterAlias).get(settings))
+            .addConnections(
+                0,
+                TransportRequestOptions.Type.BULK,
+                TransportRequestOptions.Type.STATE,
+                TransportRequestOptions.Type.RECOVERY,
+                TransportRequestOptions.Type.PING
+            )
+            .addConnections(mode.numberOfChannels, TransportRequestOptions.Type.REG);
+        return builder.build();
+    }
+
+    static ProtobufRemoteConnectionStrategy buildStrategy(
+        String clusterAlias,
+        ProtobufTransportService transportService,
+        ProtobufRemoteConnectionManager connectionManager,
+        Settings settings
+    ) {
+        ProtobufConnectionStrategy mode = REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(clusterAlias).get(settings);
+        switch (mode) {
+            case SNIFF:
+                return new ProtobufSniffConnectionStrategy(clusterAlias, transportService, connectionManager, settings);
+            case PROXY:
+                return new ProtobufProxyConnectionStrategy(clusterAlias, transportService, connectionManager, settings);
+            default:
+                throw new AssertionError("Invalid connection strategy" + mode);
+        }
+    }
+
+    static Set<String> getRemoteClusters(Settings settings) {
+        final Stream<Setting.AffixSetting<?>> enablementSettings = Arrays.stream(ProtobufConnectionStrategy.values())
+            .flatMap(strategy -> strategy.getEnablementSettings().get());
+        return enablementSettings.flatMap(s -> getClusterAlias(settings, s)).collect(Collectors.toSet());
+    }
+
+    public static boolean isConnectionEnabled(String clusterAlias, Settings settings) {
+        ProtobufConnectionStrategy mode = REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(clusterAlias).get(settings);
+        if (mode.equals(ProtobufConnectionStrategy.SNIFF)) {
+            List<String> seeds = ProtobufSniffConnectionStrategy.REMOTE_CLUSTER_SEEDS.getConcreteSettingForNamespace(clusterAlias)
+                .get(settings);
+            return seeds.isEmpty() == false;
+        } else {
+            String address = ProtobufProxyConnectionStrategy.PROXY_ADDRESS.getConcreteSettingForNamespace(clusterAlias).get(settings);
+            return Strings.isEmpty(address) == false;
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public static boolean isConnectionEnabled(String clusterAlias, Map<Setting<?>, Object> settings) {
+        ProtobufConnectionStrategy mode = (ProtobufConnectionStrategy) settings.get(
+            REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(clusterAlias)
+        );
+        if (mode.equals(ProtobufConnectionStrategy.SNIFF)) {
+            List<String> seeds = (List<String>) settings.get(
+                ProtobufSniffConnectionStrategy.REMOTE_CLUSTER_SEEDS.getConcreteSettingForNamespace(clusterAlias)
+            );
+            return seeds.isEmpty() == false;
+        } else {
+            String address = (String) settings.get(
+                ProtobufProxyConnectionStrategy.PROXY_ADDRESS.getConcreteSettingForNamespace(clusterAlias)
+            );
+            return Strings.isEmpty(address) == false;
+        }
+    }
+
+    private static <T> Stream<String> getClusterAlias(Settings settings, Setting.AffixSetting<T> affixSetting) {
+        Stream<Setting<T>> allConcreteSettings = affixSetting.getAllConcreteSettings(settings);
+        return allConcreteSettings.map(affixSetting::getNamespace);
+    }
+
+    static InetSocketAddress parseConfiguredAddress(String configuredAddress) {
+        final String host = parseHost(configuredAddress);
+        final int port = parsePort(configuredAddress);
+        InetAddress hostAddress;
+        try {
+            hostAddress = InetAddress.getByName(host);
+        } catch (UnknownHostException e) {
+            throw new IllegalArgumentException("unknown host [" + host + "]", e);
+        }
+        return new InetSocketAddress(hostAddress, port);
+    }
+
+    static String parseHost(final String configuredAddress) {
+        return configuredAddress.substring(0, indexOfPortSeparator(configuredAddress));
+    }
+
+    static int parsePort(String remoteHost) {
+        try {
+            int port = Integer.parseInt(remoteHost.substring(indexOfPortSeparator(remoteHost) + 1));
+            if (port <= 0) {
+                throw new IllegalArgumentException("port number must be > 0 but was: [" + port + "]");
+            }
+            return port;
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("failed to parse port", e);
+        }
+    }
+
+    private static int indexOfPortSeparator(String remoteHost) {
+        int portSeparator = remoteHost.lastIndexOf(':'); // in case we have a IPv6 address ie. [::1]:9300
+        if (portSeparator == -1 || portSeparator == remoteHost.length()) {
+            throw new IllegalArgumentException("remote hosts need to be configured as [host:port], found [" + remoteHost + "] instead");
+        }
+        return portSeparator;
+    }
+
+    /**
+     * Triggers a connect round unless there is one running already. If there is a connect round running, the listener will either
+    * be queued or rejected and failed.
+    */
+    void connect(ActionListener<Void> connectListener) {
+        boolean runConnect = false;
+        final ActionListener<Void> listener = ContextPreservingActionListener.wrapPreservingContext(
+            connectListener,
+            transportService.getThreadPool().getThreadContext()
+        );
+        boolean closed;
+        synchronized (mutex) {
+            closed = this.closed.get();
+            if (closed) {
+                assert listeners.isEmpty();
+            } else {
+                if (listeners.size() >= maxPendingConnectionListeners) {
+                    assert listeners.size() == maxPendingConnectionListeners;
+                    listener.onFailure(new OpenSearchRejectedExecutionException("connect listener queue is full"));
+                    return;
+                } else {
+                    listeners.add(listener);
+                }
+                runConnect = listeners.size() == 1;
+            }
+        }
+        if (closed) {
+            connectListener.onFailure(new AlreadyClosedException("connect handler is already closed"));
+            return;
+        }
+        if (runConnect) {
+            ExecutorService executor = transportService.getThreadPool().executor(ThreadPool.Names.MANAGEMENT);
+            executor.submit(new AbstractRunnable() {
+                @Override
+                public void onFailure(Exception e) {
+                    ActionListener.onFailure(getAndClearListeners(), e);
+                }
+
+                @Override
+                protected void doRun() {
+                    connectImpl(new ActionListener<Void>() {
+                        @Override
+                        public void onResponse(Void aVoid) {
+                            ActionListener.onResponse(getAndClearListeners(), aVoid);
+                        }
+
+                        @Override
+                        public void onFailure(Exception e) {
+                            ActionListener.onFailure(getAndClearListeners(), e);
+                        }
+                    });
+                }
+            });
+        }
+    }
+
+    boolean shouldRebuildConnection(Settings newSettings) {
+        ProtobufConnectionStrategy newMode = REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(clusterAlias).get(newSettings);
+        if (newMode.equals(strategyType()) == false) {
+            return true;
+        } else {
+            Boolean compressionEnabled = RemoteClusterService.REMOTE_CLUSTER_COMPRESS.getConcreteSettingForNamespace(clusterAlias)
+                .get(newSettings);
+            TimeValue pingSchedule = RemoteClusterService.REMOTE_CLUSTER_PING_SCHEDULE.getConcreteSettingForNamespace(clusterAlias)
+                .get(newSettings);
+
+            ProtobufConnectionProfile oldProfile = connectionManager.getConnectionProfile();
+            ProtobufConnectionProfile.Builder builder = new ProtobufConnectionProfile.Builder(oldProfile);
+            builder.setCompressionEnabled(compressionEnabled);
+            builder.setPingInterval(pingSchedule);
+            ProtobufConnectionProfile newProfile = builder.build();
+            return connectionProfileChanged(oldProfile, newProfile) || strategyMustBeRebuilt(newSettings);
+        }
+    }
+
+    protected abstract boolean strategyMustBeRebuilt(Settings newSettings);
+
+    protected abstract ProtobufConnectionStrategy strategyType();
+
+    @Override
+    public void onNodeDisconnected(ProtobufDiscoveryNode node, ProtobufTransport.Connection connection) {
+        if (shouldOpenMoreConnections()) {
+            // try to reconnect and fill up the slot of the disconnected node
+            connect(
+                ActionListener.wrap(
+                    ignore -> logger.trace("[{}] successfully connected after disconnect of {}", clusterAlias, node),
+                    e -> logger.debug(
+                        () -> new ParameterizedMessage("[{}] failed to connect after disconnect of {}", clusterAlias, node),
+                        e
+                    )
+                )
+            );
+        }
+    }
+
+    @Override
+    public void close() {
+        final List<ActionListener<Void>> toNotify;
+        synchronized (mutex) {
+            if (closed.compareAndSet(false, true)) {
+                connectionManager.removeListener(this);
+                toNotify = listeners;
+                listeners = Collections.emptyList();
+            } else {
+                toNotify = Collections.emptyList();
+            }
+        }
+        ActionListener.onFailure(toNotify, new AlreadyClosedException("connect handler is already closed"));
+    }
+
+    public boolean isClosed() {
+        return closed.get();
+    }
+
+    // for testing only
+    boolean assertNoRunningConnections() {
+        synchronized (mutex) {
+            assert listeners.isEmpty();
+        }
+        return true;
+    }
+
+    protected abstract boolean shouldOpenMoreConnections();
+
+    protected abstract void connectImpl(ActionListener<Void> listener);
+
+    protected abstract ProtobufRemoteConnectionInfo.ModeInfo getModeInfo();
+
+    private List<ActionListener<Void>> getAndClearListeners() {
+        final List<ActionListener<Void>> result;
+        synchronized (mutex) {
+            if (listeners.isEmpty()) {
+                result = Collections.emptyList();
+            } else {
+                result = listeners;
+                listeners = new ArrayList<>();
+            }
+        }
+        return result;
+    }
+
+    private boolean connectionProfileChanged(ProtobufConnectionProfile oldProfile, ProtobufConnectionProfile newProfile) {
+        return Objects.equals(oldProfile.getCompressionEnabled(), newProfile.getCompressionEnabled()) == false
+            || Objects.equals(oldProfile.getPingInterval(), newProfile.getPingInterval()) == false;
+    }
+
+    /**
+     * Internal strategy validation object
+    *
+    * @opensearch.internal
+    */
+    static class StrategyValidator<T> implements Setting.Validator<T> {
+
+        private final String key;
+        private final ProtobufConnectionStrategy expectedStrategy;
+        private final String namespace;
+        private final Consumer<T> valueChecker;
+
+        StrategyValidator(String namespace, String key, ProtobufConnectionStrategy expectedStrategy) {
+            this(namespace, key, expectedStrategy, (v) -> {});
+        }
+
+        StrategyValidator(String namespace, String key, ProtobufConnectionStrategy expectedStrategy, Consumer<T> valueChecker) {
+            this.namespace = namespace;
+            this.key = key;
+            this.expectedStrategy = expectedStrategy;
+            this.valueChecker = valueChecker;
+        }
+
+        @Override
+        public void validate(T value) {
+            valueChecker.accept(value);
+        }
+
+        @Override
+        public void validate(T value, Map<Setting<?>, Object> settings, boolean isPresent) {
+            Setting<ProtobufConnectionStrategy> concrete = REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(namespace);
+            ProtobufConnectionStrategy modeType = (ProtobufConnectionStrategy) settings.get(concrete);
+            if (isPresent && modeType.equals(expectedStrategy) == false) {
+                throw new IllegalArgumentException(
+                    "Setting \""
+                        + key
+                        + "\" cannot be used with the configured \""
+                        + concrete.getKey()
+                        + "\" [required="
+                        + expectedStrategy.name()
+                        + ", configured="
+                        + modeType.name()
+                        + "]"
+                );
+            }
+        }
+
+        @Override
+        public Iterator<Setting<?>> settings() {
+            Setting<ProtobufConnectionStrategy> concrete = REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(namespace);
+            Stream<Setting<?>> settingStream = Stream.of(concrete);
+            return settingStream.iterator();
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteTransportException.java
new file mode 100644
index 0000000000000..b720a95e19264
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteTransportException.java
@@ -0,0 +1,42 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import org.opensearch.OpenSearchWrapperException;
+import org.opensearch.common.transport.ProtobufTransportAddress;
+
+import java.io.IOException;
+
+/**
+ * A remote exception for an action. A wrapper exception around the actual remote cause and does not fill the
+* stack trace.
+*
+* @opensearch.internal
+*/
+public class ProtobufRemoteTransportException extends ProtobufActionTransportException implements OpenSearchWrapperException {
+
+    public ProtobufRemoteTransportException(String msg, Throwable cause) {
+        super(msg, null, null, cause);
+    }
+
+    public ProtobufRemoteTransportException(String name, ProtobufTransportAddress address, String action, Throwable cause) {
+        super(name, address, action, cause);
+    }
+
+    public ProtobufRemoteTransportException(CodedInputStream in) throws IOException {
+        super(in);
+    }
+
+    @Override
+    public Throwable fillInStackTrace() {
+        // no need for stack trace here, we always have cause
+        return this;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
index 1ddeb04f106a8..6e4fdbfc4f053 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
@@ -8,11 +8,10 @@
 
 package org.opensearch.transport;
 
-import org.opensearch.common.io.stream.StreamInput;
+import com.google.protobuf.CodedInputStream;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.lease.Releasables;
-import org.opensearch.search.internal.ShardSearchRequest;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.tasks.ProtobufCancellableTask;
 import org.opensearch.tasks.ProtobufTask;
@@ -57,24 +56,24 @@ public String getAction() {
         return action;
     }
 
-    public Request newRequest(StreamInput in) throws IOException {
+    public Request newRequest(CodedInputStream in) throws IOException {
         return requestReader.read(in);
     }
 
-    public void processMessageReceived(Request request, TransportChannel channel) throws Exception {
+    public void processMessageReceived(Request request, ProtobufTransportChannel channel) throws Exception {
         final ProtobufTask task = taskManager.register(channel.getChannelType(), action, request);
         ThreadContext.StoredContext contextToRestore = taskManager.taskExecutionStarted(task);
 
         Releasable unregisterTask = () -> taskManager.unregister(task);
         try {
-            if (channel instanceof TcpTransportChannel && task instanceof ProtobufCancellableTask) {
+            if (channel instanceof ProtobufTcpTransportChannel && task instanceof ProtobufCancellableTask) {
                 // if (request instanceof ShardSearchRequest) {
-                //     // on receiving request, update the inbound network time to reflect time spent in transit over the network
-                //     ((ShardSearchRequest) request).setInboundNetworkTime(
-                //         Math.max(0, System.currentTimeMillis() - ((ShardSearchRequest) request).getInboundNetworkTime())
-                //     );
+                // // on receiving request, update the inbound network time to reflect time spent in transit over the network
+                // ((ShardSearchRequest) request).setInboundNetworkTime(
+                // Math.max(0, System.currentTimeMillis() - ((ShardSearchRequest) request).getInboundNetworkTime())
+                // );
                 // }
-                final TcpChannel tcpChannel = ((TcpTransportChannel) channel).getChannel();
+                final TcpChannel tcpChannel = ((ProtobufTcpTransportChannel) channel).getChannel();
                 final Releasable stopTracking = taskManager.startTrackingCancellableChannelTask(tcpChannel, (ProtobufCancellableTask) task);
                 unregisterTask = Releasables.wrap(unregisterTask, stopTracking);
             }
@@ -108,11 +107,11 @@ public String toString() {
         return handler.toString();
     }
 
-    public static <R extends ProtobufTransportRequest> RequestHandlerRegistry<R> replaceHandler(
-        RequestHandlerRegistry<R> registry,
+    public static <R extends ProtobufTransportRequest> ProtobufRequestHandlerRegistry<R> replaceHandler(
+        ProtobufRequestHandlerRegistry<R> registry,
         ProtobufTransportRequestHandler<R> handler
     ) {
-        return new RequestHandlerRegistry<>(
+        return new ProtobufRequestHandlerRegistry<>(
             registry.action,
             registry.requestReader,
             registry.taskManager,
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufSendRequestTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufSendRequestTransportException.java
new file mode 100644
index 0000000000000..eb1e1340230c4
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufSendRequestTransportException.java
@@ -0,0 +1,31 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import org.opensearch.OpenSearchWrapperException;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+
+import java.io.IOException;
+
+/**
+ * Thrown when an error occurs while sending a request
+*
+* @opensearch.internal
+*/
+public class ProtobufSendRequestTransportException extends ProtobufActionTransportException implements OpenSearchWrapperException {
+
+    public ProtobufSendRequestTransportException(ProtobufDiscoveryNode node, String action, Throwable cause) {
+        super(node == null ? null : node.getName(), node == null ? null : node.getAddress(), action, cause);
+    }
+
+    public ProtobufSendRequestTransportException(CodedInputStream in) throws IOException {
+        super(in);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java
new file mode 100644
index 0000000000000..36c851592a6fd
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java
@@ -0,0 +1,628 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.Version;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.StepListener;
+import org.opensearch.action.admin.cluster.state.ClusterStateAction;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
+import org.opensearch.cluster.ProtobufClusterName;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
+import org.opensearch.common.Booleans;
+import org.opensearch.common.SetOnce;
+import org.opensearch.common.Strings;
+import org.opensearch.common.UUIDs;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.threadpool.ProtobufThreadPool;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.opensearch.common.settings.Setting.intSetting;
+
+/**
+ * Sniff for initial seed nodes
+*
+* @opensearch.internal
+*/
+public class ProtobufSniffConnectionStrategy extends ProtobufRemoteConnectionStrategy {
+
+    /**
+     * A list of initial seed nodes to discover eligible nodes from the remote cluster
+    */
+    public static final Setting.AffixSetting<List<String>> REMOTE_CLUSTER_SEEDS = Setting.affixKeySetting(
+        "cluster.remote.",
+        "seeds",
+        (ns, key) -> Setting.listSetting(key, Collections.emptyList(), s -> {
+            // validate seed address
+            parsePort(s);
+            return s;
+        }, new StrategyValidator<>(ns, key, ProtobufConnectionStrategy.SNIFF), Setting.Property.Dynamic, Setting.Property.NodeScope)
+    );
+
+    /**
+     * A proxy address for the remote cluster. By default this is not set, meaning that OpenSearch will connect directly to the nodes in
+    * the remote cluster using their publish addresses. If this setting is set to an IP address or hostname then OpenSearch will connect
+    * to the nodes in the remote cluster using this address instead. Use of this setting is not recommended and it is deliberately
+    * undocumented as it does not work well with all proxies.
+    */
+    public static final Setting.AffixSetting<String> REMOTE_CLUSTERS_PROXY = Setting.affixKeySetting(
+        "cluster.remote.",
+        "proxy",
+        (ns, key) -> Setting.simpleString(key, new StrategyValidator<>(ns, key, ProtobufConnectionStrategy.SNIFF, s -> {
+            if (Strings.hasLength(s)) {
+                parsePort(s);
+            }
+        }), Setting.Property.Dynamic, Setting.Property.NodeScope),
+        () -> REMOTE_CLUSTER_SEEDS
+    );
+
+    /**
+     * The maximum number of connections that will be established to a remote cluster. For instance if there is only a single
+    * seed node, other nodes will be discovered up to the given number of nodes in this setting. The default is 3.
+    */
+    public static final Setting<Integer> REMOTE_CONNECTIONS_PER_CLUSTER = intSetting(
+        "cluster.remote.connections_per_cluster",
+        3,
+        1,
+        Setting.Property.NodeScope
+    );
+    /**
+     * The maximum number of node connections that will be established to a remote cluster. For instance if there is only a single
+    * seed node, other nodes will be discovered up to the given number of nodes in this setting. The default is 3.
+    */
+    public static final Setting.AffixSetting<Integer> REMOTE_NODE_CONNECTIONS = Setting.affixKeySetting(
+        "cluster.remote.",
+        "node_connections",
+        (ns, key) -> intSetting(
+            key,
+            REMOTE_CONNECTIONS_PER_CLUSTER,
+            1,
+            new StrategyValidator<>(ns, key, ProtobufConnectionStrategy.SNIFF),
+            Setting.Property.Dynamic,
+            Setting.Property.NodeScope
+        )
+    );
+
+    static final int CHANNELS_PER_CONNECTION = 6;
+
+    private static final Predicate<ProtobufDiscoveryNode> DEFAULT_NODE_PREDICATE = (node) -> Version.CURRENT.isCompatible(node.getVersion())
+        && (node.isClusterManagerNode() == false || node.isDataNode() || node.isIngestNode());
+
+    private final List<String> configuredSeedNodes;
+    private final List<Supplier<ProtobufDiscoveryNode>> seedNodes;
+    private final int maxNumRemoteConnections;
+    private final Predicate<ProtobufDiscoveryNode> nodePredicate;
+    private final SetOnce<ProtobufClusterName> remoteClusterName = new SetOnce<>();
+    private final String proxyAddress;
+
+    ProtobufSniffConnectionStrategy(
+        String clusterAlias,
+        ProtobufTransportService transportService,
+        ProtobufRemoteConnectionManager connectionManager,
+        Settings settings
+    ) {
+        this(
+            clusterAlias,
+            transportService,
+            connectionManager,
+            REMOTE_CLUSTERS_PROXY.getConcreteSettingForNamespace(clusterAlias).get(settings),
+            settings,
+            REMOTE_NODE_CONNECTIONS.getConcreteSettingForNamespace(clusterAlias).get(settings),
+            getNodePredicate(settings),
+            REMOTE_CLUSTER_SEEDS.getConcreteSettingForNamespace(clusterAlias).get(settings)
+        );
+    }
+
+    ProtobufSniffConnectionStrategy(
+        String clusterAlias,
+        ProtobufTransportService transportService,
+        ProtobufRemoteConnectionManager connectionManager,
+        String proxyAddress,
+        Settings settings,
+        int maxNumRemoteConnections,
+        Predicate<ProtobufDiscoveryNode> nodePredicate,
+        List<String> configuredSeedNodes
+    ) {
+        this(
+            clusterAlias,
+            transportService,
+            connectionManager,
+            proxyAddress,
+            settings,
+            maxNumRemoteConnections,
+            nodePredicate,
+            configuredSeedNodes,
+            configuredSeedNodes.stream()
+                .map(seedAddress -> (Supplier<ProtobufDiscoveryNode>) () -> resolveSeedNode(clusterAlias, seedAddress, proxyAddress))
+                .collect(Collectors.toList())
+        );
+    }
+
+    ProtobufSniffConnectionStrategy(
+        String clusterAlias,
+        ProtobufTransportService transportService,
+        ProtobufRemoteConnectionManager connectionManager,
+        String proxyAddress,
+        Settings settings,
+        int maxNumRemoteConnections,
+        Predicate<ProtobufDiscoveryNode> nodePredicate,
+        List<String> configuredSeedNodes,
+        List<Supplier<ProtobufDiscoveryNode>> seedNodes
+    ) {
+        super(clusterAlias, transportService, connectionManager, settings);
+        this.proxyAddress = proxyAddress;
+        this.maxNumRemoteConnections = maxNumRemoteConnections;
+        this.nodePredicate = nodePredicate;
+        this.configuredSeedNodes = configuredSeedNodes;
+        this.seedNodes = seedNodes;
+    }
+
+    static Stream<Setting.AffixSetting<?>> enablementSettings() {
+        return Stream.of(ProtobufSniffConnectionStrategy.REMOTE_CLUSTER_SEEDS);
+    }
+
+    static ProtobufWriteable.Reader<ProtobufRemoteConnectionInfo.ModeInfo> infoReader() {
+        return SniffModeInfo::new;
+    }
+
+    @Override
+    protected boolean shouldOpenMoreConnections() {
+        return connectionManager.size() < maxNumRemoteConnections;
+    }
+
+    @Override
+    protected boolean strategyMustBeRebuilt(Settings newSettings) {
+        String proxy = REMOTE_CLUSTERS_PROXY.getConcreteSettingForNamespace(clusterAlias).get(newSettings);
+        List<String> addresses = REMOTE_CLUSTER_SEEDS.getConcreteSettingForNamespace(clusterAlias).get(newSettings);
+        int nodeConnections = REMOTE_NODE_CONNECTIONS.getConcreteSettingForNamespace(clusterAlias).get(newSettings);
+        return nodeConnections != maxNumRemoteConnections
+            || seedsChanged(configuredSeedNodes, addresses)
+            || proxyChanged(proxyAddress, proxy);
+    }
+
+    @Override
+    protected ProtobufConnectionStrategy strategyType() {
+        return ProtobufConnectionStrategy.SNIFF;
+    }
+
+    @Override
+    protected void connectImpl(ActionListener<Void> listener) {
+        collectRemoteNodes(seedNodes.iterator(), listener);
+    }
+
+    @Override
+    protected ProtobufRemoteConnectionInfo.ModeInfo getModeInfo() {
+        return new SniffModeInfo(configuredSeedNodes, maxNumRemoteConnections, connectionManager.size());
+    }
+
+    private void collectRemoteNodes(Iterator<Supplier<ProtobufDiscoveryNode>> seedNodes, ActionListener<Void> listener) {
+        if (Thread.currentThread().isInterrupted()) {
+            listener.onFailure(new InterruptedException("remote connect thread got interrupted"));
+            return;
+        }
+
+        if (seedNodes.hasNext()) {
+            final Consumer<Exception> onFailure = e -> {
+                if (e instanceof ConnectTransportException || e instanceof IOException || e instanceof IllegalStateException) {
+                    // ISE if we fail the handshake with an version incompatible node
+                    if (seedNodes.hasNext()) {
+                        logger.debug(
+                            () -> new ParameterizedMessage(
+                                "fetching nodes from external cluster [{}] failed moving to next seed node",
+                                clusterAlias
+                            ),
+                            e
+                        );
+                        collectRemoteNodes(seedNodes, listener);
+                        return;
+                    }
+                }
+                logger.warn(new ParameterizedMessage("fetching nodes from external cluster [{}] failed", clusterAlias), e);
+                listener.onFailure(e);
+            };
+
+            final ProtobufDiscoveryNode seedNode = seedNodes.next().get();
+            logger.trace("[{}] opening transient connection to seed node: [{}]", clusterAlias, seedNode);
+            final StepListener<ProtobufTransport.Connection> openConnectionStep = new StepListener<>();
+            try {
+                connectionManager.openConnection(seedNode, null, openConnectionStep);
+            } catch (Exception e) {
+                onFailure.accept(e);
+            }
+
+            final StepListener<ProtobufTransportService.HandshakeResponse> handshakeStep = new StepListener<>();
+            openConnectionStep.whenComplete(connection -> {
+                ProtobufConnectionProfile connectionProfile = connectionManager.getConnectionProfile();
+                transportService.handshake(
+                    connection,
+                    connectionProfile.getHandshakeTimeout().millis(),
+                    getRemoteClusterNamePredicate(),
+                    handshakeStep
+                );
+            }, onFailure);
+
+            final StepListener<Void> fullConnectionStep = new StepListener<>();
+            handshakeStep.whenComplete(handshakeResponse -> {
+                final ProtobufDiscoveryNode handshakeNode = handshakeResponse.getDiscoveryNode();
+
+                if (nodePredicate.test(handshakeNode) && shouldOpenMoreConnections()) {
+                    logger.trace(
+                        "[{}] opening managed connection to seed node: [{}] proxy address: [{}]",
+                        clusterAlias,
+                        handshakeNode,
+                        proxyAddress
+                    );
+                    final ProtobufDiscoveryNode handshakeNodeWithProxy = maybeAddProxyAddress(proxyAddress, handshakeNode);
+                    connectionManager.connectToNode(
+                        handshakeNodeWithProxy,
+                        null,
+                        transportService.connectionValidator(handshakeNodeWithProxy),
+                        fullConnectionStep
+                    );
+                } else {
+                    fullConnectionStep.onResponse(null);
+                }
+            }, e -> {
+                final ProtobufTransport.Connection connection = openConnectionStep.result();
+                final ProtobufDiscoveryNode node = connection.getNode();
+                logger.debug(() -> new ParameterizedMessage("[{}] failed to handshake with seed node: [{}]", clusterAlias, node), e);
+                IOUtils.closeWhileHandlingException(connection);
+                onFailure.accept(e);
+            });
+
+            fullConnectionStep.whenComplete(aVoid -> {
+                if (remoteClusterName.get() == null) {
+                    ProtobufTransportService.HandshakeResponse handshakeResponse = handshakeStep.result();
+                    assert handshakeResponse.getClusterName().value() != null;
+                    remoteClusterName.set(handshakeResponse.getClusterName());
+                }
+                final ProtobufTransport.Connection connection = openConnectionStep.result();
+
+                ProtobufClusterStateRequest request = new ProtobufClusterStateRequest();
+                request.clear();
+                request.nodes(true);
+                // here we pass on the connection since we can only close it once the sendRequest returns otherwise
+                // due to the async nature (it will return before it's actually sent) this can cause the request to fail
+                // due to an already closed connection.
+                ProtobufThreadPool threadPool = transportService.getThreadPool();
+                ThreadContext threadContext = threadPool.getThreadContext();
+                ProtobufTransportService.ContextRestoreResponseHandler<ProtobufClusterStateResponse> responseHandler =
+                    new ProtobufTransportService.ContextRestoreResponseHandler<>(
+                        threadContext.newRestorableContext(false),
+                        new SniffClusterStateResponseHandler(connection, listener, seedNodes)
+                    );
+                try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
+                    // we stash any context here since this is an internal execution and should not leak any
+                    // existing context information.
+                    threadContext.markAsSystemContext();
+                    transportService.sendRequest(
+                        connection,
+                        ClusterStateAction.NAME,
+                        request,
+                        TransportRequestOptions.EMPTY,
+                        responseHandler
+                    );
+                }
+            }, e -> {
+                final ProtobufTransport.Connection connection = openConnectionStep.result();
+                final ProtobufDiscoveryNode node = connection.getNode();
+                logger.debug(
+                    () -> new ParameterizedMessage("[{}] failed to open managed connection to seed node: [{}]", clusterAlias, node),
+                    e
+                );
+                IOUtils.closeWhileHandlingException(openConnectionStep.result());
+                onFailure.accept(e);
+            });
+        } else {
+            listener.onFailure(new NoSeedNodeLeftException(clusterAlias));
+        }
+    }
+
+    /* This class handles the _state response from the remote cluster when sniffing nodes to connect to */
+    private class SniffClusterStateResponseHandler implements ProtobufTransportResponseHandler<ProtobufClusterStateResponse> {
+
+        private final ProtobufTransport.Connection connection;
+        private final ActionListener<Void> listener;
+        private final Iterator<Supplier<ProtobufDiscoveryNode>> seedNodes;
+
+        SniffClusterStateResponseHandler(
+            ProtobufTransport.Connection connection,
+            ActionListener<Void> listener,
+            Iterator<Supplier<ProtobufDiscoveryNode>> seedNodes
+        ) {
+            this.connection = connection;
+            this.listener = listener;
+            this.seedNodes = seedNodes;
+        }
+
+        @Override
+        public ProtobufClusterStateResponse read(CodedInputStream in) throws IOException {
+            return new ProtobufClusterStateResponse(in);
+        }
+
+        @Override
+        public void handleResponse(ProtobufClusterStateResponse response) {
+            handleNodes(response.getState().nodes().getNodes().valuesIt());
+        }
+
+        private void handleNodes(Iterator<ProtobufDiscoveryNode> nodesIter) {
+            while (nodesIter.hasNext()) {
+                final ProtobufDiscoveryNode node = nodesIter.next();
+                if (nodePredicate.test(node) && shouldOpenMoreConnections()) {
+                    logger.trace("[{}] opening managed connection to node: [{}] proxy address: [{}]", clusterAlias, node, proxyAddress);
+                    final ProtobufDiscoveryNode nodeWithProxy = maybeAddProxyAddress(proxyAddress, node);
+                    connectionManager.connectToNode(
+                        nodeWithProxy,
+                        null,
+                        transportService.connectionValidator(node),
+                        new ActionListener<Void>() {
+                            @Override
+                            public void onResponse(Void aVoid) {
+                                handleNodes(nodesIter);
+                            }
+
+                            @Override
+                            public void onFailure(Exception e) {
+                                if (e instanceof ConnectTransportException || e instanceof IllegalStateException) {
+                                    // ISE if we fail the handshake with an version incompatible node
+                                    // fair enough we can't connect just move on
+                                    logger.debug(
+                                        () -> new ParameterizedMessage(
+                                            "[{}] failed to open managed connection to node [{}]",
+                                            clusterAlias,
+                                            node
+                                        ),
+                                        e
+                                    );
+                                    handleNodes(nodesIter);
+                                } else {
+                                    logger.warn(
+                                        new ParameterizedMessage("[{}] failed to open managed connection to node [{}]", clusterAlias, node),
+                                        e
+                                    );
+                                    IOUtils.closeWhileHandlingException(connection);
+                                    collectRemoteNodes(seedNodes, listener);
+                                }
+                            }
+                        }
+                    );
+                    return;
+                }
+            }
+            // We have to close this connection before we notify listeners - this is mainly needed for test correctness
+            // since if we do it afterwards we might fail assertions that check if all high level connections are closed.
+            // from a code correctness perspective we could also close it afterwards.
+            IOUtils.closeWhileHandlingException(connection);
+            int openConnections = connectionManager.size();
+            if (openConnections == 0) {
+                listener.onFailure(new IllegalStateException("Unable to open any connections to remote cluster [" + clusterAlias + "]"));
+            } else {
+                listener.onResponse(null);
+            }
+        }
+
+        @Override
+        public void handleException(ProtobufTransportException exp) {
+            logger.warn(new ParameterizedMessage("fetching nodes from external cluster {} failed", clusterAlias), exp);
+            try {
+                IOUtils.closeWhileHandlingException(connection);
+            } finally {
+                // once the connection is closed lets try the next node
+                collectRemoteNodes(seedNodes, listener);
+            }
+        }
+
+        @Override
+        public String executor() {
+            return ProtobufThreadPool.Names.MANAGEMENT;
+        }
+    }
+
+    private Predicate<ProtobufClusterName> getRemoteClusterNamePredicate() {
+        return new Predicate<ProtobufClusterName>() {
+            @Override
+            public boolean test(ProtobufClusterName c) {
+                return remoteClusterName.get() == null || c.equals(remoteClusterName.get());
+            }
+
+            @Override
+            public String toString() {
+                return remoteClusterName.get() == null
+                    ? "any cluster name"
+                    : "expected remote cluster name [" + remoteClusterName.get().value() + "]";
+            }
+        };
+    }
+
+    private static ProtobufDiscoveryNode resolveSeedNode(String clusterAlias, String address, String proxyAddress) {
+        if (proxyAddress == null || proxyAddress.isEmpty()) {
+            ProtobufTransportAddress transportAddress = new ProtobufTransportAddress(parseConfiguredAddress(address));
+            return new ProtobufDiscoveryNode(
+                clusterAlias + "#" + transportAddress.toString(),
+                transportAddress,
+                Version.CURRENT.minimumCompatibilityVersion()
+            );
+        } else {
+            ProtobufTransportAddress transportAddress = new ProtobufTransportAddress(parseConfiguredAddress(proxyAddress));
+            String hostName = ProtobufRemoteConnectionStrategy.parseHost(proxyAddress);
+            return new ProtobufDiscoveryNode(
+                "",
+                clusterAlias + "#" + address,
+                UUIDs.randomBase64UUID(),
+                hostName,
+                address,
+                transportAddress,
+                Collections.singletonMap("server_name", hostName),
+                DiscoveryNodeRole.BUILT_IN_ROLES,
+                Version.CURRENT.minimumCompatibilityVersion()
+            );
+        }
+    }
+
+    // Default visibility for tests
+    static Predicate<ProtobufDiscoveryNode> getNodePredicate(Settings settings) {
+        if (RemoteClusterService.REMOTE_NODE_ATTRIBUTE.exists(settings)) {
+            // nodes can be tagged with node.attr.remote_gateway: true to allow a node to be a gateway node for cross cluster search
+            String attribute = RemoteClusterService.REMOTE_NODE_ATTRIBUTE.get(settings);
+            return DEFAULT_NODE_PREDICATE.and((node) -> Booleans.parseBoolean(node.getAttributes().getOrDefault(attribute, "false")));
+        }
+        return DEFAULT_NODE_PREDICATE;
+    }
+
+    private static ProtobufDiscoveryNode maybeAddProxyAddress(String proxyAddress, ProtobufDiscoveryNode node) {
+        if (proxyAddress == null || proxyAddress.isEmpty()) {
+            return node;
+        } else {
+            // resolve proxy address lazy here
+            InetSocketAddress proxyInetAddress = parseConfiguredAddress(proxyAddress);
+            return new ProtobufDiscoveryNode(
+                node.getName(),
+                node.getId(),
+                node.getEphemeralId(),
+                node.getHostName(),
+                node.getHostAddress(),
+                new ProtobufTransportAddress(proxyInetAddress),
+                node.getAttributes(),
+                node.getRoles(),
+                node.getVersion()
+            );
+        }
+    }
+
+    private boolean seedsChanged(final List<String> oldSeedNodes, final List<String> newSeedNodes) {
+        if (oldSeedNodes.size() != newSeedNodes.size()) {
+            return true;
+        }
+        Set<String> oldSeeds = new HashSet<>(oldSeedNodes);
+        Set<String> newSeeds = new HashSet<>(newSeedNodes);
+        return oldSeeds.equals(newSeeds) == false;
+    }
+
+    private boolean proxyChanged(String oldProxy, String newProxy) {
+        if (oldProxy == null || oldProxy.isEmpty()) {
+            return (newProxy == null || newProxy.isEmpty()) == false;
+        }
+
+        return Objects.equals(oldProxy, newProxy) == false;
+    }
+
+    /**
+     * Information about the sniff mode
+    *
+    * @opensearch.internal
+    */
+    public static class SniffModeInfo implements ProtobufRemoteConnectionInfo.ModeInfo {
+
+        final List<String> seedNodes;
+        final int maxConnectionsPerCluster;
+        final int numNodesConnected;
+
+        public SniffModeInfo(List<String> seedNodes, int maxConnectionsPerCluster, int numNodesConnected) {
+            this.seedNodes = seedNodes;
+            this.maxConnectionsPerCluster = maxConnectionsPerCluster;
+            this.numNodesConnected = numNodesConnected;
+        }
+
+        private SniffModeInfo(CodedInputStream input) throws IOException {
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(input);
+            seedNodes = Arrays.asList(protobufStreamInput.readStringArray());
+            maxConnectionsPerCluster = protobufStreamInput.readVInt();
+            numNodesConnected = protobufStreamInput.readVInt();
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.startArray("seeds");
+            for (String address : seedNodes) {
+                builder.value(address);
+            }
+            builder.endArray();
+            builder.field("num_nodes_connected", numNodesConnected);
+            builder.field("max_connections_per_cluster", maxConnectionsPerCluster);
+            return builder;
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+            protobufStreamOutput.writeStringArray(seedNodes.toArray(new String[0]));
+            out.writeInt32NoTag(maxConnectionsPerCluster);
+            out.writeInt32NoTag(numNodesConnected);
+        }
+
+        @Override
+        public boolean isConnected() {
+            return numNodesConnected > 0;
+        }
+
+        @Override
+        public String modeName() {
+            return "sniff";
+        }
+
+        public List<String> getSeedNodes() {
+            return seedNodes;
+        }
+
+        public int getMaxConnectionsPerCluster() {
+            return maxConnectionsPerCluster;
+        }
+
+        public int getNumNodesConnected() {
+            return numNodesConnected;
+        }
+
+        @Override
+        public ProtobufRemoteConnectionStrategy.ProtobufConnectionStrategy modeType() {
+            return ProtobufRemoteConnectionStrategy.ProtobufConnectionStrategy.SNIFF;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            SniffModeInfo sniff = (SniffModeInfo) o;
+            return maxConnectionsPerCluster == sniff.maxConnectionsPerCluster
+                && numNodesConnected == sniff.numNodesConnected
+                && Objects.equals(seedNodes, sniff.seedNodes);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(seedNodes, maxConnectionsPerCluster, numNodesConnected);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTcpTransportChannel.java b/server/src/main/java/org/opensearch/transport/ProtobufTcpTransportChannel.java
index 81aa03275d263..03daaec9409a9 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTcpTransportChannel.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTcpTransportChannel.java
@@ -10,8 +10,6 @@
 
 import org.opensearch.Version;
 import org.opensearch.common.lease.Releasable;
-import org.opensearch.search.query.QuerySearchResult;
-
 import java.io.IOException;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -24,7 +22,7 @@
 public final class ProtobufTcpTransportChannel implements ProtobufTransportChannel {
 
     private final AtomicBoolean released = new AtomicBoolean();
-    private final OutboundHandler outboundHandler;
+    private final ProtobufOutboundHandler outboundHandler;
     private final TcpChannel channel;
     private final String action;
     private final long requestId;
@@ -35,7 +33,7 @@ public final class ProtobufTcpTransportChannel implements ProtobufTransportChann
     private final Releasable breakerRelease;
 
     ProtobufTcpTransportChannel(
-        OutboundHandler outboundHandler,
+        ProtobufOutboundHandler outboundHandler,
         TcpChannel channel,
         String action,
         long requestId,
@@ -65,8 +63,8 @@ public String getProfileName() {
     public void sendResponse(ProtobufTransportResponse response) throws IOException {
         try {
             // if (response instanceof QuerySearchResult && ((QuerySearchResult) response).getShardSearchRequest() != null) {
-            //     // update outbound network time with current time before sending response over network
-            //     ((QuerySearchResult) response).getShardSearchRequest().setOutboundNetworkTime(System.currentTimeMillis());
+            // // update outbound network time with current time before sending response over network
+            // ((QuerySearchResult) response).getShardSearchRequest().setOutboundNetworkTime(System.currentTimeMillis());
             // }
             outboundHandler.sendResponse(version, features, channel, requestId, action, response, compressResponse, isHandshake);
         } finally {
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransport.java b/server/src/main/java/org/opensearch/transport/ProtobufTransport.java
index 08d0ad17de49c..9a9890255fa67 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransport.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransport.java
@@ -10,11 +10,11 @@
 
 import org.opensearch.Version;
 import org.opensearch.action.ActionListener;
-import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
 import org.opensearch.common.collect.MapBuilder;
 import org.opensearch.common.component.LifecycleComponent;
 import org.opensearch.common.transport.ProtobufBoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.ConcurrentCollections;
 import org.opensearch.common.util.concurrent.ConcurrentMapLong;
@@ -39,7 +39,7 @@ public interface ProtobufTransport extends LifecycleComponent {
     /**
      * Registers a new request handler
     */
-    default <Request extends ProtobufTransportRequest> void registerRequestHandler(RequestHandlerRegistry<Request> reg) {
+    default <Request extends ProtobufTransportRequest> void registerRequestHandler(ProtobufRequestHandlerRegistry<Request> reg) {
         getRequestHandlers().registerHandler(reg);
     }
 
@@ -65,7 +65,7 @@ default boolean isSecure() {
     /**
      * Returns an address from its string representation.
     */
-    TransportAddress[] addressesFromString(String address) throws UnknownHostException;
+    ProtobufTransportAddress[] addressesFromString(String address) throws UnknownHostException;
 
     /**
      * Returns a list of all local addresses for this transport
@@ -76,7 +76,11 @@ default boolean isSecure() {
      * Opens a new connection to the given node. When the connection is fully connected, the listener is called.
     * The ActionListener will be called on the calling thread or the generic thread pool.
     */
-    void openConnection(DiscoveryNode node, ConnectionProfile profile, ActionListener<ProtobufTransport.Connection> listener);
+    void openConnection(
+        ProtobufDiscoveryNode node,
+        ProtobufConnectionProfile profile,
+        ActionListener<ProtobufTransport.Connection> listener
+    );
 
     TransportStats getStats();
 
@@ -85,13 +89,13 @@ default boolean isSecure() {
     RequestHandlers getRequestHandlers();
 
     /**
-     * A unidirectional connection to a {@link DiscoveryNode}
+     * A unidirectional connection to a {@link ProtobufDiscoveryNode}
     */
     interface Connection extends Closeable {
         /**
          * The node this connection is associated with
         */
-        DiscoveryNode getNode();
+        ProtobufDiscoveryNode getNode();
 
         /**
          * Sends the request to the node this connection is associated with
@@ -101,8 +105,8 @@ interface Connection extends Closeable {
         * @param options request options to apply
         * @throws NodeNotConnectedException if the given node is not connected
         */
-        void sendRequest(long requestId, String action, ProtobufTransportRequest request, TransportRequestOptions options) throws IOException,
-            TransportException;
+        void sendRequest(long requestId, String action, ProtobufTransportRequest request, TransportRequestOptions options)
+            throws IOException, TransportException;
 
         /**
          * The listener's {@link ActionListener#onResponse(Object)} method will be called when this
@@ -138,21 +142,21 @@ default Object getCacheKey() {
      * This class represents a response context that encapsulates the actual response handler, the action and the connection it was
     * executed on.
     */
-    final class ResponseContext<T extends TransportResponse> {
+    final class ResponseContext<T extends ProtobufTransportResponse> {
 
-        private final TransportResponseHandler<T> handler;
+        private final ProtobufTransportResponseHandler<T> handler;
 
         private final Connection connection;
 
         private final String action;
 
-        ResponseContext(TransportResponseHandler<T> handler, Connection connection, String action) {
+        ResponseContext(ProtobufTransportResponseHandler<T> handler, Connection connection, String action) {
             this.handler = handler;
             this.connection = connection;
             this.action = action;
         }
 
-        public TransportResponseHandler<T> handler() {
+        public ProtobufTransportResponseHandler<T> handler() {
             return handler;
         }
 
@@ -169,7 +173,7 @@ public String action() {
      * This class is a registry that allows
     */
     final class ResponseHandlers {
-        private final ConcurrentMapLong<ResponseContext<? extends TransportResponse>> handlers = ConcurrentCollections
+        private final ConcurrentMapLong<ResponseContext<? extends ProtobufTransportResponse>> handlers = ConcurrentCollections
             .newConcurrentMapLongWithAggressiveConcurrency();
         private final AtomicLong requestIdGenerator = new AtomicLong();
 
@@ -184,7 +188,7 @@ public boolean contains(long requestId) {
          * Removes and return the {@link ResponseContext} for the given request ID or returns
         * <code>null</code> if no context is associated with this request ID.
         */
-        public ResponseContext<? extends TransportResponse> remove(long requestId) {
+        public ResponseContext<? extends ProtobufTransportResponse> remove(long requestId) {
             return handlers.remove(requestId);
         }
 
@@ -193,9 +197,9 @@ public ResponseContext<? extends TransportResponse> remove(long requestId) {
         * @return the new request ID
         * @see Connection#sendRequest(long, String, ProtobufTransportRequest, TransportRequestOptions)
         */
-        public long add(ResponseContext<? extends TransportResponse> holder) {
+        public long add(ResponseContext<? extends ProtobufTransportResponse> holder) {
             long requestId = newRequestId();
-            ResponseContext<? extends TransportResponse> existing = handlers.put(requestId, holder);
+            ResponseContext<? extends ProtobufTransportResponse> existing = handlers.put(requestId, holder);
             assert existing == null : "request ID already in use: " + requestId;
             return requestId;
         }
@@ -211,12 +215,14 @@ long newRequestId() {
         /**
          * Removes and returns all {@link ResponseContext} instances that match the predicate
         */
-        public List<ResponseContext<? extends TransportResponse>> prune(Predicate<ResponseContext<? extends TransportResponse>> predicate) {
-            final List<ResponseContext<? extends TransportResponse>> holders = new ArrayList<>();
-            for (Map.Entry<Long, ResponseContext<? extends TransportResponse>> entry : handlers.entrySet()) {
-                ResponseContext<? extends TransportResponse> holder = entry.getValue();
+        public List<ResponseContext<? extends ProtobufTransportResponse>> prune(
+            Predicate<ResponseContext<? extends ProtobufTransportResponse>> predicate
+        ) {
+            final List<ResponseContext<? extends ProtobufTransportResponse>> holders = new ArrayList<>();
+            for (Map.Entry<Long, ResponseContext<? extends ProtobufTransportResponse>> entry : handlers.entrySet()) {
+                ResponseContext<? extends ProtobufTransportResponse> holder = entry.getValue();
                 if (predicate.test(holder)) {
-                    ResponseContext<? extends TransportResponse> remove = handlers.remove(entry.getKey());
+                    ResponseContext<? extends ProtobufTransportResponse> remove = handlers.remove(entry.getKey());
                     if (remove != null) {
                         holders.add(holder);
                     }
@@ -230,11 +236,11 @@ public List<ResponseContext<? extends TransportResponse>> prune(Predicate<Respon
         * sent request (before any processing or deserialization was done). Returns the appropriate response handler or null if not
         * found.
         */
-        public TransportResponseHandler<? extends TransportResponse> onResponseReceived(
+        public ProtobufTransportResponseHandler<? extends ProtobufTransportResponse> onResponseReceived(
             final long requestId,
             final ProtobufTransportMessageListener listener
         ) {
-            ResponseContext<? extends TransportResponse> context = handlers.remove(requestId);
+            ResponseContext<? extends ProtobufTransportResponse> context = handlers.remove(requestId);
             listener.onResponseReceived(requestId, context);
             if (context == null) {
                 return null;
@@ -251,9 +257,10 @@ public TransportResponseHandler<? extends TransportResponse> onResponseReceived(
     */
     final class RequestHandlers {
 
-        private volatile Map<String, RequestHandlerRegistry<? extends ProtobufTransportRequest>> requestHandlers = Collections.emptyMap();
+        private volatile Map<String, ProtobufRequestHandlerRegistry<? extends ProtobufTransportRequest>> requestHandlers = Collections
+            .emptyMap();
 
-        synchronized <Request extends ProtobufTransportRequest> void registerHandler(RequestHandlerRegistry<Request> reg) {
+        synchronized <Request extends ProtobufTransportRequest> void registerHandler(ProtobufRequestHandlerRegistry<Request> reg) {
             if (requestHandlers.containsKey(reg.getAction())) {
                 throw new IllegalArgumentException("transport handlers for action " + reg.getAction() + " is already registered");
             }
@@ -262,13 +269,13 @@ synchronized <Request extends ProtobufTransportRequest> void registerHandler(Req
 
         // TODO: Only visible for testing. Perhaps move StubbableTransport from
         // org.opensearch.test.transport to org.opensearch.transport
-        public synchronized <Request extends ProtobufTransportRequest> void forceRegister(RequestHandlerRegistry<Request> reg) {
+        public synchronized <Request extends ProtobufTransportRequest> void forceRegister(ProtobufRequestHandlerRegistry<Request> reg) {
             requestHandlers = MapBuilder.newMapBuilder(requestHandlers).put(reg.getAction(), reg).immutableMap();
         }
 
         @SuppressWarnings("unchecked")
-        public <T extends ProtobufTransportRequest> RequestHandlerRegistry<T> getHandler(String action) {
-            return (RequestHandlerRegistry<T>) requestHandlers.get(action);
+        public <T extends ProtobufTransportRequest> ProtobufRequestHandlerRegistry<T> getHandler(String action) {
+            return (ProtobufRequestHandlerRegistry<T>) requestHandlers.get(action);
         }
     }
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java
new file mode 100644
index 0000000000000..5c0fdea673c9d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java
@@ -0,0 +1,226 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.tasks.ProtobufTask;
+import org.opensearch.threadpool.ProtobufThreadPool;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.util.function.Function;
+
+/**
+ * ProtobufTransportActionProxy allows an arbitrary action to be executed on a defined target node while the initial request is sent to a second
+* node that acts as a request proxy to the target node. This is useful if a node is not directly connected to a target node but is
+* connected to an intermediate node that establishes a transitive connection.
+*
+* @opensearch.internal
+*/
+public final class ProtobufTransportActionProxy {
+
+    private ProtobufTransportActionProxy() {} // no instance
+
+    /**
+     * Handler for proxy requests
+    *
+    * @opensearch.internal
+    */
+    private static class ProxyRequestHandler<T extends ProxyRequest> implements ProtobufTransportRequestHandler<T> {
+
+        private final ProtobufTransportService service;
+        private final String action;
+        private final Function<ProtobufTransportRequest, ProtobufWriteable.Reader<? extends ProtobufTransportResponse>> responseFunction;
+
+        ProxyRequestHandler(
+            ProtobufTransportService service,
+            String action,
+            Function<ProtobufTransportRequest, ProtobufWriteable.Reader<? extends ProtobufTransportResponse>> responseFunction
+        ) {
+            this.service = service;
+            this.action = action;
+            this.responseFunction = responseFunction;
+        }
+
+        @Override
+        public void messageReceived(T request, ProtobufTransportChannel channel, ProtobufTask task) throws Exception {
+            ProtobufDiscoveryNode targetNode = request.targetNode;
+            ProtobufTransportRequest wrappedRequest = request.wrapped;
+            service.sendRequest(
+                targetNode,
+                action,
+                wrappedRequest,
+                new ProxyResponseHandler<>(channel, responseFunction.apply(wrappedRequest))
+            );
+        }
+    }
+
+    /**
+     * Handler for the proxy response
+    *
+    * @opensearch.internal
+    */
+    private static class ProxyResponseHandler<T extends ProtobufTransportResponse> implements ProtobufTransportResponseHandler<T> {
+
+        private final ProtobufWriteable.Reader<T> reader;
+        private final ProtobufTransportChannel channel;
+
+        ProxyResponseHandler(ProtobufTransportChannel channel, ProtobufWriteable.Reader<T> reader) {
+            this.reader = reader;
+            this.channel = channel;
+        }
+
+        @Override
+        public T read(CodedInputStream in) throws IOException {
+            return reader.read(in);
+        }
+
+        @Override
+        public void handleResponse(T response) {
+            try {
+                channel.sendResponse(response);
+            } catch (IOException e) {
+                throw new UncheckedIOException(e);
+            }
+        }
+
+        @Override
+        public void handleException(ProtobufTransportException exp) {
+            try {
+                channel.sendResponse(exp);
+            } catch (IOException e) {
+                throw new UncheckedIOException(e);
+            }
+        }
+
+        @Override
+        public String executor() {
+            return ProtobufThreadPool.Names.SAME;
+        }
+    }
+
+    /**
+     * The proxy request
+    *
+    * @opensearch.internal
+    */
+    static class ProxyRequest<T extends ProtobufTransportRequest> extends ProtobufTransportRequest {
+        final T wrapped;
+        final ProtobufDiscoveryNode targetNode;
+
+        ProxyRequest(T wrapped, ProtobufDiscoveryNode targetNode) {
+            this.wrapped = wrapped;
+            this.targetNode = targetNode;
+        }
+
+        ProxyRequest(CodedInputStream in, ProtobufWriteable.Reader<T> reader) throws IOException {
+            super(in);
+            targetNode = new ProtobufDiscoveryNode(in);
+            wrapped = reader.read(in);
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            super.writeTo(out);
+            targetNode.writeTo(out);
+            wrapped.writeTo(out);
+        }
+    }
+
+    /**
+     * Registers a proxy request handler that allows to forward requests for the given action to another node. To be used when the
+    * response type changes based on the upcoming request (quite rare)
+    */
+    public static void registerProxyActionWithDynamicResponseType(
+        ProtobufTransportService service,
+        String action,
+        Function<ProtobufTransportRequest, ProtobufWriteable.Reader<? extends ProtobufTransportResponse>> responseFunction
+    ) {
+        ProtobufRequestHandlerRegistry<? extends ProtobufTransportRequest> requestHandler = service.getRequestHandler(action);
+        service.registerRequestHandler(
+            getProxyAction(action),
+            ProtobufThreadPool.Names.SAME,
+            true,
+            false,
+            in -> new ProxyRequest<>(in, requestHandler::newRequest),
+            new ProxyRequestHandler<>(service, action, responseFunction)
+        );
+    }
+
+    /**
+     * Registers a proxy request handler that allows to forward requests for the given action to another node. To be used when the
+    * response type is always the same (most of the cases).
+    */
+    public static void registerProxyAction(
+        ProtobufTransportService service,
+        String action,
+        ProtobufWriteable.Reader<? extends ProtobufTransportResponse> reader
+    ) {
+        ProtobufRequestHandlerRegistry<? extends ProtobufTransportRequest> requestHandler = service.getRequestHandler(action);
+        service.registerRequestHandler(
+            getProxyAction(action),
+            ProtobufThreadPool.Names.SAME,
+            true,
+            false,
+            in -> new ProxyRequest<>(in, requestHandler::newRequest),
+            new ProxyRequestHandler<>(service, action, request -> reader)
+        );
+    }
+
+    private static final String PROXY_ACTION_PREFIX = "internal:transport/proxy/";
+
+    /**
+     * Returns the corresponding proxy action for the given action
+    */
+    public static String getProxyAction(String action) {
+        return PROXY_ACTION_PREFIX + action;
+    }
+
+    /**
+     * Wraps the actual request in a proxy request object that encodes the target node.
+    */
+    public static ProtobufTransportRequest wrapRequest(ProtobufDiscoveryNode node, ProtobufTransportRequest request) {
+        return new ProxyRequest<>(request, node);
+    }
+
+    /**
+     * Unwraps a proxy request and returns the original request
+    */
+    public static ProtobufTransportRequest unwrapRequest(ProtobufTransportRequest request) {
+        if (request instanceof ProxyRequest) {
+            return ((ProxyRequest) request).wrapped;
+        }
+        return request;
+    }
+
+    /**
+     * Unwraps a proxy action and returns the underlying action
+    */
+    public static String unwrapAction(String action) {
+        assert isProxyAction(action) : "Attempted to unwrap non-proxy action: " + action;
+        return action.substring(PROXY_ACTION_PREFIX.length());
+    }
+
+    /**
+     * Returns <code>true</code> iff the given action is a proxy action
+    */
+    public static boolean isProxyAction(String action) {
+        return action.startsWith(PROXY_ACTION_PREFIX);
+    }
+
+    /**
+     * Returns <code>true</code> iff the given request is a proxy request
+    */
+    public static boolean isProxyRequest(ProtobufTransportRequest request) {
+        return request instanceof ProxyRequest;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java
new file mode 100644
index 0000000000000..2f348b72e1a5a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java
@@ -0,0 +1,43 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+
+/**
+ * A listener interface that allows to react on transport events. All methods may be
+* executed on network threads. Consumers must fork in the case of long running or blocking
+* operations.
+*
+* @opensearch.internal
+*/
+public interface ProtobufTransportConnectionListener {
+
+    /**
+     * Called once a connection was opened
+    * @param connection the connection
+    */
+    default void onConnectionOpened(ProtobufTransport.Connection connection) {}
+
+    /**
+     * Called once a connection ws closed.
+    * @param connection the closed connection
+    */
+    default void onConnectionClosed(ProtobufTransport.Connection connection) {}
+
+    /**
+     * Called once a node connection is opened and registered.
+    */
+    default void onNodeConnected(ProtobufDiscoveryNode node, ProtobufTransport.Connection connection) {}
+
+    /**
+     * Called once a node connection is closed and unregistered.
+    */
+    default void onNodeDisconnected(ProtobufDiscoveryNode node, ProtobufTransport.Connection connection) {}
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportException.java
new file mode 100644
index 0000000000000..42bca65d8c1fd
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportException.java
@@ -0,0 +1,37 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import org.opensearch.ProtobufOpenSearchException;
+
+import java.io.IOException;
+
+/**
+ * Thrown for any transport errors
+*
+* @opensearch.internal
+*/
+public class ProtobufTransportException extends ProtobufOpenSearchException {
+    public ProtobufTransportException(Throwable cause) {
+        super(cause);
+    }
+
+    public ProtobufTransportException(CodedInputStream in) throws IOException {
+        super(in);
+    }
+
+    public ProtobufTransportException(String msg) {
+        super(msg);
+    }
+
+    public ProtobufTransportException(String msg, Throwable cause) {
+        super(msg, cause);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java
new file mode 100644
index 0000000000000..2476882515de1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java
@@ -0,0 +1,59 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.common.io.stream.ProtobufWriteable.Reader;
+
+/**
+ * This interface allows plugins to intercept requests on both the sender and the receiver side.
+*
+* @opensearch.internal
+*/
+public interface ProtobufTransportInterceptor {
+    /**
+     * This is called for each handler that is registered via
+    * {@link ProtobufTransportService#registerRequestHandler(String, String, boolean, boolean, Reader, ProtobufTransportRequestHandler)} or
+    * {@link ProtobufTransportService#registerRequestHandler(String, String, Reader, ProtobufTransportRequestHandler)}. The returned handler is
+    * used instead of the passed in handler. By default the provided handler is returned.
+    */
+    default <T extends ProtobufTransportRequest> ProtobufTransportRequestHandler<T> interceptHandler(
+        String action,
+        String executor,
+        boolean forceExecution,
+        ProtobufTransportRequestHandler<T> actualHandler
+    ) {
+        return actualHandler;
+    }
+
+    /**
+     * This is called up-front providing the actual low level {@link AsyncSender} that performs the low level send request.
+    * The returned sender is used to send all requests that come in via
+    * {@link ProtobufTransportService#sendRequest(ProtobufDiscoveryNode, String, ProtobufTransportRequest, ProtobufTransportResponseHandler)} or
+    * {@link ProtobufTransportService#sendRequest(ProtobufDiscoveryNode, String, ProtobufTransportRequest, TransportRequestOptions, ProtobufTransportResponseHandler)}.
+    * This allows plugins to perform actions on each send request including modifying the request context etc.
+    */
+    default AsyncSender interceptSender(AsyncSender sender) {
+        return sender;
+    }
+
+    /**
+     * A simple interface to decorate
+    * {@link #sendRequest(ProtobufTransport.Connection, String, ProtobufTransportRequest, TransportRequestOptions, ProtobufTransportResponseHandler)}
+    */
+    interface AsyncSender {
+        <T extends ProtobufTransportResponse> void sendRequest(
+            ProtobufTransport.Connection connection,
+            String action,
+            ProtobufTransportRequest request,
+            TransportRequestOptions options,
+            ProtobufTransportResponseHandler<T> handler
+        );
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportRequestHandler.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportRequestHandler.java
index 6eb9b7fd72f4e..abfc5c91e7645 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportRequestHandler.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportRequestHandler.java
@@ -9,7 +9,6 @@
 package org.opensearch.transport;
 
 import org.opensearch.tasks.ProtobufTask;
-import org.opensearch.tasks.Task;
 
 /**
  * Handles transport requests
@@ -18,5 +17,5 @@
 */
 public interface ProtobufTransportRequestHandler<T extends ProtobufTransportRequest> {
 
-    void messageReceived(T request, TransportChannel channel, ProtobufTask task) throws Exception;
+    void messageReceived(T request, ProtobufTransportChannel channel, ProtobufTask task) throws Exception;
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportResponseHandler.java
new file mode 100644
index 0000000000000..6da728b512185
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportResponseHandler.java
@@ -0,0 +1,57 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+
+import java.io.IOException;
+import java.util.function.Function;
+
+/**
+ * Handles transport responses
+*
+* @opensearch.internal
+*/
+public interface ProtobufTransportResponseHandler<T extends ProtobufTransportResponse> extends ProtobufWriteable.Reader<T> {
+
+    void handleResponse(T response);
+
+    void handleException(ProtobufTransportException exp);
+
+    String executor();
+
+    default <Q extends ProtobufTransportResponse> ProtobufTransportResponseHandler<Q> wrap(
+        Function<Q, T> converter,
+        ProtobufWriteable.Reader<Q> reader
+    ) {
+        final ProtobufTransportResponseHandler<T> self = this;
+        return new ProtobufTransportResponseHandler<Q>() {
+            @Override
+            public void handleResponse(Q response) {
+                self.handleResponse(converter.apply(response));
+            }
+
+            @Override
+            public void handleException(ProtobufTransportException exp) {
+                self.handleException(exp);
+            }
+
+            @Override
+            public String executor() {
+                return self.executor();
+            }
+
+            @Override
+            public Q read(CodedInputStream in) throws IOException {
+                return reader.read(in);
+            }
+        };
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java
index 369419be1c8f6..9f5107009d977 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java
@@ -8,39 +8,41 @@
 
 package org.opensearch.transport;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.Version;
 import org.opensearch.action.ActionListener;
-import org.opensearch.action.ActionListenerResponseHandler;
+import org.opensearch.action.ProtobufActionListenerResponseHandler;
 import org.opensearch.action.support.PlainActionFuture;
-import org.opensearch.cluster.ClusterName;
-import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.ProtobufClusterName;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.Strings;
 import org.opensearch.common.component.AbstractLifecycleComponent;
-import org.opensearch.common.io.stream.StreamInput;
-import org.opensearch.common.io.stream.StreamOutput;
-import org.opensearch.common.io.stream.Writeable;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.logging.Loggers;
 import org.opensearch.common.regex.Regex;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.transport.ProtobufBoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
 import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.common.util.io.IOUtils;
-import org.opensearch.node.NodeClosedException;
+import org.opensearch.node.ProtobufNodeClosedException;
 import org.opensearch.node.ProtobufReportingService;
-import org.opensearch.tasks.Task;
-import org.opensearch.tasks.TaskManager;
+import org.opensearch.tasks.ProtobufTask;
+import org.opensearch.tasks.ProtobufTaskManager;
 import org.opensearch.threadpool.Scheduler;
-import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.threadpool.ProtobufThreadPool;
 
 import java.io.IOException;
 import java.io.UncheckedIOException;
@@ -68,8 +70,8 @@
 public class ProtobufTransportService extends AbstractLifecycleComponent
     implements
         ProtobufReportingService<ProtobufTransportInfo>,
-        TransportMessageListener,
-        TransportConnectionListener {
+        ProtobufTransportMessageListener,
+        ProtobufTransportConnectionListener {
     private static final Logger logger = LogManager.getLogger(ProtobufTransportService.class);
 
     public static final String DIRECT_RESPONSE_PROFILE = ".direct";
@@ -77,16 +79,16 @@ public class ProtobufTransportService extends AbstractLifecycleComponent
 
     private final AtomicBoolean handleIncomingRequests = new AtomicBoolean();
     private final DelegatingTransportMessageListener messageListener = new DelegatingTransportMessageListener();
-    protected final Transport transport;
-    protected final ConnectionManager connectionManager;
-    protected final ThreadPool threadPool;
-    protected final ClusterName clusterName;
-    protected final TaskManager taskManager;
-    private final TransportInterceptor.AsyncSender asyncSender;
-    private final Function<ProtobufBoundTransportAddress, DiscoveryNode> localNodeFactory;
+    protected final ProtobufTransport transport;
+    protected final ProtobufConnectionManager connectionManager;
+    protected final ProtobufThreadPool threadPool;
+    protected final ProtobufClusterName clusterName;
+    protected final ProtobufTaskManager taskManager;
+    private final ProtobufTransportInterceptor.AsyncSender asyncSender;
+    private final Function<ProtobufBoundTransportAddress, ProtobufDiscoveryNode> localNodeFactory;
     private final boolean remoteClusterClient;
-    private final Transport.ResponseHandlers responseHandlers;
-    private final TransportInterceptor interceptor;
+    private final ProtobufTransport.ResponseHandlers responseHandlers;
+    private final ProtobufTransportInterceptor interceptor;
 
     // An LRU (don't really care about concurrency here) that holds the latest timed out requests so if they
     // do show up, we can print more descriptive information about them
@@ -99,7 +101,7 @@ protected boolean removeEldestEntry(Map.Entry eldest) {
         }
     );
 
-    public static final TransportInterceptor NOOP_TRANSPORT_INTERCEPTOR = new TransportInterceptor() {
+    public static final ProtobufTransportInterceptor NOOP_TRANSPORT_INTERCEPTOR = new ProtobufTransportInterceptor() {
     };
 
     // tracer log
@@ -109,19 +111,19 @@ protected boolean removeEldestEntry(Map.Entry eldest) {
     volatile String[] tracerLogInclude;
     volatile String[] tracerLogExclude;
 
-    private final RemoteClusterService remoteClusterService;
+    private final ProtobufRemoteClusterService remoteClusterService;
 
     /** if set will call requests sent to this id to shortcut and executed locally */
-    volatile DiscoveryNode localNode = null;
-    private final Transport.Connection localNodeConnection = new Transport.Connection() {
+    volatile ProtobufDiscoveryNode localNode = null;
+    private final ProtobufTransport.Connection localNodeConnection = new ProtobufTransport.Connection() {
         @Override
-        public DiscoveryNode getNode() {
+        public ProtobufDiscoveryNode getNode() {
             return localNode;
         }
 
         @Override
-        public void sendRequest(long requestId, String action, TransportRequest request, TransportRequestOptions options)
-            throws TransportException {
+        public void sendRequest(long requestId, String action, ProtobufTransportRequest request, TransportRequestOptions options)
+            throws ProtobufTransportException {
             sendLocalRequest(requestId, action, request, options);
         }
 
@@ -145,10 +147,10 @@ public void close() {}
     */
     public ProtobufTransportService(
         Settings settings,
-        Transport transport,
-        ThreadPool threadPool,
-        TransportInterceptor transportInterceptor,
-        Function<ProtobufBoundTransportAddress, DiscoveryNode> localNodeFactory,
+        ProtobufTransport transport,
+        ProtobufThreadPool threadPool,
+        ProtobufTransportInterceptor transportInterceptor,
+        Function<ProtobufBoundTransportAddress, ProtobufDiscoveryNode> localNodeFactory,
         @Nullable ClusterSettings clusterSettings,
         Set<String> taskHeaders
     ) {
@@ -160,34 +162,34 @@ public ProtobufTransportService(
             localNodeFactory,
             clusterSettings,
             taskHeaders,
-            new ClusterConnectionManager(settings, transport)
+            new ProtobufClusterConnectionManager(settings, transport)
         );
     }
 
     public ProtobufTransportService(
         Settings settings,
-        Transport transport,
-        ThreadPool threadPool,
-        TransportInterceptor transportInterceptor,
-        Function<ProtobufBoundTransportAddress, DiscoveryNode> localNodeFactory,
+        ProtobufTransport transport,
+        ProtobufThreadPool threadPool,
+        ProtobufTransportInterceptor transportInterceptor,
+        Function<ProtobufBoundTransportAddress, ProtobufDiscoveryNode> localNodeFactory,
         @Nullable ClusterSettings clusterSettings,
         Set<String> taskHeaders,
-        ConnectionManager connectionManager
+        ProtobufConnectionManager connectionManager
     ) {
         this.transport = transport;
         transport.setSlowLogThreshold(TransportSettings.SLOW_OPERATION_THRESHOLD_SETTING.get(settings));
         this.threadPool = threadPool;
         this.localNodeFactory = localNodeFactory;
         this.connectionManager = connectionManager;
-        this.clusterName = ClusterName.CLUSTER_NAME_SETTING.get(settings);
+        this.clusterName = ProtobufClusterName.CLUSTER_NAME_SETTING.get(settings);
         setTracerLogInclude(TransportSettings.TRACE_LOG_INCLUDE_SETTING.get(settings));
         setTracerLogExclude(TransportSettings.TRACE_LOG_EXCLUDE_SETTING.get(settings));
         tracerLog = Loggers.getLogger(logger, ".tracer");
         taskManager = createTaskManager(settings, clusterSettings, threadPool, taskHeaders);
         this.interceptor = transportInterceptor;
         this.asyncSender = interceptor.interceptSender(this::sendRequestInternal);
-        this.remoteClusterClient = DiscoveryNode.isRemoteClusterClient(settings);
-        remoteClusterService = new RemoteClusterService(settings, this);
+        this.remoteClusterClient = ProtobufDiscoveryNode.isRemoteClusterClient(settings);
+        remoteClusterService = new ProtobufRemoteClusterService(settings, this);
         responseHandlers = transport.getResponseHandlers();
         if (clusterSettings != null) {
             clusterSettings.addSettingsUpdateConsumer(TransportSettings.TRACE_LOG_INCLUDE_SETTING, this::setTracerLogInclude);
@@ -199,7 +201,7 @@ public ProtobufTransportService(
         }
         registerRequestHandler(
             HANDSHAKE_ACTION_NAME,
-            ThreadPool.Names.SAME,
+            ProtobufThreadPool.Names.SAME,
             false,
             false,
             HandshakeRequest::new,
@@ -207,28 +209,28 @@ public ProtobufTransportService(
         );
     }
 
-    public RemoteClusterService getRemoteClusterService() {
+    public ProtobufRemoteClusterService getRemoteClusterService() {
         return remoteClusterService;
     }
 
-    public DiscoveryNode getLocalNode() {
+    public ProtobufDiscoveryNode getLocalNode() {
         return localNode;
     }
 
-    public TaskManager getTaskManager() {
+    public ProtobufTaskManager getTaskManager() {
         return taskManager;
     }
 
-    protected TaskManager createTaskManager(
+    protected ProtobufTaskManager createTaskManager(
         Settings settings,
         ClusterSettings clusterSettings,
-        ThreadPool threadPool,
+        ProtobufThreadPool threadPool,
         Set<String> taskHeaders
     ) {
         if (clusterSettings != null) {
-            return TaskManager.createTaskManagerWithClusterSettings(settings, clusterSettings, threadPool, taskHeaders);
+            return ProtobufTaskManager.createTaskManagerWithClusterSettings(settings, clusterSettings, threadPool, taskHeaders);
         } else {
-            return new TaskManager(settings, threadPool, taskHeaders);
+            return new ProtobufTaskManager(settings, threadPool, taskHeaders);
         }
     }
 
@@ -277,7 +279,7 @@ protected void doStop() {
         } finally {
             // in case the transport is not connected to our local node (thus cleaned on node disconnect)
             // make sure to clean any leftover on going handles
-            for (final Transport.ResponseContext holderToNotify : responseHandlers.prune(h -> true)) {
+            for (final ProtobufTransport.ResponseContext holderToNotify : responseHandlers.prune(h -> true)) {
                 // callback that an exception happened, but on a different thread since we don't
                 // want handlers to worry about stack overflows
                 getExecutorService().execute(new AbstractRunnable() {
@@ -306,10 +308,10 @@ public void onFailure(Exception e) {
 
                     @Override
                     public void doRun() {
-                        TransportException ex = new SendRequestTransportException(
+                        ProtobufTransportException ex = new ProtobufSendRequestTransportException(
                             holderToNotify.connection().getNode(),
                             holderToNotify.action(),
-                            new NodeClosedException(localNode)
+                            new ProtobufNodeClosedException(localNode)
                         );
                         holderToNotify.handler().handleException(ex);
                     }
@@ -360,7 +362,7 @@ public List<String> getDefaultSeedAddresses() {
     /**
      * Returns <code>true</code> iff the given node is already connected.
     */
-    public boolean nodeConnected(DiscoveryNode node) {
+    public boolean nodeConnected(ProtobufDiscoveryNode node) {
         return isLocalNode(node) || connectionManager.nodeConnected(node);
     }
 
@@ -369,13 +371,13 @@ public boolean nodeConnected(DiscoveryNode node) {
     *
     * @param node the node to connect to
     */
-    public void connectToNode(DiscoveryNode node) throws ConnectTransportException {
-        connectToNode(node, (ConnectionProfile) null);
+    public void connectToNode(ProtobufDiscoveryNode node) throws ProtobufConnectTransportException {
+        connectToNode(node, (ProtobufConnectionProfile) null);
     }
 
     // We are skipping node validation for extensibility as extensionNode and opensearchNode(LocalNode) will have different ephemeral id's
-    public void connectToExtensionNode(final DiscoveryNode node) {
-        PlainActionFuture.get(fut -> connectToExtensionNode(node, (ConnectionProfile) null, ActionListener.map(fut, x -> null)));
+    public void connectToExtensionNode(final ProtobufDiscoveryNode node) {
+        PlainActionFuture.get(fut -> connectToExtensionNode(node, (ProtobufConnectionProfile) null, ActionListener.map(fut, x -> null)));
     }
 
     /**
@@ -384,11 +386,11 @@ public void connectToExtensionNode(final DiscoveryNode node) {
     * @param node the node to connect to
     * @param connectionProfile the connection profile to use when connecting to this node
     */
-    public void connectToNode(final DiscoveryNode node, ConnectionProfile connectionProfile) {
+    public void connectToNode(final ProtobufDiscoveryNode node, ProtobufConnectionProfile connectionProfile) {
         PlainActionFuture.get(fut -> connectToNode(node, connectionProfile, ActionListener.map(fut, x -> null)));
     }
 
-    public void connectToExtensionNode(final DiscoveryNode node, ConnectionProfile connectionProfile) {
+    public void connectToExtensionNode(final ProtobufDiscoveryNode node, ProtobufConnectionProfile connectionProfile) {
         PlainActionFuture.get(fut -> connectToExtensionNode(node, connectionProfile, ActionListener.map(fut, x -> null)));
     }
 
@@ -399,11 +401,11 @@ public void connectToExtensionNode(final DiscoveryNode node, ConnectionProfile c
     * @param node the node to connect to
     * @param listener the action listener to notify
     */
-    public void connectToNode(DiscoveryNode node, ActionListener<Void> listener) throws ConnectTransportException {
+    public void connectToNode(ProtobufDiscoveryNode node, ActionListener<Void> listener) throws ProtobufConnectTransportException {
         connectToNode(node, null, listener);
     }
 
-    public void connectToExtensionNode(DiscoveryNode node, ActionListener<Void> listener) throws ConnectTransportException {
+    public void connectToExtensionNode(ProtobufDiscoveryNode node, ActionListener<Void> listener) throws ProtobufConnectTransportException {
         connectToExtensionNode(node, null, listener);
     }
 
@@ -415,7 +417,11 @@ public void connectToExtensionNode(DiscoveryNode node, ActionListener<Void> list
     * @param connectionProfile the connection profile to use when connecting to this node
     * @param listener the action listener to notify
     */
-    public void connectToNode(final DiscoveryNode node, ConnectionProfile connectionProfile, ActionListener<Void> listener) {
+    public void connectToNode(
+        final ProtobufDiscoveryNode node,
+        ProtobufConnectionProfile connectionProfile,
+        ActionListener<Void> listener
+    ) {
         if (isLocalNode(node)) {
             listener.onResponse(null);
             return;
@@ -423,7 +429,11 @@ public void connectToNode(final DiscoveryNode node, ConnectionProfile connection
         connectionManager.connectToNode(node, connectionProfile, connectionValidator(node), listener);
     }
 
-    public void connectToExtensionNode(final DiscoveryNode node, ConnectionProfile connectionProfile, ActionListener<Void> listener) {
+    public void connectToExtensionNode(
+        final ProtobufDiscoveryNode node,
+        ProtobufConnectionProfile connectionProfile,
+        ActionListener<Void> listener
+    ) {
         if (isLocalNode(node)) {
             listener.onResponse(null);
             return;
@@ -431,14 +441,14 @@ public void connectToExtensionNode(final DiscoveryNode node, ConnectionProfile c
         connectionManager.connectToNode(node, connectionProfile, extensionConnectionValidator(node), listener);
     }
 
-    public ConnectionManager.ConnectionValidator connectionValidator(DiscoveryNode node) {
+    public ProtobufConnectionManager.ConnectionValidator connectionValidator(ProtobufDiscoveryNode node) {
         return (newConnection, actualProfile, listener) -> {
             // We don't validate cluster names to allow for CCS connections.
             handshake(newConnection, actualProfile.getHandshakeTimeout().millis(), cn -> true, ActionListener.map(listener, resp -> {
-                final DiscoveryNode remote = resp.discoveryNode;
+                final ProtobufDiscoveryNode remote = resp.discoveryNode;
 
                 if (node.equals(remote) == false) {
-                    throw new ConnectTransportException(node, "handshake failed. unexpected remote node " + remote);
+                    throw new ProtobufConnectTransportException(node, "handshake failed. unexpected remote node " + remote);
                 }
 
                 return null;
@@ -446,11 +456,11 @@ public ConnectionManager.ConnectionValidator connectionValidator(DiscoveryNode n
         };
     }
 
-    public ConnectionManager.ConnectionValidator extensionConnectionValidator(DiscoveryNode node) {
+    public ProtobufConnectionManager.ConnectionValidator extensionConnectionValidator(ProtobufDiscoveryNode node) {
         return (newConnection, actualProfile, listener) -> {
             // We don't validate cluster names to allow for CCS connections.
             handshake(newConnection, actualProfile.getHandshakeTimeout().millis(), cn -> true, ActionListener.map(listener, resp -> {
-                final DiscoveryNode remote = resp.discoveryNode;
+                final ProtobufDiscoveryNode remote = resp.discoveryNode;
                 logger.info("Connection validation was skipped");
                 return null;
             }));
@@ -464,7 +474,7 @@ public ConnectionManager.ConnectionValidator extensionConnectionValidator(Discov
     * @param node the node to connect to
     * @param connectionProfile the connection profile to use
     */
-    public Transport.Connection openConnection(final DiscoveryNode node, ConnectionProfile connectionProfile) {
+    public ProtobufTransport.Connection openConnection(final ProtobufDiscoveryNode node, ProtobufConnectionProfile connectionProfile) {
         return PlainActionFuture.get(fut -> openConnection(node, connectionProfile, fut));
     }
 
@@ -477,9 +487,9 @@ public Transport.Connection openConnection(final DiscoveryNode node, ConnectionP
     * @param listener the action listener to notify
     */
     public void openConnection(
-        final DiscoveryNode node,
-        ConnectionProfile connectionProfile,
-        ActionListener<Transport.Connection> listener
+        final ProtobufDiscoveryNode node,
+        ProtobufConnectionProfile connectionProfile,
+        ActionListener<ProtobufTransport.Connection> listener
     ) {
         if (isLocalNode(node)) {
             listener.onResponse(localNodeConnection);
@@ -498,13 +508,13 @@ public void openConnection(
     * @param connection       the connection to a specific node
     * @param handshakeTimeout handshake timeout
     * @param listener         action listener to notify
-    * @throws ConnectTransportException if the connection failed
+    * @throws ProtobufConnectTransportException if the connection failed
     * @throws IllegalStateException if the handshake failed
     */
     public void handshake(
-        final Transport.Connection connection,
+        final ProtobufTransport.Connection connection,
         final long handshakeTimeout,
-        final ActionListener<DiscoveryNode> listener
+        final ActionListener<ProtobufDiscoveryNode> listener
     ) {
         handshake(
             connection,
@@ -528,18 +538,18 @@ public void handshake(
     * @throws IllegalStateException if the handshake failed
     */
     public void handshake(
-        final Transport.Connection connection,
+        final ProtobufTransport.Connection connection,
         final long handshakeTimeout,
-        Predicate<ClusterName> clusterNamePredicate,
+        Predicate<ProtobufClusterName> clusterNamePredicate,
         final ActionListener<HandshakeResponse> listener
     ) {
-        final DiscoveryNode node = connection.getNode();
+        final ProtobufDiscoveryNode node = connection.getNode();
         sendRequest(
             connection,
             HANDSHAKE_ACTION_NAME,
             HandshakeRequest.INSTANCE,
             TransportRequestOptions.builder().withTimeout(handshakeTimeout).build(),
-            new ActionListenerResponseHandler<>(new ActionListener<HandshakeResponse>() {
+            new ProtobufActionListenerResponseHandler<>(new ActionListener<HandshakeResponse>() {
                 @Override
                 public void onResponse(HandshakeResponse response) {
                     if (clusterNamePredicate.test(response.clusterName) == false) {
@@ -574,11 +584,11 @@ public void onResponse(HandshakeResponse response) {
                 public void onFailure(Exception e) {
                     listener.onFailure(e);
                 }
-            }, HandshakeResponse::new, ThreadPool.Names.GENERIC)
+            }, HandshakeResponse::new, ProtobufThreadPool.Names.GENERIC)
         );
     }
 
-    public ConnectionManager getConnectionManager() {
+    public ProtobufConnectionManager getConnectionManager() {
         return connectionManager;
     }
 
@@ -587,11 +597,11 @@ public ConnectionManager getConnectionManager() {
     *
     * @opensearch.internal
     */
-    static class HandshakeRequest extends TransportRequest {
+    static class HandshakeRequest extends ProtobufTransportRequest {
 
         public static final HandshakeRequest INSTANCE = new HandshakeRequest();
 
-        HandshakeRequest(StreamInput in) throws IOException {
+        HandshakeRequest(CodedInputStream in) throws IOException {
             super(in);
         }
 
@@ -604,100 +614,102 @@ private HandshakeRequest() {}
     *
     * @opensearch.internal
     */
-    public static class HandshakeResponse extends TransportResponse {
-        private final DiscoveryNode discoveryNode;
-        private final ClusterName clusterName;
+    public static class HandshakeResponse extends ProtobufTransportResponse {
+        private final ProtobufDiscoveryNode discoveryNode;
+        private final ProtobufClusterName clusterName;
         private final Version version;
 
-        public HandshakeResponse(DiscoveryNode discoveryNode, ClusterName clusterName, Version version) {
+        public HandshakeResponse(ProtobufDiscoveryNode discoveryNode, ProtobufClusterName clusterName, Version version) {
             this.discoveryNode = discoveryNode;
             this.version = version;
             this.clusterName = clusterName;
         }
 
-        public HandshakeResponse(StreamInput in) throws IOException {
+        public HandshakeResponse(CodedInputStream in) throws IOException {
             super(in);
-            discoveryNode = in.readOptionalWriteable(DiscoveryNode::new);
-            clusterName = new ClusterName(in);
-            version = Version.readVersion(in);
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+            discoveryNode = protobufStreamInput.readOptionalWriteable(ProtobufDiscoveryNode::new);
+            clusterName = new ProtobufClusterName(in);
+            version = Version.readVersionProtobuf(in);
         }
 
         @Override
-        public void writeTo(StreamOutput out) throws IOException {
-            out.writeOptionalWriteable(discoveryNode);
+        public void writeTo(CodedOutputStream out) throws IOException {
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+            protobufStreamOutput.writeOptionalWriteable(discoveryNode);
             clusterName.writeTo(out);
-            Version.writeVersion(version, out);
+            out.writeInt32NoTag(version.id);
         }
 
-        public DiscoveryNode getDiscoveryNode() {
+        public ProtobufDiscoveryNode getDiscoveryNode() {
             return discoveryNode;
         }
 
-        public ClusterName getClusterName() {
+        public ProtobufClusterName getClusterName() {
             return clusterName;
         }
     }
 
-    public void disconnectFromNode(DiscoveryNode node) {
+    public void disconnectFromNode(ProtobufDiscoveryNode node) {
         if (isLocalNode(node)) {
             return;
         }
         connectionManager.disconnectFromNode(node);
     }
 
-    public void addMessageListener(TransportMessageListener listener) {
+    public void addMessageListener(ProtobufTransportMessageListener listener) {
         messageListener.listeners.add(listener);
     }
 
-    public boolean removeMessageListener(TransportMessageListener listener) {
+    public boolean removeMessageListener(ProtobufTransportMessageListener listener) {
         return messageListener.listeners.remove(listener);
     }
 
-    public void addConnectionListener(TransportConnectionListener listener) {
+    public void addConnectionListener(ProtobufTransportConnectionListener listener) {
         connectionManager.addListener(listener);
     }
 
-    public void removeConnectionListener(TransportConnectionListener listener) {
+    public void removeConnectionListener(ProtobufTransportConnectionListener listener) {
         connectionManager.removeListener(listener);
     }
 
-    public <T extends TransportResponse> TransportFuture<T> submitRequest(
-        DiscoveryNode node,
+    public <T extends ProtobufTransportResponse> TransportFuture<T> submitRequest(
+        ProtobufDiscoveryNode node,
         String action,
-        TransportRequest request,
-        TransportResponseHandler<T> handler
-    ) throws TransportException {
+        ProtobufTransportRequest request,
+        ProtobufTransportResponseHandler<T> handler
+    ) throws ProtobufTransportException {
         return submitRequest(node, action, request, TransportRequestOptions.EMPTY, handler);
     }
 
-    public <T extends TransportResponse> TransportFuture<T> submitRequest(
-        DiscoveryNode node,
+    public <T extends ProtobufTransportResponse> TransportFuture<T> submitRequest(
+        ProtobufDiscoveryNode node,
         String action,
-        TransportRequest request,
+        ProtobufTransportRequest request,
         TransportRequestOptions options,
-        TransportResponseHandler<T> handler
-    ) throws TransportException {
-        PlainTransportFuture<T> futureHandler = new PlainTransportFuture<>(handler);
+        ProtobufTransportResponseHandler<T> handler
+    ) throws ProtobufTransportException {
+        ProtobufPlainTransportFuture<T> futureHandler = new ProtobufPlainTransportFuture<>(handler);
         try {
-            Transport.Connection connection = getConnection(node);
+            ProtobufTransport.Connection connection = getConnection(node);
             sendRequest(connection, action, request, options, futureHandler);
-        } catch (NodeNotConnectedException ex) {
+        } catch (ProtobufNodeNotConnectedException ex) {
             // the caller might not handle this so we invoke the handler
             futureHandler.handleException(ex);
         }
         return futureHandler;
     }
 
-    public <T extends TransportResponse> void sendRequest(
-        final DiscoveryNode node,
+    public <T extends ProtobufTransportResponse> void sendRequest(
+        final ProtobufDiscoveryNode node,
         final String action,
-        final TransportRequest request,
-        final TransportResponseHandler<T> handler
+        final ProtobufTransportRequest request,
+        final ProtobufTransportResponseHandler<T> handler
     ) {
-        final Transport.Connection connection;
+        final ProtobufTransport.Connection connection;
         try {
             connection = getConnection(node);
-        } catch (final NodeNotConnectedException ex) {
+        } catch (final ProtobufNodeNotConnectedException ex) {
             // the caller might not handle this so we invoke the handler
             handler.handleException(ex);
             return;
@@ -705,17 +717,17 @@ public <T extends TransportResponse> void sendRequest(
         sendRequest(connection, action, request, TransportRequestOptions.EMPTY, handler);
     }
 
-    public final <T extends TransportResponse> void sendRequest(
-        final DiscoveryNode node,
+    public final <T extends ProtobufTransportResponse> void sendRequest(
+        final ProtobufDiscoveryNode node,
         final String action,
-        final TransportRequest request,
+        final ProtobufTransportRequest request,
         final TransportRequestOptions options,
-        TransportResponseHandler<T> handler
+        ProtobufTransportResponseHandler<T> handler
     ) {
-        final Transport.Connection connection;
+        final ProtobufTransport.Connection connection;
         try {
             connection = getConnection(node);
-        } catch (final NodeNotConnectedException ex) {
+        } catch (final ProtobufNodeNotConnectedException ex) {
             // the caller might not handle this so we invoke the handler
             handler.handleException(ex);
             return;
@@ -733,20 +745,20 @@ public final <T extends TransportResponse> void sendRequest(
     * @param handler    the response handler
     * @param <T>        the type of the transport response
     */
-    public final <T extends TransportResponse> void sendRequest(
-        final Transport.Connection connection,
+    public final <T extends ProtobufTransportResponse> void sendRequest(
+        final ProtobufTransport.Connection connection,
         final String action,
-        final TransportRequest request,
+        final ProtobufTransportRequest request,
         final TransportRequestOptions options,
-        final TransportResponseHandler<T> handler
+        final ProtobufTransportResponseHandler<T> handler
     ) {
         try {
             logger.debug("Action: " + action);
-            final TransportResponseHandler<T> delegate;
+            final ProtobufTransportResponseHandler<T> delegate;
             if (request.getParentTask().isSet()) {
                 // TODO: capture the connection instead so that we can cancel child tasks on the remote connections.
                 final Releasable unregisterChildNode = taskManager.registerChildNode(request.getParentTask().getId(), connection.getNode());
-                delegate = new TransportResponseHandler<T>() {
+                delegate = new ProtobufTransportResponseHandler<T>() {
                     @Override
                     public void handleResponse(T response) {
                         unregisterChildNode.close();
@@ -754,7 +766,7 @@ public void handleResponse(T response) {
                     }
 
                     @Override
-                    public void handleException(TransportException exp) {
+                    public void handleException(ProtobufTransportException exp) {
                         unregisterChildNode.close();
                         handler.handleException(exp);
                     }
@@ -765,7 +777,7 @@ public String executor() {
                     }
 
                     @Override
-                    public T read(StreamInput in) throws IOException {
+                    public T read(CodedInputStream in) throws IOException {
                         return handler.read(in);
                     }
 
@@ -780,11 +792,11 @@ public String toString() {
             asyncSender.sendRequest(connection, action, request, options, delegate);
         } catch (final Exception ex) {
             // the caller might not handle this so we invoke the handler
-            final TransportException te;
-            if (ex instanceof TransportException) {
-                te = (TransportException) ex;
+            final ProtobufTransportException te;
+            if (ex instanceof ProtobufTransportException) {
+                te = (ProtobufTransportException) ex;
             } else {
-                te = new TransportException("failure to send", ex);
+                te = new ProtobufTransportException("failure to send", ex);
             }
             handler.handleException(te);
         }
@@ -792,9 +804,9 @@ public String toString() {
 
     /**
      * Returns either a real transport connection or a local node connection if we are using the local node optimization.
-    * @throws NodeNotConnectedException if the given node is not connected
+    * @throws ProtobufNodeNotConnectedException if the given node is not connected
     */
-    public Transport.Connection getConnection(DiscoveryNode node) {
+    public ProtobufTransport.Connection getConnection(ProtobufDiscoveryNode node) {
         if (isLocalNode(node)) {
             return localNodeConnection;
         } else {
@@ -802,18 +814,18 @@ public Transport.Connection getConnection(DiscoveryNode node) {
         }
     }
 
-    public final <T extends TransportResponse> void sendChildRequest(
-        final DiscoveryNode node,
+    public final <T extends ProtobufTransportResponse> void sendChildRequest(
+        final ProtobufDiscoveryNode node,
         final String action,
-        final TransportRequest request,
-        final Task parentTask,
+        final ProtobufTransportRequest request,
+        final ProtobufTask parentTask,
         final TransportRequestOptions options,
-        final TransportResponseHandler<T> handler
+        final ProtobufTransportResponseHandler<T> handler
     ) {
-        final Transport.Connection connection;
+        final ProtobufTransport.Connection connection;
         try {
             connection = getConnection(node);
-        } catch (final NodeNotConnectedException ex) {
+        } catch (final ProtobufNodeNotConnectedException ex) {
             // the caller might not handle this so we invoke the handler
             handler.handleException(ex);
             return;
@@ -821,44 +833,44 @@ public final <T extends TransportResponse> void sendChildRequest(
         sendChildRequest(connection, action, request, parentTask, options, handler);
     }
 
-    public <T extends TransportResponse> void sendChildRequest(
-        final Transport.Connection connection,
+    public <T extends ProtobufTransportResponse> void sendChildRequest(
+        final ProtobufTransport.Connection connection,
         final String action,
-        final TransportRequest request,
-        final Task parentTask,
-        final TransportResponseHandler<T> handler
+        final ProtobufTransportRequest request,
+        final ProtobufTask parentTask,
+        final ProtobufTransportResponseHandler<T> handler
     ) {
         sendChildRequest(connection, action, request, parentTask, TransportRequestOptions.EMPTY, handler);
     }
 
-    public <T extends TransportResponse> void sendChildRequest(
-        final Transport.Connection connection,
+    public <T extends ProtobufTransportResponse> void sendChildRequest(
+        final ProtobufTransport.Connection connection,
         final String action,
-        final TransportRequest request,
-        final Task parentTask,
+        final ProtobufTransportRequest request,
+        final ProtobufTask parentTask,
         final TransportRequestOptions options,
-        final TransportResponseHandler<T> handler
+        final ProtobufTransportResponseHandler<T> handler
     ) {
         request.setParentTask(localNode.getId(), parentTask.getId());
         sendRequest(connection, action, request, options, handler);
     }
 
-    private <T extends TransportResponse> void sendRequestInternal(
-        final Transport.Connection connection,
+    private <T extends ProtobufTransportResponse> void sendRequestInternal(
+        final ProtobufTransport.Connection connection,
         final String action,
-        final TransportRequest request,
+        final ProtobufTransportRequest request,
         final TransportRequestOptions options,
-        TransportResponseHandler<T> handler
+        ProtobufTransportResponseHandler<T> handler
     ) {
         if (connection == null) {
             throw new IllegalStateException("can't send request to a null connection");
         }
-        DiscoveryNode node = connection.getNode();
+        ProtobufDiscoveryNode node = connection.getNode();
 
         Supplier<ThreadContext.StoredContext> storedContextSupplier = threadPool.getThreadContext().newRestorableContext(true);
         ContextRestoreResponseHandler<T> responseHandler = new ContextRestoreResponseHandler<>(storedContextSupplier, handler);
         // TODO we can probably fold this entire request ID dance into connection.sendReqeust but it will be a bigger refactoring
-        final long requestId = responseHandlers.add(new Transport.ResponseContext<>(responseHandler, connection, action));
+        final long requestId = responseHandlers.add(new ProtobufTransport.ResponseContext<>(responseHandler, connection, action));
         final TimeoutHandler timeoutHandler;
         if (options.timeout() != null) {
             timeoutHandler = new TimeoutHandler(requestId, connection.getNode(), action);
@@ -872,7 +884,7 @@ private <T extends TransportResponse> void sendRequestInternal(
                 * If we are not started the exception handling will remove the request holder again and calls the handler to notify the
                 * caller. It will only notify if toStop hasn't done the work yet.
                 */
-                throw new NodeClosedException(localNode);
+                throw new ProtobufNodeClosedException(localNode);
             }
             if (timeoutHandler != null) {
                 assert options.timeout() != null;
@@ -882,7 +894,9 @@ private <T extends TransportResponse> void sendRequestInternal(
         } catch (final Exception e) {
             // usually happen either because we failed to connect to the node
             // or because we failed serializing the message
-            final Transport.ResponseContext<? extends TransportResponse> contextToNotify = responseHandlers.remove(requestId);
+            final ProtobufTransport.ResponseContext<? extends ProtobufTransportResponse> contextToNotify = responseHandlers.remove(
+                requestId
+            );
             // If holderToNotify == null then handler has already been taken care of.
             if (contextToNotify != null) {
                 if (timeoutHandler != null) {
@@ -891,8 +905,12 @@ private <T extends TransportResponse> void sendRequestInternal(
                 // callback that an exception happened, but on a different thread since we don't
                 // want handlers to worry about stack overflows. In the special case of running into a closing node we run on the current
                 // thread on a best effort basis though.
-                final SendRequestTransportException sendRequestException = new SendRequestTransportException(node, action, e);
-                final String executor = lifecycle.stoppedOrClosed() ? ThreadPool.Names.SAME : ThreadPool.Names.GENERIC;
+                final ProtobufSendRequestTransportException sendRequestException = new ProtobufSendRequestTransportException(
+                    node,
+                    action,
+                    e
+                );
+                final String executor = lifecycle.stoppedOrClosed() ? ProtobufThreadPool.Names.SAME : ProtobufThreadPool.Names.GENERIC;
                 threadPool.executor(executor).execute(new AbstractRunnable() {
                     @Override
                     public void onRejection(Exception e) {
@@ -928,17 +946,22 @@ protected void doRun() throws Exception {
         }
     }
 
-    private void sendLocalRequest(long requestId, final String action, final TransportRequest request, TransportRequestOptions options) {
+    private void sendLocalRequest(
+        long requestId,
+        final String action,
+        final ProtobufTransportRequest request,
+        TransportRequestOptions options
+    ) {
         final DirectResponseChannel channel = new DirectResponseChannel(localNode, action, requestId, this, threadPool);
         try {
             onRequestSent(localNode, requestId, action, request, options);
             onRequestReceived(requestId, action);
-            final RequestHandlerRegistry reg = getRequestHandler(action);
+            final ProtobufRequestHandlerRegistry reg = getRequestHandler(action);
             if (reg == null) {
                 throw new ActionNotFoundTransportException("Action [" + action + "] not found");
             }
             final String executor = reg.getExecutor();
-            if (ThreadPool.Names.SAME.equals(executor)) {
+            if (ProtobufThreadPool.Names.SAME.equals(executor)) {
                 // noinspection unchecked
                 reg.processMessageReceived(request, channel);
             } else {
@@ -1000,7 +1023,7 @@ public static boolean shouldTraceAction(String action, String[] include, String[
         return true;
     }
 
-    public TransportAddress[] addressesFromString(String address) throws UnknownHostException {
+    public ProtobufTransportAddress[] addressesFromString(String address) throws UnknownHostException {
         return transport.addressesFromString(address);
     }
 
@@ -1027,7 +1050,9 @@ private void validateActionName(String actionName) {
         // TODO we should makes this a hard validation and throw an exception but we need a good way to add backwards layer
         // for it. Maybe start with a deprecation layer
         if (isValidActionName(actionName) == false) {
-            logger.warn("invalid action name [" + actionName + "] must start with one of: " + ProtobufTransportService.VALID_ACTION_PREFIXES);
+            logger.warn(
+                "invalid action name [" + actionName + "] must start with one of: " + ProtobufTransportService.VALID_ACTION_PREFIXES
+            );
         }
     }
 
@@ -1053,15 +1078,15 @@ public static boolean isValidActionName(String actionName) {
     * @param executor       The executor the request handling will be executed on
     * @param handler        The handler itself that implements the request handling
     */
-    public <Request extends TransportRequest> void registerRequestHandler(
+    public <Request extends ProtobufTransportRequest> void registerRequestHandler(
         String action,
         String executor,
-        Writeable.Reader<Request> requestReader,
-        TransportRequestHandler<Request> handler
+        ProtobufWriteable.Reader<Request> requestReader,
+        ProtobufTransportRequestHandler<Request> handler
     ) {
         validateActionName(action);
         handler = interceptor.interceptHandler(action, executor, false, handler);
-        RequestHandlerRegistry<Request> reg = new RequestHandlerRegistry<>(
+        ProtobufRequestHandlerRegistry<Request> reg = new ProtobufRequestHandlerRegistry<>(
             action,
             requestReader,
             taskManager,
@@ -1083,17 +1108,17 @@ public <Request extends TransportRequest> void registerRequestHandler(
     * @param canTripCircuitBreaker Check the request size and raise an exception in case the limit is breached.
     * @param handler               The handler itself that implements the request handling
     */
-    public <Request extends TransportRequest> void registerRequestHandler(
+    public <Request extends ProtobufTransportRequest> void registerRequestHandler(
         String action,
         String executor,
         boolean forceExecution,
         boolean canTripCircuitBreaker,
-        Writeable.Reader<Request> requestReader,
-        TransportRequestHandler<Request> handler
+        ProtobufWriteable.Reader<Request> requestReader,
+        ProtobufTransportRequestHandler<Request> handler
     ) {
         validateActionName(action);
         handler = interceptor.interceptHandler(action, executor, forceExecution, handler);
-        RequestHandlerRegistry<Request> reg = new RequestHandlerRegistry<>(
+        ProtobufRequestHandlerRegistry<Request> reg = new ProtobufRequestHandlerRegistry<>(
             action,
             requestReader,
             taskManager,
@@ -1106,7 +1131,7 @@ public <Request extends TransportRequest> void registerRequestHandler(
     }
 
     /**
-     * called by the {@link Transport} implementation when an incoming request arrives but before
+     * called by the {@link ProtobufTransport} implementation when an incoming request arrives but before
     * any parsing of it has happened (with the exception of the requestId and action)
     */
     @Override
@@ -1120,13 +1145,13 @@ public void onRequestReceived(long requestId, String action) {
         messageListener.onRequestReceived(requestId, action);
     }
 
-    /** called by the {@link Transport} implementation once a request has been sent */
+    /** called by the {@link ProtobufTransport} implementation once a request has been sent */
     @Override
     public void onRequestSent(
-        DiscoveryNode node,
+        ProtobufDiscoveryNode node,
         long requestId,
         String action,
-        TransportRequest request,
+        ProtobufTransportRequest request,
         TransportRequestOptions options
     ) {
         if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
@@ -1136,7 +1161,7 @@ public void onRequestSent(
     }
 
     @Override
-    public void onResponseReceived(long requestId, Transport.ResponseContext holder) {
+    public void onResponseReceived(long requestId, ProtobufTransport.ResponseContext holder) {
         if (holder == null) {
             checkForTimeout(requestId);
         } else if (tracerLog.isTraceEnabled() && shouldTraceAction(holder.action())) {
@@ -1145,16 +1170,16 @@ public void onResponseReceived(long requestId, Transport.ResponseContext holder)
         messageListener.onResponseReceived(requestId, holder);
     }
 
-    /** called by the {@link Transport} implementation once a response was sent to calling node */
+    /** called by the {@link ProtobufTransport} implementation once a response was sent to calling node */
     @Override
-    public void onResponseSent(long requestId, String action, TransportResponse response) {
+    public void onResponseSent(long requestId, String action, ProtobufTransportResponse response) {
         if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
             tracerLog.trace("[{}][{}] sent response", requestId, action);
         }
         messageListener.onResponseSent(requestId, action, response);
     }
 
-    /** called by the {@link Transport} implementation after an exception was sent as a response to an incoming request */
+    /** called by the {@link ProtobufTransport} implementation after an exception was sent as a response to an incoming request */
     @Override
     public void onResponseSent(long requestId, String action, Exception e) {
         if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
@@ -1163,13 +1188,13 @@ public void onResponseSent(long requestId, String action, Exception e) {
         messageListener.onResponseSent(requestId, action, e);
     }
 
-    public RequestHandlerRegistry<? extends TransportRequest> getRequestHandler(String action) {
+    public ProtobufRequestHandlerRegistry<? extends ProtobufTransportRequest> getRequestHandler(String action) {
         return transport.getRequestHandlers().getHandler(action);
     }
 
     private void checkForTimeout(long requestId) {
         // lets see if its in the timeout holder, but sync on mutex to make sure any ongoing timeout handling has finished
-        final DiscoveryNode sourceNode;
+        final ProtobufDiscoveryNode sourceNode;
         final String action;
         assert responseHandlers.contains(requestId) == false;
         TimeoutInfoHolder timeoutInfoHolder = timeoutInfoHandlers.remove(requestId);
@@ -1187,7 +1212,7 @@ private void checkForTimeout(long requestId) {
             action = timeoutInfoHolder.action();
             sourceNode = timeoutInfoHolder.node();
         } else {
-            logger.warn("Transport response handler not found of id [{}]", requestId);
+            logger.warn("ProtobufTransport response handler not found of id [{}]", requestId);
             action = null;
             sourceNode = null;
         }
@@ -1204,9 +1229,9 @@ private void checkForTimeout(long requestId) {
     }
 
     @Override
-    public void onConnectionClosed(Transport.Connection connection) {
+    public void onConnectionClosed(ProtobufTransport.Connection connection) {
         try {
-            List<Transport.ResponseContext<? extends TransportResponse>> pruned = responseHandlers.prune(
+            List<ProtobufTransport.ResponseContext<? extends ProtobufTransportResponse>> pruned = responseHandlers.prune(
                 h -> h.connection().getCacheKey().equals(connection.getCacheKey())
             );
             // callback that an exception happened, but on a different thread since we don't
@@ -1214,9 +1239,9 @@ public void onConnectionClosed(Transport.Connection connection) {
             getExecutorService().execute(new Runnable() {
                 @Override
                 public void run() {
-                    for (Transport.ResponseContext holderToNotify : pruned) {
+                    for (ProtobufTransport.ResponseContext holderToNotify : pruned) {
                         holderToNotify.handler()
-                            .handleException(new NodeDisconnectedException(connection.getNode(), holderToNotify.action()));
+                            .handleException(new ProtobufNodeDisconnectedException(connection.getNode(), holderToNotify.action()));
                     }
                 }
 
@@ -1235,10 +1260,10 @@ final class TimeoutHandler implements Runnable {
         private final long requestId;
         private final long sentTime = threadPool.relativeTimeInMillis();
         private final String action;
-        private final DiscoveryNode node;
+        private final ProtobufDiscoveryNode node;
         volatile Scheduler.Cancellable cancellable;
 
-        TimeoutHandler(long requestId, DiscoveryNode node, String action) {
+        TimeoutHandler(long requestId, ProtobufDiscoveryNode node, String action) {
             this.requestId = requestId;
             this.node = node;
             this.action = action;
@@ -1250,13 +1275,13 @@ public void run() {
                 long timeoutTime = threadPool.relativeTimeInMillis();
                 timeoutInfoHandlers.put(requestId, new TimeoutInfoHolder(node, action, sentTime, timeoutTime));
                 // now that we have the information visible via timeoutInfoHandlers, we try to remove the request id
-                final Transport.ResponseContext<? extends TransportResponse> holder = responseHandlers.remove(requestId);
+                final ProtobufTransport.ResponseContext<? extends ProtobufTransportResponse> holder = responseHandlers.remove(requestId);
                 if (holder != null) {
                     assert holder.action().equals(action);
                     assert holder.connection().getNode().equals(node);
                     holder.handler()
                         .handleException(
-                            new ReceiveTimeoutTransportException(
+                            new ProtobufReceiveTimeoutTransportException(
                                 holder.connection().getNode(),
                                 holder.action(),
                                 "request_id [" + requestId + "] timed out after [" + (timeoutTime - sentTime) + "ms]"
@@ -1288,7 +1313,7 @@ public String toString() {
         }
 
         private void scheduleTimeout(TimeValue timeout) {
-            this.cancellable = threadPool.schedule(this, timeout, ThreadPool.Names.GENERIC);
+            this.cancellable = threadPool.schedule(this, timeout, ProtobufThreadPool.Names.GENERIC);
         }
     }
 
@@ -1299,19 +1324,19 @@ private void scheduleTimeout(TimeValue timeout) {
     */
     static class TimeoutInfoHolder {
 
-        private final DiscoveryNode node;
+        private final ProtobufDiscoveryNode node;
         private final String action;
         private final long sentTime;
         private final long timeoutTime;
 
-        TimeoutInfoHolder(DiscoveryNode node, String action, long sentTime, long timeoutTime) {
+        TimeoutInfoHolder(ProtobufDiscoveryNode node, String action, long sentTime, long timeoutTime) {
             this.node = node;
             this.action = action;
             this.sentTime = sentTime;
             this.timeoutTime = timeoutTime;
         }
 
-        public DiscoveryNode node() {
+        public ProtobufDiscoveryNode node() {
             return node;
         }
 
@@ -1332,19 +1357,24 @@ public long timeoutTime() {
      * This handler wrapper ensures that the response thread executes with the correct thread context. Before any of the handle methods
     * are invoked we restore the context.
     */
-    public static final class ContextRestoreResponseHandler<T extends TransportResponse> implements TransportResponseHandler<T> {
+    public static final class ContextRestoreResponseHandler<T extends ProtobufTransportResponse>
+        implements
+            ProtobufTransportResponseHandler<T> {
 
-        private final TransportResponseHandler<T> delegate;
+        private final ProtobufTransportResponseHandler<T> delegate;
         private final Supplier<ThreadContext.StoredContext> contextSupplier;
         private volatile TimeoutHandler handler;
 
-        public ContextRestoreResponseHandler(Supplier<ThreadContext.StoredContext> contextSupplier, TransportResponseHandler<T> delegate) {
+        public ContextRestoreResponseHandler(
+            Supplier<ThreadContext.StoredContext> contextSupplier,
+            ProtobufTransportResponseHandler<T> delegate
+        ) {
             this.delegate = delegate;
             this.contextSupplier = contextSupplier;
         }
 
         @Override
-        public T read(StreamInput in) throws IOException {
+        public T read(CodedInputStream in) throws IOException {
             return delegate.read(in);
         }
 
@@ -1359,7 +1389,7 @@ public void handleResponse(T response) {
         }
 
         @Override
-        public void handleException(TransportException exp) {
+        public void handleException(ProtobufTransportException exp) {
             if (handler != null) {
                 handler.cancel();
             }
@@ -1389,14 +1419,20 @@ void setTimeoutHandler(TimeoutHandler handler) {
     *
     * @opensearch.internal
     */
-    static class DirectResponseChannel implements TransportChannel {
-        final DiscoveryNode localNode;
+    static class DirectResponseChannel implements ProtobufTransportChannel {
+        final ProtobufDiscoveryNode localNode;
         private final String action;
         private final long requestId;
         final ProtobufTransportService service;
-        final ThreadPool threadPool;
+        final ProtobufThreadPool threadPool;
 
-        DirectResponseChannel(DiscoveryNode localNode, String action, long requestId, ProtobufTransportService service, ThreadPool threadPool) {
+        DirectResponseChannel(
+            ProtobufDiscoveryNode localNode,
+            String action,
+            long requestId,
+            ProtobufTransportService service,
+            ProtobufThreadPool threadPool
+        ) {
             this.localNode = localNode;
             this.action = action;
             this.requestId = requestId;
@@ -1410,13 +1446,13 @@ public String getProfileName() {
         }
 
         @Override
-        public void sendResponse(TransportResponse response) throws IOException {
+        public void sendResponse(ProtobufTransportResponse response) throws IOException {
             service.onResponseSent(requestId, action, response);
-            final TransportResponseHandler handler = service.responseHandlers.onResponseReceived(requestId, service);
+            final ProtobufTransportResponseHandler handler = service.responseHandlers.onResponseReceived(requestId, service);
             // ignore if its null, the service logs it
             if (handler != null) {
                 final String executor = handler.executor();
-                if (ThreadPool.Names.SAME.equals(executor)) {
+                if (ProtobufThreadPool.Names.SAME.equals(executor)) {
                     processResponse(handler, response);
                 } else {
                     threadPool.executor(executor).execute(new Runnable() {
@@ -1435,7 +1471,7 @@ public String toString() {
         }
 
         @SuppressWarnings("unchecked")
-        protected void processResponse(TransportResponseHandler handler, TransportResponse response) {
+        protected void processResponse(ProtobufTransportResponseHandler handler, ProtobufTransportResponse response) {
             try {
                 handler.handleResponse(response);
             } catch (Exception e) {
@@ -1446,12 +1482,12 @@ protected void processResponse(TransportResponseHandler handler, TransportRespon
         @Override
         public void sendResponse(Exception exception) throws IOException {
             service.onResponseSent(requestId, action, exception);
-            final TransportResponseHandler handler = service.responseHandlers.onResponseReceived(requestId, service);
+            final ProtobufTransportResponseHandler handler = service.responseHandlers.onResponseReceived(requestId, service);
             // ignore if its null, the service logs it
             if (handler != null) {
-                final RemoteTransportException rtx = wrapInRemote(exception);
+                final ProtobufRemoteTransportException rtx = wrapInRemote(exception);
                 final String executor = handler.executor();
-                if (ThreadPool.Names.SAME.equals(executor)) {
+                if (ProtobufThreadPool.Names.SAME.equals(executor)) {
                     processException(handler, rtx);
                 } else {
                     threadPool.executor(handler.executor()).execute(new Runnable() {
@@ -1469,14 +1505,14 @@ public String toString() {
             }
         }
 
-        protected RemoteTransportException wrapInRemote(Exception e) {
-            if (e instanceof RemoteTransportException) {
-                return (RemoteTransportException) e;
+        protected ProtobufRemoteTransportException wrapInRemote(Exception e) {
+            if (e instanceof ProtobufRemoteTransportException) {
+                return (ProtobufRemoteTransportException) e;
             }
-            return new RemoteTransportException(localNode.getName(), localNode.getAddress(), action, e);
+            return new ProtobufRemoteTransportException(localNode.getName(), localNode.getAddress(), action, e);
         }
 
-        protected void processException(final TransportResponseHandler handler, final RemoteTransportException rtx) {
+        protected void processException(final ProtobufTransportResponseHandler handler, final ProtobufRemoteTransportException rtx) {
             try {
                 handler.handleException(rtx);
             } catch (Exception e) {
@@ -1501,55 +1537,55 @@ public Version getVersion() {
     /**
      * Returns the internal thread pool
     */
-    public ThreadPool getThreadPool() {
+    public ProtobufThreadPool getThreadPool() {
         return threadPool;
     }
 
-    private boolean isLocalNode(DiscoveryNode discoveryNode) {
+    private boolean isLocalNode(ProtobufDiscoveryNode discoveryNode) {
         return Objects.requireNonNull(discoveryNode, "discovery node must not be null").equals(localNode);
     }
 
-    private static final class DelegatingTransportMessageListener implements TransportMessageListener {
+    private static final class DelegatingTransportMessageListener implements ProtobufTransportMessageListener {
 
-        private final List<TransportMessageListener> listeners = new CopyOnWriteArrayList<>();
+        private final List<ProtobufTransportMessageListener> listeners = new CopyOnWriteArrayList<>();
 
         @Override
         public void onRequestReceived(long requestId, String action) {
-            for (TransportMessageListener listener : listeners) {
+            for (ProtobufTransportMessageListener listener : listeners) {
                 listener.onRequestReceived(requestId, action);
             }
         }
 
         @Override
-        public void onResponseSent(long requestId, String action, TransportResponse response) {
-            for (TransportMessageListener listener : listeners) {
+        public void onResponseSent(long requestId, String action, ProtobufTransportResponse response) {
+            for (ProtobufTransportMessageListener listener : listeners) {
                 listener.onResponseSent(requestId, action, response);
             }
         }
 
         @Override
         public void onResponseSent(long requestId, String action, Exception error) {
-            for (TransportMessageListener listener : listeners) {
+            for (ProtobufTransportMessageListener listener : listeners) {
                 listener.onResponseSent(requestId, action, error);
             }
         }
 
         @Override
         public void onRequestSent(
-            DiscoveryNode node,
+            ProtobufDiscoveryNode node,
             long requestId,
             String action,
-            TransportRequest request,
+            ProtobufTransportRequest request,
             TransportRequestOptions finalOptions
         ) {
-            for (TransportMessageListener listener : listeners) {
+            for (ProtobufTransportMessageListener listener : listeners) {
                 listener.onRequestSent(node, requestId, action, request, finalOptions);
             }
         }
 
         @Override
-        public void onResponseReceived(long requestId, Transport.ResponseContext holder) {
-            for (TransportMessageListener listener : listeners) {
+        public void onResponseReceived(long requestId, ProtobufTransport.ResponseContext holder) {
+            for (ProtobufTransportMessageListener listener : listeners) {
                 listener.onResponseReceived(requestId, holder);
             }
         }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportStats.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportStats.java
new file mode 100644
index 0000000000000..963bf4665af8b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportStats.java
@@ -0,0 +1,126 @@
+/*
+* 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.
+*/
+
+package org.opensearch.transport;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+/**
+ * Stats for transport activity
+*
+* @opensearch.internal
+*/
+public class ProtobufTransportStats implements ProtobufWriteable, ToXContentFragment {
+
+    private final long serverOpen;
+    private final long totalOutboundConnections;
+    private final long rxCount;
+    private final long rxSize;
+    private final long txCount;
+    private final long txSize;
+
+    public ProtobufTransportStats(long serverOpen, long totalOutboundConnections, long rxCount, long rxSize, long txCount, long txSize) {
+        this.serverOpen = serverOpen;
+        this.totalOutboundConnections = totalOutboundConnections;
+        this.rxCount = rxCount;
+        this.rxSize = rxSize;
+        this.txCount = txCount;
+        this.txSize = txSize;
+    }
+
+    public ProtobufTransportStats(CodedInputStream in) throws IOException {
+        serverOpen = in.readInt64();
+        totalOutboundConnections = in.readInt64();
+        rxCount = in.readInt64();
+        rxSize = in.readInt64();
+        txCount = in.readInt64();
+        txSize = in.readInt64();
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(serverOpen);
+        out.writeInt64NoTag(totalOutboundConnections);
+        out.writeInt64NoTag(rxCount);
+        out.writeInt64NoTag(rxSize);
+        out.writeInt64NoTag(txCount);
+        out.writeInt64NoTag(txSize);
+    }
+
+    public long serverOpen() {
+        return this.serverOpen;
+    }
+
+    public long getServerOpen() {
+        return serverOpen();
+    }
+
+    public long rxCount() {
+        return rxCount;
+    }
+
+    public long getRxCount() {
+        return rxCount();
+    }
+
+    public ByteSizeValue rxSize() {
+        return new ByteSizeValue(rxSize);
+    }
+
+    public ByteSizeValue getRxSize() {
+        return rxSize();
+    }
+
+    public long txCount() {
+        return txCount;
+    }
+
+    public long getTxCount() {
+        return txCount();
+    }
+
+    public ByteSizeValue txSize() {
+        return new ByteSizeValue(txSize);
+    }
+
+    public ByteSizeValue getTxSize() {
+        return txSize();
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.TRANSPORT);
+        builder.field(Fields.SERVER_OPEN, serverOpen);
+        builder.field(Fields.TOTAL_OUTBOUND_CONNECTIONS, totalOutboundConnections);
+        builder.field(Fields.RX_COUNT, rxCount);
+        builder.humanReadableField(Fields.RX_SIZE_IN_BYTES, Fields.RX_SIZE, new ByteSizeValue(rxSize));
+        builder.field(Fields.TX_COUNT, txCount);
+        builder.humanReadableField(Fields.TX_SIZE_IN_BYTES, Fields.TX_SIZE, new ByteSizeValue(txSize));
+        builder.endObject();
+        return builder;
+    }
+
+    static final class Fields {
+        static final String TRANSPORT = "transport";
+        static final String SERVER_OPEN = "server_open";
+        static final String TOTAL_OUTBOUND_CONNECTIONS = "total_outbound_connections";
+        static final String RX_COUNT = "rx_count";
+        static final String RX_SIZE = "rx_size";
+        static final String RX_SIZE_IN_BYTES = "rx_size_in_bytes";
+        static final String TX_COUNT = "tx_count";
+        static final String TX_SIZE = "tx_size";
+        static final String TX_SIZE_IN_BYTES = "tx_size_in_bytes";
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/TcpHeader.java b/server/src/main/java/org/opensearch/transport/TcpHeader.java
index 78353a9a80403..7e991bfddd53e 100644
--- a/server/src/main/java/org/opensearch/transport/TcpHeader.java
+++ b/server/src/main/java/org/opensearch/transport/TcpHeader.java
@@ -32,6 +32,7 @@
 
 package org.opensearch.transport;
 
+import com.google.protobuf.CodedOutputStream;
 import org.opensearch.Version;
 import org.opensearch.core.common.io.stream.StreamOutput;
 
@@ -91,4 +92,22 @@ public static void writeHeader(
         assert variableHeaderSize != -1 : "Variable header size not set";
         output.writeInt(variableHeaderSize);
     }
+
+    public static void writeHeaderProtobuf(
+        CodedOutputStream output,
+        long requestId,
+        byte status,
+        Version version,
+        int contentSize,
+        int variableHeaderSize
+    ) throws IOException {
+        output.writeByteArrayNoTag(PREFIX);
+        // write the size, the size indicates the remaining message size, not including the size int
+        output.writeInt32NoTag(contentSize + REQUEST_ID_SIZE + STATUS_SIZE + VERSION_ID_SIZE + VARIABLE_HEADER_SIZE);
+        output.writeInt64NoTag(requestId);
+        output.writeRawByte(status);
+        output.writeInt32NoTag(version.id);
+        assert variableHeaderSize != -1 : "Variable header size not set";
+        output.writeInt32NoTag(variableHeaderSize);
+    }
 }

From 8e570343d2a443e312f3a20ca66c232a12dd99e5 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Wed, 21 Jun 2023 21:53:41 +0000
Subject: [PATCH 09/37] Fixing node crashes

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 ...nsionRequestProto$ExtensionRequest$1.class |  Bin 0 -> 2790 bytes
 ...equestProto$ExtensionRequest$Builder.class |  Bin 0 -> 11386 bytes
 ...tensionRequestProto$ExtensionRequest.class |  Bin 0 -> 12446 bytes
 ...questProto$ExtensionRequestOrBuilder.class |  Bin 0 -> 697 bytes
 .../ExtensionRequestProto$RequestType$1.class |  Bin 0 -> 1234 bytes
 .../ExtensionRequestProto$RequestType.class   |  Bin 0 -> 5611 bytes
 .../proto/ExtensionRequestProto.class         |  Bin 0 -> 3318 bytes
 .../tasks/proto/TaskIdProto$TaskId$1.class    |  Bin 0 -> 2505 bytes
 .../proto/TaskIdProto$TaskId$Builder.class    |  Bin 0 -> 9996 bytes
 .../tasks/proto/TaskIdProto$TaskId.class      |  Bin 0 -> 11288 bytes
 .../proto/TaskIdProto$TaskIdOrBuilder.class   |  Bin 0 -> 429 bytes
 .../opensearch/tasks/proto/TaskIdProto.class  |  Bin 0 -> 2532 bytes
 ...sourceStatsProto$TaskResourceStats$1.class |  Bin 0 -> 2758 bytes
 ...StatsProto$TaskResourceStats$Builder.class |  Bin 0 -> 14366 bytes
 ...tats$ResourceUsageDefaultEntryHolder.class |  Bin 0 -> 1971 bytes
 ...askResourceStats$TaskResourceUsage$1.class |  Bin 0 -> 3039 bytes
 ...ourceStats$TaskResourceUsage$Builder.class |  Bin 0 -> 9805 bytes
 ...$TaskResourceStats$TaskResourceUsage.class |  Bin 0 -> 11572 bytes
 ...urceStats$TaskResourceUsageOrBuilder.class |  Bin 0 -> 537 bytes
 ...ResourceStatsProto$TaskResourceStats.class |  Bin 0 -> 15186 bytes
 ...tatsProto$TaskResourceStatsOrBuilder.class |  Bin 0 -> 1364 bytes
 .../tasks/proto/TaskResourceStatsProto.class  |  Bin 0 -> 4154 bytes
 .../org/opensearch/action/ActionModule.java   |  186 +++
 ...ProtobufActionListenerResponseHandler.java |    4 +-
 .../ProtobufTransportNodesInfoAction.java     |  128 ++
 .../ProtobufTransportNodesStatsAction.java    |  132 ++
 .../ProtobufTransportClusterStateAction.java  |  212 +++
 .../action/main/ProtobufMainAction.java       |   26 +
 .../action/main/ProtobufMainRequest.java      |   35 +
 .../action/main/ProtobufMainResponse.java     |  185 +++
 .../main/ProtobufTransportMainAction.java     |   56 +
 .../ProtobufHandledTransportAction.java       |   83 +
 .../support/ProtobufTransportAction.java      |   32 +-
 ...obufTransportClusterManagerNodeAction.java |  352 +++++
 ...TransportClusterManagerNodeReadAction.java |   67 +
 .../nodes/ProtobufTransportNodesAction.java   |  309 ++++
 .../client/ProtobufFilterClient.java          |    4 +-
 .../client/ProtobufOpenSearchClient.java      |    4 +-
 .../client/node/ProtobufNodeClient.java       |   20 +-
 .../support/ProtobufAbstractClient.java       |   10 +-
 .../ClusterManagerNodeChangePredicate.java    |   23 +
 .../org/opensearch/cluster/ClusterModule.java |    8 +
 .../cluster/ProtobufClusterStateApplier.java  |    2 +-
 .../cluster/ProtobufClusterStateListener.java |   22 +
 .../cluster/ProtobufClusterStateObserver.java |  379 +++++
 .../ProtobufTimeoutClusterStateListener.java  |   49 +
 .../ProtobufIndexNameExpressionResolver.java  | 1342 +++++++++++++++++
 .../service/ClusterApplierService.java        |   14 +
 .../cluster/service/ClusterService.java       |    9 +
 .../common/network/NetworkModule.java         |   48 +
 .../common/settings/SettingsModule.java       |    1 +
 .../common/unit/ProtobufSizeValue.java        |    8 +
 .../org/opensearch/common/unit/SizeValue.java |    8 +
 .../http/AbstractHttpServerTransport.java     |    2 +
 .../main/java/org/opensearch/node/Node.java   |  180 ++-
 .../opensearch/node/ProtobufNodeService.java  |  238 +++
 .../node/ProtobufReportingService.java        |    2 +-
 .../plugins/ProtobufActionPlugin.java         |  205 +++
 .../org/opensearch/rest/MethodHandlers.java   |   33 +
 .../opensearch/rest/ProtobufRestHandler.java  |    2 +-
 .../org/opensearch/rest/RestBaseHandler.java  |  189 +++
 .../org/opensearch/rest/RestController.java   |  199 ++-
 .../java/org/opensearch/rest/RestHandler.java |    2 +-
 .../action/cat/ProtobufRestCatAction.java     |   58 +
 .../action/cat/ProtobufRestNodesAction.java   |    6 +-
 .../ProtobufTaskCancellationService.java      |   22 +-
 .../opensearch/tasks/ProtobufTaskManager.java |   10 +-
 .../ProtobufTaskResourceTrackingService.java  |    6 +-
 .../org/opensearch/tasks/TaskManager.java     |  842 ++++++++++-
 .../threadpool/ProtobufExecutorBuilder.java   |   91 --
 .../ProtobufFixedExecutorBuilder.java         |  182 ---
 .../ProtobufResizableExecutorBuilder.java     |  134 --
 .../ProtobufScalingExecutorBuilder.java       |  141 --
 .../threadpool/ProtobufThreadPool.java        |  860 -----------
 .../threadpool/ProtobufThreadPoolInfo.java    |   10 +-
 .../org/opensearch/threadpool/ThreadPool.java |   84 +-
 .../ProtobufClusterConnectionManager.java     |   26 +-
 .../transport/ProtobufConnectionManager.java  |   14 +-
 .../transport/ProtobufOutboundHandler.java    |    6 +-
 .../ProtobufRemoteClusterAwareClient.java     |   14 +-
 .../ProtobufRemoteClusterConnection.java      |   12 +-
 .../ProtobufRemoteClusterService.java         |   10 +-
 .../ProtobufRemoteConnectionManager.java      |   16 +-
 .../ProtobufRemoteConnectionStrategy.java     |    2 +-
 .../ProtobufRequestHandlerRegistry.java       |   14 +-
 .../ProtobufSniffConnectionStrategy.java      |   18 +-
 .../transport/ProtobufTransport.java          |    4 +-
 .../ProtobufTransportActionProxy.java         |    8 +-
 .../ProtobufTransportConnectionListener.java  |    8 +-
 .../ProtobufTransportInterceptor.java         |    4 +-
 .../ProtobufTransportMessageListener.java     |    2 +-
 .../transport/ProtobufTransportService.java   |  137 +-
 .../transport/RemoteClusterService.java       |   67 +-
 .../opensearch/transport/TcpTransport.java    |   52 +
 .../org/opensearch/transport/Transport.java   |  239 +++
 .../org/opensearch/usage/UsageService.java    |   31 +
 .../opensearch/rest/RestControllerTests.java  |    4 +-
 .../test/transport/FakeTransport.java         |   56 +
 .../test/transport/StubbableTransport.java    |   55 +
 99 files changed, 6388 insertions(+), 1667 deletions(-)
 create mode 100644 server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequest$1.class
 create mode 100644 server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequest$Builder.class
 create mode 100644 server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequest.class
 create mode 100644 server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequestOrBuilder.class
 create mode 100644 server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$RequestType$1.class
 create mode 100644 server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$RequestType.class
 create mode 100644 server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto.class
 create mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskId$1.class
 create mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskId$Builder.class
 create mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskId.class
 create mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskIdOrBuilder.class
 create mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskIdProto.class
 create mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$1.class
 create mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$Builder.class
 create mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$ResourceUsageDefaultEntryHolder.class
 create mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsage$1.class
 create mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsage$Builder.class
 create mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsage.class
 create mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsageOrBuilder.class
 create mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats.class
 create mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStatsOrBuilder.class
 create mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto.class
 create mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
 create mode 100644 server/src/main/java/org/opensearch/action/main/ProtobufMainAction.java
 create mode 100644 server/src/main/java/org/opensearch/action/main/ProtobufMainRequest.java
 create mode 100644 server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java
 create mode 100644 server/src/main/java/org/opensearch/action/main/ProtobufTransportMainAction.java
 create mode 100644 server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
 create mode 100644 server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
 create mode 100644 server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeReadAction.java
 create mode 100644 server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufClusterStateListener.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufClusterStateObserver.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufTimeoutClusterStateListener.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/metadata/ProtobufIndexNameExpressionResolver.java
 create mode 100644 server/src/main/java/org/opensearch/node/ProtobufNodeService.java
 create mode 100644 server/src/main/java/org/opensearch/plugins/ProtobufActionPlugin.java
 create mode 100644 server/src/main/java/org/opensearch/rest/RestBaseHandler.java
 create mode 100644 server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestCatAction.java
 delete mode 100644 server/src/main/java/org/opensearch/threadpool/ProtobufExecutorBuilder.java
 delete mode 100644 server/src/main/java/org/opensearch/threadpool/ProtobufFixedExecutorBuilder.java
 delete mode 100644 server/src/main/java/org/opensearch/threadpool/ProtobufResizableExecutorBuilder.java
 delete mode 100644 server/src/main/java/org/opensearch/threadpool/ProtobufScalingExecutorBuilder.java
 delete mode 100644 server/src/main/java/org/opensearch/threadpool/ProtobufThreadPool.java

diff --git a/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequest$1.class b/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequest$1.class
new file mode 100644
index 0000000000000000000000000000000000000000..c518df95ed79f9b6daffd856f34d8eb068f67b53
GIT binary patch
literal 2790
zcmd5;L3i6k5dJ2Tqt;auJ8@`Z0;I*XcHBfwo0d?g1t%oLspI4&G<_Upd84Svl9A+6
z_$wSaa4naV2k*h19|g=RjvI_#c;)%PLE72b-Pv!xot@d=|M>Y=03TvU!w6y14{XEl
z2rm?7U>zCaMZ~h>d!f+@{Kz-fPZfLOtF8#6U8yY$Y72`RRKj)3ZyUDn+paiS-s~P4
z)n*t4rWNg)K_~*k=!)Yx(IbLVEFBQkHNPd&P;gO43ZsPay5osPx7`%M=VsFtgo(Ou
zneKrZII`bUs?m`X61M8Y@}NS<bR<Rw8abxB5%_Jwcg1>=QxbHm=5@N!eiR6^T}hmE
zh9=u#7QU%Fk*Ji01epP+*I!to6Up<^FhRJJgtg{9H(jR{pPc2ptKGvx5%d?Pk;7XW
zrU)CuVN%BxTxDpU_<FVLxGj0+d&OZnUFg}Yq>;yrhPMfg;ov^Ctm7TLOSsq;fh|sg
z;QRk?5S*fp`Iyyl4c7^JQxe~cW4<FpW1n})qM+jg+#uva5k2t^`8J0~qO~o;(6srs
zK20X8H{QDeZyu+-brEwKN`%Fv)lWQ`R`}jJ-}b@ugIq@$w+ORlc>ZM|+-I(m%%8t5
z=4C-9FoSTlSbt_dHx0)(YCC-hmC}KRMZ#pl7$N1zTtc{!xcNV_4I$gl)O+G2w-CyS
zi<6TOL5qV#-p<`2C8T~V5{Ls~DG|=U5J|Y3xa{2H<xDu0$T{Kieq>r-ZkwIBY-r%R
zQ%E}BL5ekeLMSE8OyrXwlEZ$`?wb{gI96QKvyGkRGhsy>XM{B!V;JWQyYF`cOKdo@
zM&{4JdR?d&qyf%l`;P6IQ8(a;ULw7JFVZVR3W&-hKAG`#&vO0H@$7989r-OzPc_dI
z!J2D^q2Rjpm~ihurEo6TgI;r3_lwSj2ESJ}{V>8Tv!?K?2l1a@8Qj;nXK+j0rsiJZ
z!jCMBAkBX{3}qCTSk_M_aC@11B$?+~8J1P<Wu+M!W3wsNRDZ%`W4?Ur7}HOGz~TdS
zTAe?}d&hYHHz^<E=Iib+$bK=czQX*eO13ZAkjmSRv0>TfIpxW=gxfqKp)E*IiVjs7
z!zE=L86|_flEsWNfs!(bvXaA+GKC7aE6No)8=JAO)t(Cs6L)YocB_gd++%lCJj8u|
z6DsUj8q4^IH8bq+G9Iv0W;DyFu(ZO~u0j2i0je5E!$S=pYYdac>|+hZhKAb{nJSN0
z2U)^RHZKoBo0AN!zGU$X-Hb<K9pNv9Ph)8v8*%#?dm!n~@xR7jp3UU2g*v8VFIdI8
N9JaaNV0i>ve*wSPPgDQ^

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequest$Builder.class b/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequest$Builder.class
new file mode 100644
index 0000000000000000000000000000000000000000..f80c23a713a9a75a01afac549f7fc88e6677a65c
GIT binary patch
literal 11386
zcmcgy349z?9sb_SZYP^g+ayiWhLD~qq?<rE%aOLylLphYG(DsuakH7E+orp5j~<Fp
zR1`!|v8b(hA5}rEm8KPxQZE$m`@S#mzzZ)d;P;=I-JRV|mNW#C-{$SUeeZvM|Kq*M
zLr>m&KY)wWECX7hE0G*%OAJ}@lod%vx3pQi(tICF#8YiU$wWHQwjw*R&U#74N~PDz
zY*X=U)6z_Au+K^w2q>H#O>A!)NF)XZEr&>NroZiSD{dttX{&Fwl}behtc~aA_e@Y&
zGd^;xNxFh4RP@HuD`VDR-#I-Bszbp{IvT9sJ!Ekzl!?cvQAZ!&S9flW?1;1tM&bi)
zYkId@(R91Qqya0v+)720v7vM#Nwu2iclv3TUz2LezbApfvP7R1LM5sVR4H6ICKXLg
zMUBGqWAU_=j7J80Qt3!K7VROip1j|B@_y^F{nk_Lp`JdEDy^rc$dt}l-0I3~@3oTa
zBfW!`7%UNu3~r1hWAfRZY|P4dx#d`XNi<4lC$gIsjbK0@XxNS`*xoLNJk3M{PFLv8
zavHNW`UM#U3>4aZtui|449rkiIVKOE6igMEg*gUhD_r7-w^0dXVlJ8#W-^#FNvpt|
zsg8Io9g7UcUTXCz^fY_0zicp)O0}Of;g9=K$su8o-V#eGtnC~h>txdgDNk4!qbiFP
z%9`hItUwvUCeB222nwwxLMSiC*$RB4aE^%zOr%AdN9$xak*tj*t$4cKp?|*6KbMS$
z>{*2cW22@Jj1Ds4Dy(BnjI&+D5SN%(fJ+t58-2*R`ZCTG7Md_nu255u0ts))oeK5#
zbbll>nC^%(AH}0q?z=0-O`-M*G-8Q~rFb3_&dDrk#9pa76%=@diIuX<v}fou0l4g6
zWugODFqy{+VNb+tmW`bzR-;Q{R@~aTAue!oBf~9ID|SV#p)~8ExXRbr?!tEeASp>x
zAe^*PG^4_*ae@J9PU=oaqT5zShU~m7R_GSou2(qUUj?5?&Z0qZudva?CcJ=@z2-fK
zRjGNrq;~jhHt|9<D;SBm2#^j@_Ez~rUQ_y$iS0e!q8{3AB?qjPoK{HqYnFG;xCfa+
zuZbQ+750yx6~@V&xg06Ez!EY03H7HlkzcV{(wj;rBhj>L$Q)q?Un0H5Vg_q085M%Q
zttPf%P+=-#*zF=Ek8F$#W|&MEi5-HmxQPUYxGLqhs=K-4SxA(PNSa82;Wv@8F;?w{
zka>?uEZ-4!r<1Yx0MpS9>@u)Zp|bcp6T2nJ7_rof?L+C^qRz`qTq{rxCF0Aru&=b3
zry6mciR-b46l`|e;)$JcyEd~vo;gCQ-Vo0(>$cJqL*W%BUWr#RE7}p@T|q)S{r&7+
zC3ME!oC@#t=PYe-Uq^f>lcpuD$aeoe%hRw9#0a|Gow2m_Y)Dy=%jqctHxY2QH)Dym
zjy1V&47^rhM&8X`nZd!e3A^jet*OAx2v^`%yxzcV3Qd0DQ>?m)H%KHHG(+F|$bjs=
z-Nc(@u3Y9;#53Dv@(vSk7FgEGq=P?+oLJJ@knX=&qWY~S_F=z56<d*%<#n#YhVl19
zhm^}Z@eTuTXIJ5;YDatrd&)lhd>Bm(F3t4!TgjZUOuQ5CqO_U#&SYfBV`+tH*<dSl
z0Sj3$CZJI`!#Bkg+m;)ua>t-`mIES%7T?YOXk)Y5mxwbdsm)AG>Bs=z@zVvqBuXpX
zZs0D3`F@u2<!#_2St#1a(DhrAiJi`2D@emirkq@uKiTz+x!3ZfVJ4JAxW~XJ6qbyw
zNP38wIE-N?z5YbfIWO{1H1^ExA<VY)5RRJoB<^LGx1np@ie+mq@9NmRV!6VyF;-14
zd0Mxy?kL<b*0S!UJMLLlymh~cW0EpL1Vq-%mG*(c!`i@Sn8N(<w{&;fa&k%qj^lGC
zJ};@pOedU4$uLBJ(qhk`ds$Fs`NBU>g@LEI%zKIAP+|;xrJ!0mcPrWQ=Tuvv!`*X6
zD1RO{BJDR!d=uZIw9&-SZfX4-X)o}eVqNC`4Y`LN#qMS0r{D9Hzt5M@*y6$y=l0c^
zr+J!Wdn?bj(j$axkfeVS_sIV&V5<>7GVx>lgykq=U*0rbq%imCCD}-y+A8FGm6TMe
zpPTq8exb0*pM<w;b=y6OA6`owPk1EBc={vaXr3=viy4V*zmX=2vdtX<d2Y*Vw;|GW
z{ocf4Ib+T&y`Ir9LZ@9Ugg-z}?zH##8}Fq0=c~B~gavJtpP@%;_C@<Y$tmJSg=?QH
zVLayd1kSGKn7xPftDY;?MQ#uP=EM+J{7qc(Vuj`Y0=b48;X<MqUPACOxh-O#x0FV9
zfgmFvSo}Er$HX!`Pk22p8G%Qaita=v$$O)iTqmFAL23Re!`ae*v&wbH2I7%4uQ3(A
z?Thh|6U4$Xwg$!W<m|t=eVi!fo>VYjm>qFG9I-E7t(2h@J#h-*X{a(Lu~BT`xx>BI
zG1LTwwoz>Hy4+B_5j=C0n+#Q<5cXS~e?;PaTw*Abne}Pb6E*qWhMK~Yf!~gk;b15}
zf4N|EYqPF)E`C{HT$^P-R~KBS+gEIcsvW@tMX_M0X$lQ~a<~f(RX>7_-35gXX&Av~
zp2aN8#bD+IZt+wOjqHa!JtW(JE<W>Hl}M#=E`zs>uOR<wxgO?IL@k%>_Q=b1j%T4B
zCMI#!WPWPmC_jNim~xP#MlJtNkXiLB)Y&uq7Sk}@-Lb^x08BiD`s&7NHH?}0jn!NV
z^)SlRA7H3QP{H>?#I)H=#5|l~ljIWsm)uIS6cH-JM=(EJb{H+;>az}`?c?@35yqkU
zC;~cxkbWPgsK0t>R(fcP`l8g8q^UVpg<Fo`yb?qoLy$x(NVHP@%O+aqY;=i|1TMgZ
zB+JJLxX43ZM4m>GFWw~N+dVwOd27_s5m5g{P(4md{Ew2KK&^VhBmFd&k;0;!OU}00
z`MN}xdG-c!d)e~1qUH7;#btRpY<KE%-@Q!v?%oJTvD(z|FqU_=4CC_sC~rB6=O1ek
zQe`$WY-i|6wA*BudJ3v^mB(&VU6F!x!y2q5!7I759MrqY;ME#WnmKkc8>2wOeQ3Oj
zmR#2vz6b65P#z}h4V2-kli1eL|I<*br=woid)PL(Y(vCK5!+f}tL0|g)$#^@Dx*+y
zgxjLi1J~`t#1_79IgG1M4`x5L9mb0UfsWFrF(9BDsq_p?)H5+v&!z-(Fk3g-Qp|EF
zx>As~D@BmJuc7+dHUppKpTJZlk;m4+6(_<k#pu&pj-zoO%y7#CXdFi5pg^~8lMN=X
z<(pyX`KZ(_sMD<;6HL!BpN;`+A$74lb3vueF6y$oi&MgG75#eI2M`P&Y`F(l+kA%+
z8^-ocH2zD5k=c*>Fu!^cBQbmxEfw4&C?Cd4#XBz_#tob74|!mO`Roq*Tzcp{ig!Nk
zb0OyH1!&P1;X-{eF431_scy$gz0f1}s+`!XD0UVwOkbfXGZ}k)EaVE_%28rY2kw@?
z`7EWE*yNl9qg`@h;TyT?)m$6kzSl@vP`B_s9f`fI4`SkdxcRChxaC;c;se-9onE&f
zP#d_5-vaCS5{SspT)rfGHuF`@*P;N|Un)j;qogV^O+ZX@0P|#WZ-KoIFsrq+)&`E?
zE&CA+EN<NQ)LRdry6dcAyzSVfL9t+c@R(~z%_Mm(Z=Ubucq4za;Ok}Ph3;VbyMht7
z8k2PwqizkR>9ts>*I}{l#uB{&9eN|W^(Ji8n{kbPA-3qNu}$}2hkh}3anH57AA9rw
zZq!@w8XdzedMj?@c)Q+aTX3;so18=T;@x<UZS%c&FWyIMPDUK>#|LPeX^7we?GnHq
zrnnE{L!1-5%}0fKg8yD}0$~-Xsd*gcQ>0pEKpD8zz=vhLbA^GsnG)oA1OH0CZsRD<
z4N4pq`#0n9Z!qUyK8A2NZ*U=98*V7@NDiM4Se(T5a>np=n4+&|4DYcCI|;uwr*<tq
zDhZ3fAHzYH#WfryYHCEjqxg7d%Yz6V!jS_Acyd&QtkE~2T;J@WT;ozMr(4(HUQ!Z6
znUV|mFDHjC<BN0m;ZrWJjH^x)dE`Kv$C-fa)1s$@Vm|tu4E08W<aUB&FO$O^n4#Z{
zIr=RgS(<WMHc`v0EKCv-JrCsSTPH;jchuQzE1$eBSKzWty(WDJQ{p=r^6x^8ez(V0
zbva-0;f<@@UYdvvf}MQZI+^lz>_-hV-tpC~!}x4hSPK7H2RX4Lui6}mKmB1k?k=kK
z5puel`2Q$X{1_VaK{V<^HrKF2+2ty!_Y3TIc;8H8KZq}qa~(UPFX15<t9DgtH1K7v
z`6|BVN_Z33N$k&}s~rjVp;`nwim$H@w^F`Vk?(l1eD_hlPf@;Ol<$6m>(jKx15AR)
zDdT5t`J5s#D<@xrD_;$z`nD~f0K=B5!IA1a_^vBe+y%w#0#LAI6({GsSa$EBze<t5
zMst0gVtfNL^*3!%9L&$op<y=B@DN$KB}35gy&M{@bkWcdX31c2$TF>b!p4OkB!0k_
z>W8e;KcWGCY;$zdbGA+^d>=n>RomgJHqWaXgY1XllIl5t{|(jqEiL{#GW$K%dzdBX
z5s!-Vaw^WFieL1qSS3eXSB6D&y2N)#itf)IfD$u$Ys{k_nxP!c5PpeYkwld|=<_4>
zYaddNl_FKSgx6QUbxF<R=w!uV{H{nMe&P1!_LhfFbqg=m+%0Fgx=)bIaziOLuf!v#
zyr&0$ApL?e%>QyI<1b*aHV)&DrC9dh&(Cc8qt9&nU!K|aem{HtwY0*2Kjl6ACn9%`
z7cu`R#byEidFosKb*fvI`9k^Mr370BKPZ>n!n<ofll`|8o1gkax#XUezS=A=#b%|i
zHY0Cg1^b_!c~0O7dwdd4aqI=}U6fXVKu86ZVUHm-ktd0I9<(RhpDQ_5PcSiy<5bkE
r8dawP6GCdbI!#7a!%B5J*YkftRDffUpBp)Uh~tdQ>eWn}U*-P+xO%u+

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequest.class b/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequest.class
new file mode 100644
index 0000000000000000000000000000000000000000..9da2f0cd30b626531f60edf3fba0a7fe72fba8b3
GIT binary patch
literal 12446
zcmc&)33yc3b^ebu(r9@IA!KYJHe(FZNFW2oYyzWYfWca@7HqH+F&aHd1EU#vW(3Ag
zw=`|tH0c(nX-E?%X&NUjNgWJAHf|cbt&=8goo-3@HfxupOPaP$TgUBx-g`6iH1iOM
zPQL2<G;iL$_niBm^`3k0eD?L{KM7!`^!ZUDIG9LIv?Zp^c*+bXBa?0BqiKGRCgQ2K
z>0~0EXbWZ<2Fyoh%vAcQwr<F8^}{FF7)eaEO(YT%G1Dd<of&UCWX8>8IBkygnyFNH
z!aTO!k8(kOapvt$cFsg&V`frNn=+HpaO{|wRQSW8Zh;&TEa{>w>2N%KEF7CL%P6|_
zC%A1Oc>i#4aA@fG(cs9zP_U<aq;I&lGdMuHP$>tAz)0Fc51pGfM+CPF_k~Ck>Yg`V
z$5NA(Gw~=j6dL2ex}H<vGvT&aI6l$VKYGfHr1z3~%A86>A2Y{7sZczcCRTmnY@Gz(
z9X!}E+%q&1>Kh#D=<5m!4)+vCMVz_(Xve^y3bv}p%S1=RN$QT{DhHzz@o;)3X$r;{
z7}{PeX!|*7MSCO`r9SoxN}HOG34C3NF|!JSbp~$7YQk@~`YYLVhk+Hi)sH)=pW>)z
z!`3Qnz&d5#WZ*V52$uFl<7VH?)To&p3XjI9jJlpggsv5)gYn&I+}`A=qC$t?;P~iX
zmF}L!Qnd&6lduY<*rNJqQKWYnSc)YT*d~C!-)*1{%k|qm2I_GOm6)E4rUd@cOnBV2
zSg?W>^QC4CWF%iCFBL%rSSP5Cn`c8-Kt`z7!5db_aC|0ZjvY-#&oGzJVZ&2qnm*g?
z6=>x%)?mTCH;VHb+?hQl%yhSziX@}c=>(I^mZoM;p1Cop4Y}`oE76UEegp+OZpvE?
z9KvD2ebG3DjfZ0+%w*|kWQ5E{a!Gq6m$XN$q&<?Ko=3)9GPEv60>SFc<cG}k!KfJ<
z>xe{{$`hH`*mn(;c*H>=xuu~V1HI^@H)LkIX)(t=@a^>!_r}oqaa7QEQ>H6eA~RW_
z3IiDOV^FZ$D;eJqFayJ2E?LW^n#p>eTIa7VBTcRV>57F@sl5da-X48JIGDbdGeVrw
zKvzj?m9;W?NKiAsPY|T9+?+ODQ!tf0j5qr620_RFnVEqRoaD+ko=DmmpCwUKs2C_K
ziE`9H1YF{c;l6=jSO1~D(1{@HlCB~sfy-jjOwGj7Oj3jCaO8Avc-l$N)l~biQ;Z1e
zsq<VlGMG+A;}d)RIK`qPzuAwNV2zhocAiU{Hfa@3BW@spNs5(D*p0*K@m(}}(i|6*
zjB?#s=NWW4E_58>Fn67lMRsN$GP`_YlS?S&L+bU{$ULrT6zyXM9><%AHj<b=cQBcl
zveDk{4h?5=?@(~@BkWNsJUTzhSht+uT6;DbO`AgrLBM-i)4FD?e<nRWljeM8c*-gW
zs)CP3%;~h2+<v@;0cBYwnrI94XM5C_e$>E^sV}W{>ei9qgG0f-!BBtSNLSDB;81X2
zgr(z9P^06=4ZIZ((ygg9+pVkcHvFU?Zx`I@W#0m527U@ZO$L@s!T8LSpsXnrvI~))
zHSi8RY3adMTySbSeU25bTcu9j+k8S-{+~1OF8n-~e~X_@B-nSOdJ4HbIK!7Ek>I?6
z_uv;Y-f=pfI2*UJA-!YMHN0auo*Oo3rkPFNhxhyO6pKqQ&EyR?@Pqgv#$LiQBWLk+
z^a6F#-<Q!AgVq*B%l<)rXubAJ20n}>bk5A?Ks(e}A2IMz{4$GCf}+EiY6I<a>=06|
zUNG=6e4MPEF}7aqQ7f9flt!}m;TZ$JsNUgAS^Ubm#|g($%J7nbi+EBMJ8NJ9lU0b~
zl9F6vbSFlcGs+U_N!@K#OomgFDy9nYYX&~4Leyr2IP7#Pr%xH^KxY+Z@REV6cu;x1
zq&#0D0_8$4o7NqOhNd91V#OH&8hD*E<KtGLcXO#ezY=2R`)$ECFH48wXSgL}jmZse
zBoVVG&W2z$K8N4+<97rry@>5Sl!2G=dxB;s4hm$*C0xggse-X^I?T|qJv@&>@K$eD
zo?hpYbt0NdC(rdTAF)I(lIBzcf2b1vkzl9@usoEpEL+JAn6?OlmPN=aIOUyETq(S$
z`uJ1T$DeTnb_3IT$otOgk}X2`q6+qxD%f9H;ppY=E`2Tvp@$B7njY#bD)cWY^e=P!
zYBBbhvE-pn!CCe$3VIQv=<AB`Z&|)B7K4W{nS7}QL)=wa6f5d=S@;J7-@rFnN?LjP
zfoOWtRhtNodV8^*5}o}<0X#3Sa*hbOSe8XqmTX$gqt2zpypI15gQ|kQr3(62!Q+e9
z#G)WCth74IJl$q2I>p34rt7JK`*#EXq1IbHzdO&2I`TU@l44AIi(yqY-!musZ`I*z
zg0T1G8E^7Zfd??JVLA8O=&AJrHiGwfgDDv4$?to-9@Ap18}SVh!P~rXE=p;Ol3`)}
zF5@YmbLhzn20a%L4BYhI-=#<E3L<lo!qQ!&%#d=SBC2vzYIB7lmD*gHPGoNg&Nme+
zDHdzJa!JxJh9OI&ijb$w<b+cVS6b(JX)3S^{d#`-gtwtRPHP;o=>ldvU9>829^yJ4
zNXv2_WZf(%o?(?UD-j@1u08$lx`J`}DUwyQqVZgUd$n$JJj~;j++p>RqB$@ZI2D_h
zE<A3z#x~UnUBTpn1B!YTqh~DkyxFL2DAYu@?~ZFAbMmaU`_NciXUJ-~jVBiikEd4N
zaI=o&={pXNtX&n$2181umb;3Du_*R=beoip`Q%!s3i)$!ha9%f$v5oe!GgC~t|Gem
zm|t3XqLnM~La~@R5sq~vCuXJ?AK87V3bDnIHVLpgicFf3(>XSwlzp^SHJF%5MtCl)
zcULR()2Fq;-J&yb`3S{%J!>5dn<>BC&9f`7%$~c_a9?lu<sKUKI^&s{bJTv>%{vq?
zifhL?57wMi=9hNvv=&EAceb+2l6mQn5kBwG+&Vb*%K;uq-5`7K8zXKyygU5Tb&d0-
zJjd}1FN+$zKsW>aa)@5IzyP=F`h}<Po)&Vr>0qAQ<hzKVA-~CW(_Za5jHjRX@mB$d
z6R9+|^0cRv|7EDaO8EK7#Y`{9QH2IpDoe8OHEiPrCi@yt>uO(yPQA#qXn2ju=Sscr
zwVu41CH+dPuMw@}z6z_^vW6}D$WQ-nxe7Uc1#6$h`m5N$ZyTS*rcbb=1kL=cAv~14
zj;hjf)R#6OVD)G(?^XF}GjFw6#`vyGR|HzFU~{1KGTH)lTQ6gKpyV=kD9=)h=L(7o
ze2JgmMU~W|R(25hmo45aY!29Ii9lZ1h24a_hZF{%cFSIVQv?}dM){_F>jGEMo<Fhc
zJtx;1DjWC;e8f;m3`>cj9$%%xzJ|5<x`oA_Z=Hk1N0sg8EULVA&Zm-AILdp5-)()B
zTR6VylBFUmO9k%50rofO>7K)BgEb!TT|`$tmv3dY?L!Dh9EuLhVSwt3xUWv?`e$)}
zj<Ajb0k3k%e^S8j(2HJmiBj!A5j=ng9d>Pes_M!Dm(X@$z8q5OA}-4kAIAxY_>Fw3
z9_p2N4iELTd>WM(5q=uJ76oP7yGqAM6)L3K;%D2q-r-k4yP6myr*TpkD0vNaems1D
z|7_!lsx#M<<f6i@=Um%+T3$r--Kc2!6r#`Y<8*K9ET;Mbo9S(vb2G1}%R_EOncN0L
z8n8@O@ut5KD`YhqWeuytwHBg)&DlXzM!%Y7NHH}L&m%~3=0>VBg)}8nlnm3?u*}Z`
zTAqsFQ3v4@9H+l*S?5AnrwHe8t~bz1Xss63e0<Hs7a+dPjD%J!mlo8^7XGTDjTpCD
z_}1Bcv-lbveDy^2eHOkfszyb%4Bw9*a8R8hDz#AqQSE4N^t~Ttz6*`#QC4~(;A33+
z)ab6jlwE|gn{f7^PTFy+>~k5dAq%0NQ{2KSbYlK2>NOIS@s&sYobAnQ^zrS7t!Q}*
z*(-u=>LnNPBeQtoDHtt2eVxTmsJ7<tGw0c)PRQ@?49w!)EwgxUE@!MnIW5`6BlB)r
z?;tIA2+b10RypE=x6Ogax$pse(1GVe$%;CD=LtSPHGXFuL_M7EL+y<vPob>wLTS4K
z%HXSMwD8U0>66-SBdlq35dO-^_C^Ici(h4T<7IrPF{j2Ys3z7vs<EG1xgRw$KuZo{
zl?-8{9K&7m0QSmp{>I@1j>tnU{5@Iq9>OQAByZcbRMp#1PxQQNaAbIaI#q8w+!FY(
znv@YC=TWJ-_t^{dI_Xt$TKP}uXzN*AW{g~(#TDE3M9+6hFlW8H+#tZT0Xa$hVfZCN
z{A2XUaeCw=@kbGmQ@BS?<DkS`-g!8y`@?w7ik=3v;d$oq5+}0D{Du`ZvUDkB;Jt<;
z$#Wc`{xL+rFEFU}aiO-ky>@xy<Q#r|7B8M`uf4Nz(#OY+#z_^+ZYXmaEU|urFRR&W
z$@H7HRbD8t$|IC0NoA&)@n>k2GgvQY(JGH(yPU%Tc?`YsI0ocRE~^YVk}X9Lzm>HL
zmu-V<^~?A)!Dk%)GnRYpWQ*q1B^R+N@Ekr{0-7V2q^&hV-fYcauQ5yT3O-K)W%v69
z>^dE9tx<L@&*2YBz4$%hLR{nU)Ajq0@dbiW&R;CxoCowzJb}JF4`|W>`sW4g@`3(^
zC(w7~0abqUf&O&?=RBZ);|cU#c|gD70R3tKyL_Nu^91_dJfO;NKG45&akg{aZnmiD
zxjJtO%;E3n8Qxw9Kggoz11_l5_(%K`Nz_FDT)?o~F}`6Le-8iR!SSQ0mXEl=8V*NY
zPBZ5JHm(cy-#l1<oM1oZ3HIAJ0QOZ6j+Y7c(sjVT%<?4{RGymsFAvsN3HJFsu-|nw
z`+5Pxe9iuk2gjEP_QgD~$}y)|(M_(C$hPpQ#`n#MFF)L0cH#0l38hlc;T+mc7A4ox
zi&#G^{(SP!Smc@|m54i9E79!8d7BaiW~Dlx@N=$ttEI*&t3?m`92O5dELI0NG4Iu{
zqW}06S^6|;oNpPXc8Or^2jmrI(a&=|d&R|kwIh_SSS$#Z9r5${&8J5P&P=`ZWL>bT
zm2t}zS=QT{18axI7bx8qEuMD8lPOq9B=w@@MkV3y60IOB<yKa8wjNwn^!gl6E6<je
zSp00wHONX*T6-2&fm#W;C^zL(uF6u1tSX?)8k>QcPkFmbFBxNtp6EDuU9<&wHx|;?
zc93?BLwhHm>SSd!%-Xz(+2L%^ERx$7N77AWt#?Q^QctS0@<7Y1+_BI!C8CH_mu_Sm
z7ba<1EJ>y3EcszVt~vQD#cP%YNGhb6b$B-KunwOu)tqe3Z6NK9UUoiSEZjvEl*m@u
z#^)$YjP0^RcCu*N#lAhhO4-ZjzH)=VWh|BbY`>S!4hB)DbjzOdN;xQp^+_4JS=2Vr
dHSNEC9$)R@dl}pBWB<c^_8e%CUY!r!{|jUV`F;QZ

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequestOrBuilder.class b/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequestOrBuilder.class
new file mode 100644
index 0000000000000000000000000000000000000000..c7078d153debd2507ac75ad4f2af4806817f02d7
GIT binary patch
literal 697
zcmbVKJ5K^Z5dKz><0T^C14}~zjawND8^vHGQ8A+S2aM;D^A>majQlkVe}F&AIGl<=
ztSEM7cAojZnUBx6cL0Z|I#?0tDD6o#qR^15`;U@dE!(~djT~uZm2CYwZs<88W3MOP
z+M>6kn~@(3NIOUh6o>AMD+4$5WT!WzzIBiisP)y8^px@f`tIF}9^@q%<9al$7btsV
ze`ei|M|AH75eX#fjkZ8xJ|@trH!hY#Ff-yvAjggGLZ1<~2LcuD`UjzFwI6z%RGdj_
zjx8C1J<j|O)+9Ww%XU?y`*h|93}knax|q=Y$vA<0I}Aym2Cgw=9FzqPmO>{`T^uuI
z*uj>-$x>}=Go&$RbHDTzAIG^emN(7o;<w6YmgH-2kY+<5gKVsG$j5pO1<pudo#hIO
X*kD~^OR%h@GT3CjeO$#(94~zVR_E8c

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$RequestType$1.class b/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$RequestType$1.class
new file mode 100644
index 0000000000000000000000000000000000000000..78f78e3f45ec3b10536e5ce88ce09c25585afc12
GIT binary patch
literal 1234
zcmb_bTWb?h5dJ2Y-6ma4(rVSF-fCKtC@wyTNJ_DW6a#4$Tk?LgIoWL4oD=sV_R&8e
z{uF&t@xdS9j}m8dfl@?@?ZVlaIm~?DoVon^{o^Nqr+8>0MQG~4we?u4P>R4A+VXwG
zx~ElWj{_ZPyEVUfBj3g{j9w?Vm6>sPJeHNmCNhNLk$5L;Untjp)jN_-WWpd+9X+yL
ztzBPE@p|#VZmUQJO8AwQibowUl6zuIFt$A9McagQwbmtMnz}FZNMq50i3LKT<0-ix
zk9smV6g^)OmO9!IepduuV$Uu!(a;MCt<D8JtU)LZJk{?CKb9|!r{sj)YP)uR_(mSf
zxN71GVdvbrT3A7ekQ?Y=o~6OX<ysM_O{ga+pQ#s|7NKmRnBe6PbR0Nx*GtO1`qxo-
zl=PjM4?I_iC=S^1L+A7?G|tA&bFg&*h27@96<W&ib?7N~Pew!CCs=KzWYF|Q7|PJZ
zJ;KJB3Swe|u=X!k!oqx#35#=;A7i3Mc=BJ(WuOx~#ti$sdoOhu;STpF%_qxSoaV#J
z!B&nnn<cT#*1sYDg_RU6{u`6akGRCTHFdyc6xiaeMT!4O@H3Vvmf7-mEPZC>Wbmg+
z@XFL-7R;`=hU=i>4#V7-!ECZm0%O$6U$J@`hbA}^8mvt?ZsOKN-sX1!8D0tCE}wPQ
b*HOWykz<|;?z3D*74_!{)AW15B8BQ7DqBzw

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$RequestType.class b/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$RequestType.class
new file mode 100644
index 0000000000000000000000000000000000000000..4599b900d15dbfc53dc3f8d6e2017634af94479b
GIT binary patch
literal 5611
zcmb_fYj+dZ72RXm9$5?^449e#QNRS-5Ic|nA$9>Hk8KrM21_=Gq;-Tm2!T9fq!9rU
z$g3%B9(|L9w54g<qzP?OVuJ022GVz%ztC@8tKa$?y1MVx*fX|O>L%7&S66#<?z!i&
z@0oKy`}fDU0PMtPDk>CoSout=HENgzBb84dZ#B-?{GGMTLhESWvaMEq>OsG8s%RAK
z1LA3e0}^LP4HcCNmYhhPPPOJzW~Nm)iz6zk6>LgdBdr<B%H)iauA{|ct#WzV%JmwB
zLMmejVFh>h>jww)cw$IDoX}(ONMCFy936-!^!}lEq9dUz2uHuLoox!%-(ep;k%+{)
z<1~A&P`}<Ck=FDJBRj$gT1d$acaV%v>$`WZlpY(5^!LSj^;lxa6>OX<*r^}TW1V^|
zoE(b8y88NiJH*xsg5iFhaTyBt^&aSpQH_G73|fS;hlhImItQYRnbxg))oTN>em&gR
z9g7^%I~8o4yW5PI4-Ixi2dG7fC|DdOAMBKA52kWO!$<l+K^b$W6*$h9bO?Dx!F_W#
zEE`vM5$V}<hecD7a~Jp&Y?-^DT(sRaByY>yHRS{EuBuW{H#-OJza;<4S?O^9R29^E
zGvof_XJWIaZRE{VPDZ*nHL9RFTJ9W09JvN@f}&a5pez|)6VGPMlwHgl3aoiAY+r!W
zwVS(FOV03QbUv~G8WmKX7JO5%NRJKlHcTn^x2JPiGi&cw;A?CeR8SeVh7CW|09pBf
zh6k~ornEaEs~V$jZHn9ZteI(xM4AR`D7;gH3cnvU0z9mtMu30-U)B&1V37cOH7pW9
z6CkWX6JW6bT^be(utb1}h9v?l6(Fi%sQ^I%`ZNRuSSCQfhGp=JUkMHOVY3Rl5dOmD
ztzl~b12`<)ZxzaqXt)=fL`WXh@Kt<`A(7E6(CWsfg~*TC<uMJ-*v#q^&6-B6IC9j;
zCsIdq%vo*JN(&n2vjRI0Ychsil9IWLs5r)|?B*wu%Ndzet|Ol*ju@t`pGg~|HeW`5
z9Op3&r_4=uh$=$%aU(?DbGMLnER-@sMf0R-J#K~!J`G7fTLLg}LWJWaPh%MplqfKw
zVGEX%L-z43L$f$;r_v{RmK=jssjH7xb~Q$t7KGG+PGdB0q*Jyrtf0QXXxiBkV=!CD
zGE5z&Y1t{^F>R^y5Z7JPCQ^D@!{a!`<9^J_PsMZjRO#q8N_ARRk1dT&^DYBC!KeNY
z@r9}ywan<CIOv^5A)U{T+E$)N^S>D4$`oYjo3*e_#Rc{ga~Q?6+J=WtPjiQvbQ+%C
ze40|sl9e&D=ZxW*ygH8)A_>oF_&S~^XK24`mV#~bG~HdpoL<DYRD6>pFIVhc$&%A9
z*6;#eBoC%SNZQnLd+C4C&gNR9*@7)8^Rk9-gN#$H{BV{pm__(5zOUkYQ@z`?w1ywx
zhdiECDGm-<??$ul=m{fjGsv&7($2@yS?N)*Vn(pKth{I;1GtPIsd!z%_Rm!ZMIwGY
zzrc58a~_^CGFR}1il5FS@H1Cx_?Za2Mt8&;Sa`wMpKC08*xY=TC+$KMmH;l{7aHCY
zj8tiru*i>JvV{`%&B{Y4TL`hzgjhaUO9^aBvtnMtyBe+vn)s<AVh$T;SQ>|UG?<#t
z<yrtfyf3QoZ&=XERAIh}1NZ>fRgAIwahVoBTd)ll=MQm%^iJjTsk3Qo^eo#UuM&rk
zk+~EVuXqKAyu!}Qe_?{{!=#2$e8jkT_Xy`wg+iOhoas$n*F-*8Y6Eerm`@vmRti>^
zy=JwDMG7u>^ohj_Q+Ug!v&{93rfLz>H1g6nqoCq8EA0O`{H!X%QkVD&mY3ln#bzEW
z6@TQ-qMY(_4X=tnD_C<UY0*2<4yQpT@?2a=@)$3)JyyZqyOs6a$5Dk<d+SA02ykXU
zC}*~Ua%LAOXEuOxX749wwtaGD$0uhtdva!<$GcBGYO$QUSMYZQRub2F@G9ajd2l`P
zY7f4Pc#Q|IC0^&jcN2#^_#Wc*9=w6L!GkwaI~zmV(<tp}B4!K6-?gF>0)neWS4u3r
zY(Xm}@8<>XF~&xG{&f>dvUaP_H-T-}u|uMVDk~-0B~e>dl|=0l?XIqtXpcl4sw&Yw
zi8}p$iFAp&gVn*3Y>&iW397-8^nQtZgZ^MiJ|^*jU`>TwelQsLghu(sup^$V9K)`7
zvT6+N@nrQF_QaFw81}`J{xRtBWRQ<~IPuwjPJ9^SR5ONy@#~1+#6WTahpr<ziASzu
z=mYv&ffT=wFlXRU8O<e(*h;KrR@Pwy?qT%SV=Fe|A;xtNn$X23y^LXk(R-Bt3}YK|
z*bW;z@FaHeUG*^j&X@5&@G}0%f_+r(0^SPJl$Fs&QnHadHq*4XvG^v8WNl^w+1t$@
zBKK>q@JYMsWLAc0m%%&AG2TWD>NzfTYSblcHYE!!xkgz=Qjg*km*@EaC~#C$(B{lE
z%XEunRjVgayv83T|Ah#+MA%x=TUBBU)v*(GtiHur$Q@aImEXW2`3<@M1N^;{qm5$^
zN0_6VV?Re9N1WNa#@unVbL`>R$DwodaO~%ZT~mZbCC^*vFK~`;mM0kbC((}c*ozD3
z#8c?O(}?039Kf^8!gDyxn7fuAaV!@R;Wh6;-_(b`oWWUoTsj%&WI!6EM*w-1oE?uB
zJh^*<Hk5LgadOu%oxAhN+NUP)%<V}$JC1KOkK?6}@SO^Lic79PrA)rUOukCbUSlR-
zWhP(u*xfKYlglXbyt8QwXA$~J?lIfUD;_14j*@!OyE<#{r_16KoWyJ6_=(Rk?&54c
zZ%(@_IP|8oy6CvuM8AH{-QRN9`nF{2INqsv13YdAnZO~6ytB>qc^$n4-sM&MDo@p~
zcuBs>D)}By*82$In#b%W{wr87a#o3o6^m#x@A-}iJv5<`|7gvd*G%BO=CwDFbI<M)
z{tMh7&Bqzp38}SCx~w_D5IhjI&qoIEs_bap!Lub+){P;a-0y3?m24Mfrq_4ZB(80l
z9UNswaK;@S&D=+%B~Yt0Ph#RzNCtb)l)J7HA5*ddHy!@{7M~Drqum#Ai)5*1dv*)I
h<9vnl?>YYgf5Km?#XbBo{<^oG_y5x8Z&J_Y{{VC&vX}q>

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto.class b/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto.class
new file mode 100644
index 0000000000000000000000000000000000000000..9bfc6458d4dd93a78e64db200ef57c11d880139a
GIT binary patch
literal 3318
zcmb_eZBrUo6n-v?F0KUWCN^r@m?l&aEktc<5^Nj9)evDZELv^aZdbS=n;~GACDVNC
zxBia)gEpCI(st6xOuzL<b$WI|7J-S0%@@w@-t#=?{apU}_m95-tiTZAW4KzkDvA0b
zuQj+~mF_3_4>moU^;#owXw~g{LOJ?S;NLfS!`^njitsap9~h5}MAfKO68VD%yks+M
znKheRHKVFGY{NE7I<e~>yY8{;F1y~#u9tbEWSNI{-C|hCmg)}^m3qBW<t=Xxn)edx
z9gRlBdrmTF|J(RIlUK{BQi(Sjb*pF`R5?R(pc9+C#x29<<s9i66~4P1+2{k4Pf~Y0
zR|ZmfF*Jyy%Ds2O2Ubf}vu4_#GYHYST?T);Ugjdkj-_9-Ewfe$;2q|hmS(&p4=!HZ
zO}#u#wTXMRiF>e?!ljB7?k$g;l18mo9~2)S@(Fg4MMFyq@e`=x?cQ-Pa##v9YbNzl
zraa*z{7CHYpM272x5{N{x}e<IQM972>=hMN%j8u(o!!xjN<r6(siG2o`J+4|U3!I<
zQY>cFO)bpid1<y^ub^yZT)Ki|C6z9c2`%iCXQj)pP}YuE1vw_o^eZarZl;h|bBbEj
zJGy>(L5lY4t}EM$x~{0{eLbUY<O{i!<3o5zJ|~6K1%-mt)A`(XUL~^duzXe;qa<Vq
zv8U(q>pNK`EK)9mn@X3dz}oq>@!q1j6MHc1R()B-S%&yYb9KBACCC^L;$56)xNtON
zYfZCS?u>y0*s$sk86HLNX1&GG>dfTbH|_knHwBD<VKRsjND@807sUJcfZ<Gq+ul4e
zEJfd#*a?0*h>Q4;VT|b71MjqQgFz-jH`=CcRufsXVJAm%86Sy=Foceu1TlkInqwki
z7>{P!$gTyN6fwsTJE=NeL{8N6K@4G7#K#QR2O&E(dey25Ai>Z*g8?kk_StC<s)PkB
z2k{B6G7PV_7t&hv#3Ff~QVaBT#oVsr|4I-d0+igWS>tN+;Q>Edy>hl*GOD|VWjd?4
zy^llX&i-FFY=hzK0A>jSK6CsH(#Ev!n^dWl?5S=#+QH)%uTWvRm8w=dvqg;Y!SQ!g
z3NFlgoHcEpbar>3MPxmuq76*lU?_FOYg!^JPWNvFaT6(q+1E4TTvJ-TX_dG$#SBwj
zZg^LI+$kSJFjJ$OFI_bn4c-uuWtbk+bY9^pQIhvYLveh!h}dSB8AQ?Fw={13m#hel
zB0g1ZBfWvrrP}*R1Qjm-cIfk#yEHldwVCX-(>W8d&yYHu!LB=$rdg$bYdP-B6BX)f
zhFhm2?e#RWDB@cN^)0crQzGI!hV<z;yTXnvVv#05pntdmrkuq{PgBl<At^c61IZzJ
z8%2=x&d}S>bjnDk{Vx#O7v!+E6%$@SevWfbG4UKzzu|)LJ1+U~649rK{fUMBCx{KT
zwBy>oU%sL}!_rfH`YX}+aE*R%AVeNq!?182BP1mugHho&#z@M-EsP5}M1(A6g*@hk
zZN!B;SQS*P2?bmyyyKiiOgE5pIcbx%-A#~m+#QNN!>VU+*!?JWz)qB(;|o$8ah5?F
zJWuZqnDqjsE+E4i(rw^+8@NKUW%W4}4;*qcJw`_%_z~_R86uKRmxM0jHc7;#0Q^rd
z@e7@`QssIsEW21AeHC!aJ<H%W$t9{_6kEt)k}l#cs3aGV#~qRd;wzHeA^GL-2=+)O
UZcgGW!i5M|z+HSpr+d)<1I*vmkN^Mx

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskId$1.class b/server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskId$1.class
new file mode 100644
index 0000000000000000000000000000000000000000..ac4a0619266151f9cf2512d9087f67d9d9307815
GIT binary patch
literal 2505
zcmc&$U3U{z6y0|^VIYJyDM4wiS};P=&<=$Hg%mU`DNRXJmZfF+IGNn01IbL*%mmR#
zAN?b~;!APqTKevfQum#t5$mi%o_xrhbHC2rXP=LoKmPpXHvo6AZ9o$+J-=moUFinW
z^6djNw1O9b+4a59GoMngHlHXx*Vl8426TbTw%0LRp4V#2{?<ls-z+zR(6{XHiRA~<
z7dW-zxK8*$U@TwQ6VTVZrc7cCXHrPul)yyIab>;NX-NO6)o4qB$(m<d?LEtP)Oawd
zhX+m|uvi-rXh|U5RZxg0bgcHe?{x&e&)4FxD{RfG+wFxrp)ajYDRx)oRY;y3&;3fa
z96I}L%?V|xFd8!AN>*OkvK!J+U|>?<MjWK7`_gJVefDjyz1rK~m;Ufz5?Op;;DW&X
zNW7%*AubYuE5BLoIqjwj)ZP4uF60JBOG!*)#=u7cw?;y7WFUo)@rl5hj`UlyAD|!p
z_W&J%i@cjn;Sw$jq#BB?K`JpDN2QF$GRURyIj#s~0~zkR`z(*(KsL8z5Lhjy|Fd}4
z2kV1e8$DHcbslpD3WObZde>ET$_jD58-f|;Sqep56PUGvlk-vFHYtfSfAYDAmj%@k
zOo5B}+H>orWjdZ&-5x?H74{4)3Y?Ew6G%9!Y6Y&uUjCoD7RbosRV+}9Jse-|0!EYz
zs&ej(R{F!t5)h2{QtYko;7j0U?6DK0$ewc{mRf;xJE3L2*s{7&yEVXmor??OaV8CX
zDNu;p8B3dhjL+`lc1P>HQA)Hew`FcOo=ZDqIti?$Fpdc}xgD?P+j8AeZ%g{E$813z
zW82wrTCNrLd@k?ClKSr_ZDq7*mmZMziHd8ty})r>TQWTGn(QQ1*OmTS+X@27_Wziv
z`+mKXFKXWhX5g@QpRUUw-0*@Bv-Et74?ChSUs#R}j!a5HnV5Tn(?3zskmOe_Lo4Ad
z^;CZY<vEUoVvoDh)OC(B%8VGN*#u|GKjVCTzIg2rQ_p_H;yryzpFhN>hxqJwr61zz
zKf_;<`Fcu!gZZN=C12B!&TGeMSjlO2CnXEG&J_i1L4nfB(6u$3)gB_PRWPlsV@7*~
zg0_L8R>hLGi4x_CR#UsN5&2pkxImb=ft!(AWh~(q-O+I$xB0hcjE*I-jJuqfp~K6#
zN3BRS%P3J>p|wlU{~|!$fG}|1z!wH#Qq4RzkgprKKAA3ay?mS{T%~yx1Y=GywECLr
wTXYkT!m9C?z{5zZU_FwL=z*d;%WsvxX`0Dm6E#dlUT}(YS!{7!r><f1Z`}{mpa1{>

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskId$Builder.class b/server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskId$Builder.class
new file mode 100644
index 0000000000000000000000000000000000000000..f5716e6de1a6421819e54c1f7f92d92aa831d73f
GIT binary patch
literal 9996
zcmcgy349dg75{&mU4~5tNJ7G4Al#U2fG8j+0V+4aaL6fG4V%p*SqQsvcfz5FXhE&E
zwpCh%dbTR{Y7rrzwt`n}ZEL-2@7AlQM-SU-5&C~Kvzys4i3#+l{IYX>@4f$f@BiNS
z%{M-K^pVE^OjNlVd<tj86ZPfsCL@+K!ih*jxfxEbO_nz$;%2;jDbFiw7s>f>`+WHH
z=4fNBk<j2*7!!%FE3c2o>l+PQpr*O5e2x(_5@FM*oo^(Q;d*2FxK^2N3KP0yZehZ)
zr;uF}HD^bS#@f@W6;!2y7K_&!m9@OeuUZpcA1-eU$Lh-$)~qoiW`#mlR352$3O(u#
zbEc7uB%)1bJVDqcrBz<YTgN1ax1Lj#e+DfDk%!(I@)bsQ&IKI>C{&mnjhRLw7H+Ig
znqe~<sit&wYrLzicvoBTuC`-bUF!lns%ubtRYhaQg64HKMq+8WrqPh##3SLx<>5qB
zuAQ3$Q=sM;c2K89B1~62B{Zd-5P2lm%1MTJg@md|#{djen3=NFdH3ri%NZIKDm=r`
zIXD^yDU9x1(j1y+V+e+67^-lV7gIWASI2OSP#DC@YEBp#VM<oUqGmMQ7`@o2Rj4j;
z@pndJIGL<C?uIvGJB33CY&Jxb3KOfk6ogdWQb9MeIBHI1Rh5)3&qfx?bd;d9J4P!Y
z2!(Q;hirzcq_c@~3VTsFVZ_V|TkBZSdK%3&S$EkjPE4CZAkxToCU{Cu&}s4VOdV(7
zEQPV1F9*jh)&NPXLqm5to1!BJx<WxlE1J!E+tkDw?Qh+#3pY2Kl`*!7Sj0#_JH4wO
zRAi$V({;?i*{uHKH8VIh(!{fgYqpL#GEBGbFc-o~k+0M-59hFVMl-p}{I3$h`8pP0
zp~B#pv0+(E$l=i0>H4!aMvNvi8jmR~_NIh0u)>?!9qJT9CX6JbMdEcWy%g=S#0*E)
z&JQ<Py-=K8DzsasFwPsPN0p_rEVNZvq2oNPq-J*%N#n64T?A*VJ733VQOXG}9uqre
zkPyq|XNp3vx<q_kwR<WIt}_z##%$hJSnlmWYp74G{>8_Lj@4kZYUr|0U5i1w=}7(6
ziP3t6s!#IEt4U9*Nt%gp#B{t*D<=QrW`n`zFwnERq@pFvSgWHE3~Z2Pw7^<!u!dQX
zt?P{?W+ED^XU)ZNk%lIP+_ukjB&3qGXmZxNCUcVn)6~%{84ku{Ga9&RF<6Yn*q~!0
zHW40;RWj79wRtl75*?dyDeouk`;$uMop@6##$`IT;&K9|nPsuHvG|6VH92vDIJKQV
z=N`7iFzKzr=X7ktc6Jzxf9?@fbfI^`+@nO#iMpY1jkf_=sMS`+nwm}K#R#wSUN+3y
zXmV0!b6RZFM@f=RRZ-J82{75|ZkN>Xd4=8<1)}lt%7y7C8m?6+Zso>;=ElZFacgmu
z9+Qo0P?nAB@MR5OQW);V>b4&0_zJEkyXbB0(lBd<tf>?oJ9K<is9PvcY?dxIE^3Y@
zjAdrsnKI%=9XAQzf-<5qW=<F{HMdL0*KxB#9_Qes;m(-Cvj2b7D`h^p6}M}+jSbVw
z<I322u9WPzkVw37dUIW!kx0i(#~t_v(Kg36B*IOufGhM(6>4TCI0XcvLJ_XyJsUvV
z5K|z}XiFJ|GEZS|ZgB}#8;^0OSF4yIQ}U#EHQrN2#|~F$ctD}lD^i}eHGC(<Nb3b@
zX+t8uL0$zkJV-`*>6yOCG;GFXV-FtEu}_Gkn{oT5@P}R`j5-Bh4Xb^yryH$W7(m5g
z?$<P16McC!qhs1{Zwfur{Z_P4c4#}D$z?>a9@23bj}vPo-n2>PL>udP_X^uF?Y-`B
z=_BYG76+Sds`H=YspiDyRFaUiZYBwGtfgwoM$fc8$McomHRl3)qFq$xoM(0X2tQWn
z9=2Wphfh=(_Q?j9v*B2%Wtz$*Vt1QJN*8%v$8&grOCxV(?(z0S;KjoZ7G7LzHD}IU
zBRomi){tO(MP@Ey8`ch|oCSb2DacIsnvT!NB6(29<H_=N)+ud4cvJ8Ab;?%n;2qbW
zJU#bp2JNi2+gmD$_rI1k*p&*KKP@n>@VnM*8$V_9F4NmSEz@n%AOuXqkW{=bsR(mV
z#T!s+;o3QRiNd$!{dNMUvW}UZ0i^v^Vp{@>g+J+-iL>SGFVYdVb02R>yg9-5+o)_#
z<+^ql$H?M{4R=YjJ{C5)WukD0C$rmc3zJXqU1MrR*96nslB{{XGR6&0Yum=)^6&4A
zrdKa(liO5YHT;u}s1pM0xXw$bhJW+5w-X}nv}yQ|iR+}0hW{#ryau;!i@LW+HGItO
z_zB~g`BrI-lPgAgNgSVCO>viceCNid!fNj-aguOimb%W**oLz<05rv2Y0nI_;j^Z?
zD-?O*a0Y6M8(^L>b_Qf5L~%RFGiI*A+~=?hgfIT~Nt$__vKJUhb8b9o;&cWxi+=(B
z`ee(A+xtG*kF$>4c;c}P{m}zGIjR@0hVv-@`S&7s505_d;cqv&t45)(b%#&Uk5ab8
zG|K{zvlpl27w4-M3~m+7=TNAz$Wr5>sd3y09BV1jEi*Y7iBm0=+%k03O`%DFkP|w9
zP$+-YevEn08X`D)(iYU2{KW7uRZVI~)oG5Zxm4w&lpZQOfYZHoO+|pZa@5(Du0Hm7
z2NoqU4&$kfA44#~(R!}qZ(jnOxFVFbACqj=q2PW@4z>E;hhc}BK?5@hb{2BgY;OC{
zae?mZ7*d#;PQVz;oOc4|yJY=oSuQ~wXldDlnAVEJPTpcqS+-zDHq4_0t9Pgcv#QEk
zFn1TammNgap)ygGW%0mH=L))X9ycvlB2S&~id%07Qh?4Z!nstqn3CP0jv!Ctl2XZ*
zqGK*fjbg6oQ53IaB$rf$_F>XabPv(=a$;C@oY~a~sxTv1gZ?VwGF#-B4I;m-*+Mbv
zlRY@c?Bz5|3Sp>Nn=-(^WhZjVcs^!7E*KC<T}|GP3x#yH)2ERBQ1x`WfkcU-w^~aC
zjToY07K*{PMh69TJ17Deh-$j;v%<hnYDXyAgFrY{J8;5$C{gHF_Be`n3Q-TExCJ$P
zgt5j7i%jmwCs;&D5~&$|)OuG4`lXHcLj$7JE|F*D=UV1!9di$`8pYf^=5^ZL2!!@9
z*lSu4+lBt2vVFLK#THu0$oRJkt6Pxd^Yy_U7BZf-;NlgMpDiu8Vud_*0Srk~QI{}B
zo9X7IC{kPak>fIMW?hc4>Izh-ZJ4RHW3IZ=1$<r__&fqnQHJd*I4F<bin!D4Kp(}U
zv<094e))BErE4v9c0=(w>LkWja@18E>!;k+(%aOvJZCDgW7IRqc@)>IJb*78%9^?x
zYv|J#C-@8f_wgy5*jc9-#)EXr68`1#Z;GGeCrJ=)$OzVMjF6jOlNKNm3`hibBR5nw
zs?dJ`J9i=ApE_{ov72@yf5GS$+;V7AKqA;baL5UykKJZ7F5{Mmj_v%HqF)VrEz}L{
zc{^BhH=?JyiFLOVebp{ZRySj+x&_nJZKzbYV~M&0%hjE@P~C+FbvM?kd$3;Ji;a}o
ztoC55dXOuvy|_v}#9gO-xQ@r`)qX32Q|;KK6S4!}#GO{mci=AE&1m*S47>3y@~STx
zd=IJZ=Z0Yb_u@X@6ULPyTR%diM-Wo}f`X5rAEVYR4NAjx8t#|lt+O<In@vIXPx&j8
z&JHT)JYiMkm@3vnd>0B>3VY^{YQf$Gq0tQW=smm<Z*4_GWinHTSe1tvmM2&gk25S!
zvM`<^_nzh##%C<ILbhhdEvd=<Oei;Q80Honu&AWrARcyHu-er?4Ucflckw+3;nf@`
zePgin3Jc**<O`sKcx--1CaF<^Z%<o%&lBGZ#P>4sy~MhB5e4cMc8^zy@ihyd-8}}U
z@fA7v3OHRqVc|<R(IOkwlX%KO6(c68=OJY-LWjySh}ou0?Mdl%LVAPYdXq5T;z!W8
zEhzTvHzdt~A$Xc$N%s;dvF{%@4HkviOV~wHMstsDae9YqDzxW~cQ_5c%Le`)1Mt3O
z(XQH516OzkKX6=I@3=O??Hb$G4?A|x?$saCy^k32|I*kIy7w`LsiQ6zN2FaGK^G5X
zy2zb&2SYi7D?KN`q)&c;C$6^R>+W(O;OOJKFfMh3m(c-XOkrqHMo&oR!&YWR#+QeH
zFCV>pz0uoO-~w8h23km<5-o+Fq*G8u1A?!Q)p2q^wgPW0LQ<{SZKDV|z5&Sf4Mc&j
z*ag0iV<S)A!W{6j2oqujWghzJVX$>%dOyqsGMEM##EW=|D)Qt5fS0P5Jyex;q$+nB
zcUWF^RE^-#&PNM=)&>zDIEzzD<mX)#;l7U}GSczAoAmQ5Ix@2jzv!~eYW$M=Gv*~O
zfo-a2oGe=KtBy>r#&1qe{I@43{=1VCulI`A?>lz*jV{aZ%e*7wX3U!%nK=V*cU|NU
zT@{(>N##Fw1Z*a}sNA6lw^zMF_UDewJm*d24rS(edNZpdGjlw>X<vkM_g}5f^A6s%
zj_=`p9#`@InfM$2fe-va{0slFjvwI&j`F263&-SIDI8N--E<7$(a#Adz@^6r-GVBp
da^%SOf;=w9`!iC-_<+X%uY2;jtVevv`yav6*C_x1

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskId.class b/server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskId.class
new file mode 100644
index 0000000000000000000000000000000000000000..bcf3b1182724d669cf5ecc65dabe1d436d24e047
GIT binary patch
literal 11288
zcmcIq33y!9b^h;YMo$_&$&$Pfc`z6w+tSFkY`j4v43Z_`akUua1!EF18a+v4k7mTo
z6JSVELYozm6iODHW`ow*lmuif3rq+hBx%wlZPV;a+caC#>`9xIK>vH+)y&h(ldN$P
zeV^wo_nve9v)+5p^QWJC{7C>i#cl&WfsLv3NONl3N@lERIyTyDM>EGV&Ex5mooe3C
z`^eBfd0+3`8}JLPi>1bzM^dSggyl>eoEUDt#!6c0sBI1PSeZ<8#5%auK&ilvqS*JP
z+b80QAuBCVow3sKXyTxi&csv61Cb5^u~(pScPg2&qe=T<G%;ZXsEGO#SlZjy(HZF&
z=!$f9cMS9%=xOh~jwF#1jtc=JnHsVpLjwY}-AALhM4J=Q<VbVh;881Pw+JlBqm)!M
zPDxx+EFZJRQt{iZp-3i@jN3#dAIQ9&FgrTC+75K@ABgn!?{Dkf-6_!AU6jt0Ub?UC
zx_$}w!fr3q?u({r49+X>kB=my_C(qe=viQDYmo?ck#|{ZED@)6yQp<T<3R!cZdxn|
zfz>81!78F`RpaG+b*YIJxWK?#YFm`D^;?3d$7;!=!NdztN7Hx5lUDD<*r1i(A013k
zwc74fjGm9u|9sXjw>EexTo`usI)qxJ5<7~eY7OrqVGt$QB-L&z!)5_UyqB3+f@*oU
z&BRia$-5mUmSH(<Wsk-)46?!5=-pf_Sb-IDwLU(c)x1bvQU$5NYJrNRb!$ZBON@5y
zU$ij}BquT!6F+_nGn(NS9kXmkV53*+luoG00#_{-=RDk*+#{CVVP#_J__&>74cOGs
z=*crTCsUuhZz)Fyx(sx(LM<*RO<aRL0*q^Fmy9L`SXu0NY=G1Qxso`bO5%Vji33g<
z92jz;+)xZgfmO58uCeT{xRn@ci^W(nQ?t>3<vdDzM0z2)vO%|r9`p)y%t~6kUc(-M
zT0Hez92^7t1hy~E8+wVE&EFud!+rz(0#|qy#YM?CaR96W7jt!E(VSzhxutxd!4=xO
z6VXhjrQn5kEG`O%tlf<5UbO}ZETfBai%`FvjweT24BWuwB>%O68wD=%GC=!r+j2;Q
zID!|O7{K)crk!$L9<YZmXDLrx!velR7N^yoZp?8ZM!{+B<xwMJV)on7*s-4IxGKg5
zM&=-OR#AbftcsE=d99fzlwCq4_G2az7$f#rYW#RtIyL5C-{$s-hT`o57e6X7C=ei$
z2v=yXWOC0CpX+SCrKycu({bC{pArar*G0Mh4fRdf;}bTeThTGKq69l{i&^6~_aqqu
zw{qX1JQhziNBXiOvicr3aXao%!X50LW8?O5ZYJDX>HSCJ4U*!eCSHcWWYJc@93p`$
z7Yi=p3aMGXT*zLIzcO%_z*?^uDp1kHU*i=5K?Na_w0CTyF&iR#<&r4yDig29Yv_BL
z_dxPkGIeWG<rH1LejZo5r}bMl7pA-MIs^A`58(wUZ@P&LZ0<Z#$_td@8N&ryFqCTu
zv0v>V<zB6yKPnm`a@GD@6ZfN%@ix1!lf%*jZ!+;_yoJPsMz8Dia)?(nco{e%4Sd4H
zTk&@^izZWcbEuT<IO%S@-NfJEUTzgK3QMVV^F%a}ky0Nt@lM<!?fds84&nMB4&y=j
z_-+#^j7#DN2|hJ=l)gyWqjGm#HX6;0O1-5%A29JjsZaH+K6~__Wb&|yHnayZj42cE
z$GwvKR1l|e#=tapoL*j_0%|=pF@wjnu<lfnS?_Py+o;r;;=RPc!Zt3qr!s8?x^!?S
znGZ54+b4#H)xM#q6@aDiBiwI!BfEvWZ|6u7OC=os*}SX3NAWQOPYbN{B6jxCCZ51E
z0*&)Q%~fEXMbvaCYDby6PKM<vCvdYjE6-T%yv^of#OiUKH4@L*>EqojLflvtXCSHQ
zr=%jE7TEtMknW*#jg^m7ps5Iz1g`b2T&`k$K5GB7RQq4J310+v54B!$PO>6&JRki3
zCh>nkfIAMa7<F04b9}z|@lbVZ!;$v$LHK2f@GCr!D0&aZz9a1dFXm`b2#b&KZ%82D
z6lg0}ln3V7$|M)+q-#YlGVx@+{!bI%!hdlWrwZSpxIOAx`UUoRJJu;adRJM1!YdSX
zBZZ4uATA+i3s4?)t^nl?{2ARN?eKkRhyND1qj-gjLbkANYLyo{tVDc_m2^n1LlWE%
zP5ekYY1Q1}Ja5UFKan%3#vyMt)aK%k4Vj-yQ~g39>Mdh7HoP?Tknc4u7cA>Mja$G*
z;4W`41v5SQ%~ywt%W`S|UrF2iTHqdUI7Qi}D5wjYv4*V^-AU@=*_`bd9z?mxElR=J
zvn;p00>3x$EPl()b&j)q{hW#C<?C`gm2G~GHWVkP*bRgWSD)~iqJ+mLl#f~I5xtQs
zSKSVqS_jc5J4q>T?|7VkwG#B3m9+mTU}fyUiE?RnPrsg9Hjn<L%zxrwtM2@G2<$A*
z6<O2rD9tlShcz6XNZ7e1+?HZvi1lA8!45DR0rQ-)bdm`4EjZzP`oi+8=djPFL0zF<
z*|AIK0if%X+U+vx#R^j_6;*7_EIgmezvz6u@9A)jBkLuJWu=MV2!5+*S{RGOK8J1<
z>15{4clOPf#gkN2_4?{}^7!kmmTUjlc+e1Q*hI<gW+I7%H4;s<rAH>l7}VKwk5r=G
z6l(<&b$M*miXF?biDaB^O0YjQk&dwkCOhoat}i>AB!3=;BT0V1QLQg4V~8-@B3=bD
z*KT#UUJbE<t~|$lR=ymyA)49W^`e+Rt=Y5D#l;Yp@dQvDHG^0cg337sidj0RE$B43
z#11xI7Rlbbo6YUB_kba;n5XxV7cPci@Q1uW=!u57lCihI1b4t1;;MN(q`Aq-tTaww
z@T-h-<N6?1)@x<#J*kY1EnF;0_%DDmtc1Z|E*|oO8G@*TiOTGA724%T6OPrP#`V6I
zbNLBH(eMKbuPfyTC3WRTA=0l@V<9wg)`eKbHy82Em86q@%g;g_K7)%-Va-|8^KRWK
ztbc?9J~Z;TitymuilDCr%Y3~Es}VWMFFO2nm~T)l6PzoVt_U}s!NzcH^J#1em!HPg
zu<tasOP(c)=L)I|svcl(y@GA2YP^)dFH^i%I2^E3sX$)199IzX3rS(}>bz;;okTFJ
z%wc6jAQV1>)_lRvb55m|C?%V%@Kbz{;+IhTGHjzN+Z6;yOh`lU(^9*%%~~l`Dp;m%
z_Au`qGnFc6EiM(xvMQ9}DqPL+I<R}BIn}HAfPV_R^SNA|HL@QO?9~))TE&Vf{6(#(
z?VHB6Il@{h19Wl99tP1hRIAISN`;2PjXAE@?CvLUNwX&WD7JJreH4cuKv~mMIQ%ew
zj`VDp#*2Ex8|lD}Qi|iZH7d;Z({Bgpi-Qcq!}Qzr^wA9nvH83jH!7)NhqIO%pqFl<
zkD11#ieiwGLqr+F5cyi<&Y*u5H3s`?0;7m)gs<j2`R#bM3t_E9ID?}-;SGegL1E3u
zH%xpZlysCb<4lcFI`<fjpP<yF!nfMto5dH>_?8h>QsK*@3OT6QJJhI}iAqLcfT*^9
zfH!Xc-|jMcK(nvG%}8tFqns_{r;fziTSNYLBH*74oj{;uGVEuH_$N8&&XGH*%gd?D
zU8rR@`2xH`32<_xE{lH|MJ%TXiJJcr;aQj>z(@9bDQ$u;{d~GbrRbf!mk2gVqt4*A
z6EK_n&izZIM&<WEz&A>{Y1|o}#w(kq@!DMKI=OQ<1MD7}_VuhMZ@^mIi;cL?1#Odt
zMme1G1`Umpm)7u}y<7gu8Z@QR?4juUT0_2fAP|}?Y0YA*3TbR_yh*-P=&C{r-3%VM
zsWl`4PUCGH4V}h)p`7_Pv9JJdqWRuT^F6>ac7mVC--=7|Hf+G#iT54E_%3GTgG`l&
zT-f(y&AOX&Wc_u5p+uT>#Zo@A!>sXtiuh%SMw-GWr7M|6;snZN`FqzSLsj$;;6u!%
zho<olj+>`(lFuh;X6bao=Mz<Uj~aFPe+NYa@1X+krBB~a1tuBCA7mUq%zS!;b##hK
zoMIK7V%a)H(2p|jPb)>7_>N?q5Frnle|6Z5_c4lmN+lBk!+aLY42a4l9A!gWtMv?(
zl0kBaHlJi!keA8o#@6bkq0t$9Xc~{))LOkZH0tMNduUYZIE_=zyFm8c$r(J#hgE6<
zReap>(xl5vj*^d4!L#(zhgpfAWRiXaYw#4B*_Yjcr&;(v#`^m-cH<fB!^c^AKH>7#
zA+6*R7QVAtZ*fI6xr{zRmbnCYQia@3zLEJ`IfeD%$MBSoqC~EcI(7UrN`kWvR8r<A
zNFdpLvVdK?HdU2m*Yp_vvBZnt=Us@aG(Wkt{u4e!Fp~3U3pnQi{hTMzFXsUr)Ik5W
zfL%V&&wB#>W*$(<Z!XX;7I4l3`Xx`G-^v5}RSooO1?=*He%%x3_w#^Cesh8TyNk0^
z`>x;{>3Xi9>%%knk2#JHauDoZ1@S`{)CznX-{E`dqVE<k?9k3PmGfutJr9n*WFh*6
z3#_R*%H7PY`+tCQg8d&4*1sXxUweZ6!6Lx^*n{Kq1pC}Mz&?SW78oMWvOg<i%>^ka
z{CQx1sV)1z1q|~o`+puBO;m`AJg|~u&ay(DDRoWT#H)0^e+IwHOLtN2!sXWmrCc_c
zH0^pt$+dL~Yo_sseDYdFF2jdJl;Nyx+o_a}Hc1qo7WrjHEO*JRpmpS?UC0iWW^tot
zu_{c#CsBD8eTUD8z`IeU?`D}gTL!gN7j-biN?gdR+^Rb@Y?W3@ZxCws8tg>*<w;#j
z>R}|yg{(p{ZaO23o((xIRceUUC>NI~p3d?zyQw6R2+|R<j`?so3$KqeD@B!N?b_+C
z$?;Tm*0(cfIkALp(8mc;qe``la(zDKwOL9bY6~c{&SqlfQyz5LW!Bk3Hc&KP7i|IF
zBZaipZKPeMY1i^9eIB4=mgfoPfId4Zk_(C>>7cV-ph?!zPBPj`!%fqoZUHf*33-UQ
zaAA^*iY0m8OG-hSkZV?dJTE+?EJRW!E@lK~7jtomijbVWXT+ts1D>;pXXT+ptfRSn
zV!deK^#%rPqi7Nv`9CH%acr}{Tx{WWYpKcqCRHM~@%?sQcQT1C7cUf>OUp&8*d?#j
ep+j8FeN;X9$iF^zi#GE)!1ryO*Uoo7bo@WBWKL=T

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskIdOrBuilder.class b/server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskIdOrBuilder.class
new file mode 100644
index 0000000000000000000000000000000000000000..f7c79582456b3f3365b096733baa8e559073dbaa
GIT binary patch
literal 429
zcma)2K~BRk5FEF(X+miW^aZFw?FHZ9z^zD#AZU@w2i#;aDIu<G2Z^t7-~l`ev1z4%
z5C;zSj=Vdw<N5e}dk1iaVSt9fsj*s`H5HDOO&+CJ?#aouHQva3#&LRA;n5b)?X=AD
zlx%<<fx$|>D4DB5%lUFei4V{g7$xReYGZUxTb*V3AaBVzrK#o%gqr-!q!gzD!|~+i
zTWjHMR_JqqUOh5>_2dMOc<wLts$H{M%&J72<H@x^v@oSj=rYTR4gdJjNwrX*8y5xH
zi(ENJF2KIP@&6JL=>N(@pfe-quZ;5?0~_Ge;;5S(Re%nv$U;P$x{Ger!5-fY^w8%T
P@jQFPK|93Z=6&!5QxbG#

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskIdProto.class b/server/bin/main/org/opensearch/tasks/proto/TaskIdProto.class
new file mode 100644
index 0000000000000000000000000000000000000000..f8bd0a36dbcd6d9ab5cfc57f139241fcf3b8c59c
GIT binary patch
literal 2532
zcmb7Fe^=X77=CX0BW)U5?8GtDZO%GMVa*tBxD}@q#;kNODMJxGJ!yMaGDE^i0uJ@d
z_ziTNv!OfN@oztr$M+^(Q=~`eKY8!Xz0dRhe(&G^{P`NdEWVc^F<iBswr1~g%jLS$
z+}1qZ{lV3C9ow_Dby`<i55-zWlwtUZzOQShZnd@5#uMK380HMi<Bp}9b=T89qgf}q
zdPrCI>FPdRJ)o<%xZ8A$UC(wHrm9VQM{C=5+vI`L#@=IXv3tYKh3gW-;^5jI8{BNo
zH=EpbZD(C?n4F>1SL=OlaYy%f>jB->+k9gtw{!wbMku`wT<=R28toE?$-_P26LU?|
zung}mLnJ@3!4O@rTU<uwSb%GuV_5A3-ePc+^Fda6@=^3dnjNEX7sGHD{d>XLm7Ed}
z0NJz>w@5{$HOeltd@`#jlF=HKXdNjJl~X;mjkwP{BjX%H@wD6=cTGVSBP!m(d4`K`
z5>?(a%vLwD0<h%RI}H2zt!h|JfwQHpL4!FlC?E-j3o4RO6k5Hj;yt|2Fx2K=m?DN7
z`GJXr^Osay#s>@;qU+Sq`oS)D8L~v^d%NcurdBmvuav@v_((>MA$|Nr#Z`<`X%Gp+
zNWRiR_H<oI#sov*wCsc)39lzr#1NNpjp24bWH(3uSN#cS4Dl7emJ*m|kSZ+&Q<zcl
zF>cZkjRU{1%lT6?6PibPKT!%38^Y*W6*3YO(W+tbmA#z?f78O*s@>Gh4c#$BOLzJ@
z-RcgGMcvaG&h=qd5W%OyUX?n}+cqdY`Rdt*AT{rZ!`qZT?#!F!y{8_HO~bZ`qS)Wz
z?v*tk<{VTFkC#N#CjuhpfKt;pR{f!r_cLlDEuzMkRD6zkhVip05%aBP?>S8_dX*+p
z&u}P;EHS7Riw5O_sk<(BWmFk1^(&|_zZ4!N+)=?FpBpkB(lgYL;$%%yE1jIlGHMLh
z&X&Sl;188*u#iEyxHS-V)$xZKr{^mZko5dXt#Fr`UsNi^=354BAnx3>jPDq34hHJj
zgK5flgx>ZD#zeEzYE1MGNkxo2k}=w)pwhh|+WktWjO0S}71EoL>~L+l5P5~{5#Bz;
z=n=-A<6`6wT#@h>@`otA#MI_96k@^cVr?^;y<U5P8;7{{JJCq^guZu>rsWRel7%Em
zMRJjnJY+~_B?lwYkH|^;7?%z(DgA_^^fTt9rzlIm;5OlfaSAcrLCNQ&M(voZkrd{}
z3NJ7hDvbL-<t|uwc^9A2#iS_x4tSFG0?hskRC<66Wh``niyh!B$w2E7?uFpAAL$Go
zr4hw&4@rzj?)xP4xO7NzJ_QhchSA^XEC`ivxwP$LCHfn|7yelVUy>}4A9*a}0WQ$v
jvWyjyQ&`1UB-e;<o#Z2uU&oX9hVCn5#~L=Vg-8DaHG;#z

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$1.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$1.class
new file mode 100644
index 0000000000000000000000000000000000000000..55ce49580f29e228ece1780fff9a6584ce16118c
GIT binary patch
literal 2758
zcmd5;-*XdH6#i~|!$JscQ-ab`wP1v#p<N0UD=BDNQz%VRhC&%1Z#K8-(#>vW?+v1V
zi8H?F_ycu(z?b6448HqEspoFfsO?Uj&g8*|-Fxo2_n!UEcg{U$fB)mxR{-9_nuP&|
zau7D{pe=nRMd)nVTBvPhx5GdO_5+gdOBHlNN3Lt3)jgxm9#CgzEpUblPSCQOLD2N%
zu7P@I(=OGO4uzxdiBQRq;n;%fyZRQxU@pJGz?XuCOkxlxQb^z!!*Ip*Wv$by%kY7y
zdy-+a5;(%!5TR@4T_x9Bu41@d=?nZK!${izB$V0}-f|eU7(UNc;yf~l8!LXhqt|sP
zMXMOQtNc_Gr*7cimra)___X3`S<LqXFQHAApE|Ow$-J^K%5XIf=!*YDcy1#KniF`7
zoy|=d_6{bI!D|-IFf8?f!xUb}S;FPZPZm3_*D#@8%k{<GY}a5hiE&I=ILENs2gG}3
zQ+NY!GMs41uqk%~|K<NQ@OzLWCMHujj|&W`y5YN<xO5}>LppsTjcf|<;37jtN&V2@
zq>HPzWTPsT5>2|8kK$?Su6OhO=!r?6&SA<zo?$lb^h4iN5W1!AXFV{ztWKeT%M6o3
z9iIIR*NLb&^M{{{c$qP^%4Rs5t2`D@gzX0Q%32RXF~4D9mf>{F8biW0m4o48?8gt(
z7KXIkUr87Wv4`VJ4uchCh`Eu~ew3eH7BVo(g1J~M|G^@|wb)~a#+K^dnOMRZPEmVu
zwyUBYwFe8-U$Sw*-OsOu4;k`tJ7dXYknuUc-|o?RLX;?;@SFBp{jqd3B^g!a6oxQN
zC3QXOzss)ah35|R-l)3I7z<Rx*4?HrbSI>p+p+xqyBja`BOQvjC@#Zg-|+(F`pv4;
zTS0@$(u(iPaLE%&N$OFnbeWG_v?=)y_)F>BYcR)aQt3N^(wHQ|2I;Q`(VKoGXl~KW
zrjgN@n0kTZKa((kB)!ct_!l@ya%y)2ji+eF4C%CMgk(;$v@yem$ZUc%rC)HmHeI;9
zgRw`?FnfcK@#!7BwS%{RGx82D{XKn&^v7fT1*Z2@W_(VDIDK}A44ZMBN}U<=xI!xi
z+Kd6kzXIo9<0StEBm7&8^Y1XhpCQk`M}hx<IsPMxG%oO;%x>I?d@XfdAegv{Ymr+e
z%;8;fhvO!$(?8!JIhMpc-Y3ljIXsUWBozqFJc=YOkhSyRe-c1$fmyg|;RB0cl9*n#
zkgHj^GCESC_0oQpaEZ*DAXrm|p~dGU{)2A9W3Ud;lfXxjRK{{N-X;$W-5GkX&@)bE
XGPsKh#v(6BMY;^CG_R37fV+PIi*iJY

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$Builder.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$Builder.class
new file mode 100644
index 0000000000000000000000000000000000000000..a48f77690417aecfe3c163ed5637b55f5a34a616
GIT binary patch
literal 14366
zcmcgy349dSdH+AnNF#}n5E2N4IAm@lfiMsZ$Q<I9In5btW3j9Tv9Q{ecSjsPh?`*7
zPU6OO96Mk)PV2__YKsY$z%&6|r*7=nNsshS+9Yn$=4_K*afqG&H#56CyBaAXUL*aa
z*?sfgcmBWceeauj?VXpt2;e$p8z@j%8&7mJ#k;In(h4QQ`<m=f@<6hwD-pNjO<VbS
zvz3f@C&JbiJ7gy}$?&8;!;_YEN22Xk!ho(YGaT=1>WIfXqLxc$Pxs!Y)mF?(glwyQ
zy_HOcI;`z;GHZ$y*5yHnjR{W*h0;9{dsW1Ww$Ex)P^}8(2~Ue{!kmNS)&)tqKGfwb
zYgQ=P66uJA?Cyl6aQ}dluV1%6bTHHu4aGW|w%CbCtfM&}>SS5j5xaRY<tpp2>=jlr
zoQQPU@dT|sZF-<|nK{Wxna?DkFORodB^ZV(1C<KbUa{p(495tC)sdKOC1RmyTaw6#
zgxg4{ErX*r2S;rVj@tSFrmfwlLgSSwFmzocW^L&1++!uShW141pUQRda45Pxl!(Z8
zZ?GyQ-)hTF`BmYXX|2KbN=<1lg+i@~F&L{b%10v=2aYQg>iV&JnvQ|-3Zpa7*xVhn
zBc0aD!(pq-j>KaIu2C47x$i>9gK#k>a&c?yU?>`Cuj>qT)$J8H*To#Q7uJ=c4wFqx
z!BmB!>m#v<y;xzyw7y83zFnqHH&KrUP7QT2(AyQph#C6fO$*dvhKZSIQYg0Lu3!qo
zsd4TS&K-xz1eLunl2llq7vOs~AXbZ9eTjNzpYQ?N)^qM?pJUc{+v4_=;l+Q~nV2vB
z8{c<YjvL4NW;mhW5)Ly%#Z%B))Q_73@>$>I%@StUn^**TXJd-fZxk<%`*UP#4vd?@
zNoHWF!tyJQ{j8)!pV-M#EW-)|%M}&`Wz<1QV`3#%(OcYum~XS}m~17sBaDLEEyA|V
zkMQNuP%_!<gQPnU9NvSHgNW0nNyKPqmEc-UrKSzm$R27pg%VcGZg#1x6Dl_l$6d~-
z!o1&%nnGbX%I%pbA|CVLwbbUz_|>r4#71mUm_2x`r$V%Z!M4qWf#Oo^z)k}nWNrz<
zK`J_h70o(4YZqI^a68h)L|)?z?+tZF?bcY*4#mP&`rhjNXikln;8qiDxP==>Uw$<8
z9w}xdjqEWImT9IlLeB~kWxZu$FFKf(BH8#PdTx@15fl4yfSW|jI<ze&>Dhy@SN)_n
z0fo)M0P`j`2cvmFnvyqJ?$Cw`EAs&s$7FGVa+kuKV0i=LD}@mW1%-r(Bq&jt-<Go!
z)=bNbh%S?ZCJqU_jCf4A+a>hX5fddS6?ooZ;!e3+))_irwRU#8`-Z~My@_~do4;f%
z>9i6Z)+!DwM1vL1I4Hm2sPJ1Rj^e`#59i4;`LJ(RzBncV-ov8(*I6bg5wz?{+KEuu
z_UxA?%(#o&`z)rov4J@<Wp4?;TJh#bMT(C}MHf6jRmux8mf!&szk^RGR50SV#SX;c
zhhok?!=hzsKWWcDZHr|y3KV|V#6$Qb6Ndv3{|pkcgC+6L5<2-#;0m8I@rVGsBpzG7
zkH-+%DnA=6j1>Rvt+B3dn`NC9>I|+SRvxyw7qdv+Y;{EFuOsUswv}hWc}h#C!K8r`
z3RO;Z8HqQwZcN`X@Hh`^nX+?3cQm>w?vzsLIi+|Et)+MZzi;5P3X_6hm#eplKfser
z6tqG6)(}%UQ+I0#K8KSAo>B<sBdD`V%@vljt*wmFnrq^6ST^xAp5f-w?z=O<!PHqv
z5I%=LGVpx=+pIIs#2@2NT(ooBN?M8ZHae~!w7b(t{|UTc;xs<5Fhq>w#ht?bU_g26
z0%Nd07zH`V<KqBL!uv%NJ?Le!X251De1&0@-+@E79f>xvtZ+<n&csVN&yA0>*IGw%
z4=Wq@?6<;pvw<(rCK)ifCmS*81rrx#eKFT>4@J8z1240($p;GjXJ6;+I0UcY&kcNu
zx@9S1;#K?wfymfYnD4K2J@I{|t~cU8ka<H=(7k5jb$o@k>Js1k^AB|jc4KaQTuEMN
zm7?cOe9gdDSwsdo*E`5M-J@_kx~zNeUMrD~UlV_czoN9=u|tVamoNBvK2CW%J1eln
zDU3)GQ<xHnygurXyp@~O6dD2-2g8<!-1c~kMXI`qPO>Fu3}u<+^v2w-lJuH*e{LYr
zflWY#s<WFItcSg`?)`!Eh<qo~uV(kjz`rU?4{~sz$qalumDHW)*w%fC_#wAr^Ra%i
zQ0ka)HMNp6%n?aB-!<_){5!+a>g=+Qq(o6z92_z!5A;)`r`9t+?ZEd<{6I(#;ejA^
zL&kq(;>U83D2XJ!BqyW)Y2v@6eW8crUCd=8n3S^ilI3ysl4Rn4oA@6|l9KjFRx-=~
znfQO%+4Llj%v>9e$Lvrfmdqm1Pp{~vVqE5)*vWR&0gEPi43mZAyC#9HD13^RlVP*E
zO{sh&p~0onlFLoAgt!!6IdYV)u(}dfSUSTBcc!8}mD{f-40!tVT6EhZ$p{-tEwNZ!
zI-BtrYrATnJ{gheTct`(HAI|Hm8%^+;vQ+Ubl#ZoN&$tJ{Yl>4jNY%-aej)<K6_a+
z@u7yAszME;=V<^YWWQ1=T==Z#4P^=+XTMe0k(YByUkND}0nKFX%8-H<;dp!Y$kheg
z$Xv8+OgQ;b;eg+O9xC21_Ze!m!h}qywnn2?M=08o=;-dWVs?6qE>$()W0Xp#3zY?D
zNf0{;{)E*TKWJs$QV6|os-&6=g1>7_H9_#lu7}9Ls)4rk(rJ!B6|5O@hRz1a_&z}~
zKVD3!UaY2a<B(*{rv%+pyU@E<QOTBQG)K={Jw4L_kY8yOzMRA0YQ|H3brDd_Fx5=O
z2OveRF^T;g_1NO&UB~3yA1abLeFfIxYL2O{Rdbozf(r<LVeU2tf=a6aI%_Ody0d#3
zlLKqTTt*_>e0DNKwu${!V(xQV?>wedvx%Ff7dn36`An<*w1sko2<~k5Z42EUY`i`d
zexT-ob!k5ZTYsG?+2fZ=v*}T(Py*THUl`wU*w-REe3jYzSRcDutaIET08EP^u2?Cq
z_>jViV1Yct_2c7QcnQHZ@=RhA4}$|EJ4=xMyM{p=_!ww6ZV_G^m=UCZSh~eIH?E4v
z<Lg>~(c(N*a}LTgWm{HwBM@=@XNBwYvU#O8nZ<c2NYk%oFg=*9F}@1oJgc*khT2NQ
z2c^9n7^EOzC}!P>gIK_GjHiR4Sf4ZvVu|0whPs(P9^@iJ?NX=@nw)v_!v7YAq1Y-I
z|7+$GB$?HQ+QZ5^XhmNj7>Y-!xr3XVGAp}yEcdvdcs5IYugrQF>og<`wXYu!<Urq0
z`-$x!IlPI6iuPk;Z$h?1V*S|6H<?|YKC#4AS(Q-VMr_V1?*)(1eJG_-%s$};D`~HZ
zCv9BI?t#X?LKN_q4?_8BRe?Nl;@A-9vx(WLK^e+9GL$2ec$FXhG%8N<T7YW)FOpGh
zA4WPOyo*s><*xXULmjxb_F3Kq@4%rUbgJrmF#6PajN5r0bvr93^kPzN52p2?u@|#0
zaDwKLuO<m-F$~wbP@^R<R!d?AufndHB9J(LXY(qb=1>h{h@W*74A=Sp1A`W3-e83}
zLSgQpFn3XyqZH<@K?}103q8xUIJO6doJMoyl1kNsmW)X&DL1rZ(6oDDX!oF$pG9BO
zG2ReQ-vW8i?~$9ss~EMgz87m=;0M<?rD7oMqtLaF`v?^J2;ATiSj?GX%%b{+UaZZf
z@E{7chkRNVrA=Oh_1NGr=T_v=Y9%Gt!@an1N4@qUw$j)0da%7dSI1A0@FUdkQ4G^Q
z?Gv%eW1w(T8h$e!Ho@@wjBl-;Udy`A6Dhs+EOupNaH0ET;9Bl`-r5kaVj2N#Xk9}O
z+E1Xk;VkxDXb@5^OkI~fO?94usXa?|p7+@+rA{H0iK3GP1)_xNWehX;kdM!8((EFn
zDC}y_W64gsGq$e&47MIeaXnezMj5*Muzdj~+G&i?K2K1d@v*J-EK!2WT(%>GZGk-5
z_O$HgH%-_Iw?$+0qsLL%AR+o94mX^^;U3&BsPG5nS!#O@L$sGrrJcuU?F$a;I+siu
zA+;XsLWb*I)VaXXou<DG9^sYLM4kvC-V@D7HC)1y<1p(RE@DX!?mi`${KyUmJbr6m
zVsN~S3hfnCYhUuIJu1z66z;`ule$=&xvs)t_hFCSy&MvDGw91*Pcd{(2})_?`+9JH
z{Z5)ezgwWok&pM_!5zH&uup~w)CJmWH2v!+)4oEFzs|hy2F7V`VygC4G-zM*$uuJ^
z(+tX#LI7owH?8<eh9^@auM#>1`t$PNmteo{5OXs?fk#Y?_b6w5nsaroJ1%LOsYGWw
z2Oe*H6+_PBv7Np6y$jmnlSojL&&<<D=+E&k7+J!>{i)@plz(+P=iSh78h_Y>XB&HP
z>LQ+7SSWVs!I_%E9-O_1Kb7kjFXGZU{F#Ow8B3i+MSVl#2)!3yK7m4g@z~?<K6nz9
z8)o$2jSCBl#C|nJ7d$f-Fq<8tbKd0j0se{xvYqV5XqxpKOj+M#Abktv+P7)i?_i|%
z7UpW-#XRkMSfG6$3$-7hh1XW?huEb32)lXRtNj>V+E0+weu|^o&u}-_9@Bn~`?R<5
zfc6V~Lc5GlYQMxIyq?hBaV)yVwN=_ZkK?cLH;xY;$Jg<<v`{$?;_vYHM9WA-@DFsm
zj#j>w_>Xvod((aV`zQP}?|y^Qi+|jE-{iQ!ZW>C=%Y3`|GA1Z}!P_w3<&LQtPzIhb
z@Go+GbEScANnr5RP5yT`-|skE?q<?+Q|TGJ^(so~n6vn|Q;gBKa&nJe1Vb-IscxWL
zFZF>Xm3zDxC?^NLVwl6{0SOOEyFe(vin4l#(SN*%w`8CPKRki*diUc`WH1vQ5)@g|
zOkoWHy`0hvMX_FiA-oRLD^aUgVTwKiv-E1r)kpdyT;LgBB;>X|Y&b>vDW2qisXDIX
zRYWTza7OpwXXo(03OUiCkM@x(OGn4g@wP`~mlx|}8mOGaMCC7f@k_y?kZd@IcM2Su
zZhCRHO??6lInkl())`~c7#X7ql-Mh6Ql)hC(#b4U_~STG716U!b)=-S5>1*sO&CwA
zBxe`W8+;n1HfSaN`IM(rkwav*N2J)3J(tdGAD!ZqC6uYkJWD)HOR%~?Q=la_%y4aS
z92NYe$_w~(`O-<~jl#waP-myp7tuINFhXC9YJI80vfd?|Hd2#kB(hSKs)}k<qecx^
zBYdIaj#P6*Oj!o4{4&NFcx9=9OFVRrRHHnppW+nRo#q5ey}r?v`ULZxs@d7AYA<la
zlRhK)Xht6NHI)1YO5RGz*D~R)!!&(^qk+3~%}Hx8$J3yikF-SYf^>+xBLWMNy95Q4
zyM}U8<}v9qXd@*S;MO?NQt{5wbRBf&oZ>^W++s+-k+HHFmHHNp)VKQFSd(_+I5plg
zNC$~a@*da6Ad;!6d|d%kv*_;IG4-3N`z_Rc7slwfIviYRk4x)3t}nDF4g%UsJzXoa
zGJ}Yc!KWKldzqp-e9Bd(m7Am{d&)gbYU1tr*~)Q0E0@@<Qd7L(b#!ga-G_W?yDpDY
z?JkVfZ^I-#fkr)vdAjX$`TVr{^V6W6uckSm^^#IK4?$|Ws;AN2@NRIT@c`u%H`Fj1
zJ;OH^z-NS958T1Lcqhtqo*DF`J`bdPOj2qVv8K{kb4RK<GE7=9o{1KbtuQWOZKP&j
zgv!|2scQ9)_=uOJ^(#>yQ1gV8ybTsa>bd|@_YXv>q6Igr1s*AJpg>+S+`=4*c*8p)
zI!ms<(j{#AdP}Bwy7R2Ux@;ge52;00yymEqvrtw^g{dAO4c0e3YRNz>kE)jUwtU%p
zTfY1~Eyq0p_EIYbR(RDFui;zU-Woq*Ru9BxqiVhKC8^Wxpt<Z0g!0;f1lz5GpghnL
zdA1T{vh@S7;hG>QtAW-a9Hb3G1F+$e0Br_X!lGv*1HM3Q^77)1YBRs@N1589wy7O@
ziTWVlJCf@y>Q=Rz-55=UobO>?ts)c4c-_mi*P$Y6M^TA7pgQHs^XV`Z=X`}FY6q{M
Y<F$*Y10D|5ZTw!y`w7lZ3V#gy70>7)Z~y=R

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$ResourceUsageDefaultEntryHolder.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$ResourceUsageDefaultEntryHolder.class
new file mode 100644
index 0000000000000000000000000000000000000000..6d490a17634ffd44a6b360127ec6b104bfcc285d
GIT binary patch
literal 1971
zcmcIlTT|0O6#g~^(w1-)l$)SfwICAlt_20T&lFS&IQr5F=~4nAshh11Kf#|PKFIjs
zlTZFA$CKsKA{iM*>`c0soOAZu^PTVH=dW+y0X)K_4voR~MbY$2+zYrR><v>|!B$|F
zgfD$_ndVD8@XNyHIcdq@Rk)oxv7I_JS_!NopW^FQ*_G3t6gzXiTi`-R4MX#$^}#Y-
z%PX2M*EYE=8H_@eDMN48_P5QV?-yOZk6^95ZZ23Q6)MA!$T>yNl4ZdeKK<2rG+Q|>
zCxzn`GuiXFX!X_AWi!tRSA5iV9nX=^7-H#xRfd{LzrYh{K$DI}hLJNLZJ-$~4DTFI
za^YESKA`kFcAf&|D`e#rS$RcPz8ab$D}Rg?mBW022exoZ(iaRvkr|vivItU@c_x7i
zXxGukkd7khjU)JsFSae2nsK;WSl%gd0~c|Lp)R+)G`~2@Fc^7WlxHT6P6mW$b{psk
zqv#9Mx!lC;bP~O|qN9&t<;+QqDBS9#DLxHcML$Dpk;{WRp7$vCo=qk9Ha+m4iYSQ`
zZs@qq&=Zy2LkSqTi8O)p_{S6AexxJQTcPk6osqVYR8$FRU$&Wl@g0bCKD-}Q8I_5F
zTGTN#WgU+%mbcfqShm(&%71Itw=H+o5>B{2*sL2>%1a^!)4**cNqus|2^jdfkabK%
zCtDk-Kbcbva>fZUc2`%FlA-FE!(lt3hBxndTui!F5b!|9L%MAg-_fM$c+Ajuiao)p
zc<Uf|y-^+&s;R3UDOLw{u*q}K6+_F3JP`I%a`}gs(jzt3MIOjGKajXX)e)ml7ehx_
zA~fo>(hyfq0!iAbr=8dIHvF~k!q`P?YsW6S_HcO**S=ujGriDoi~jq`5n2f`?LF!=
zfw&f+UXy6le6(oWXruX%vJO3{vJS$VG*Wj$?ci4oSHgvOplvA^W8Z)fkC0&ucU72s
rxKHCCp?g4|-zVs#{`M53;|Yw>r{X!S8O_GgMLli|6SRJz{2G1(AqQmi

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsage$1.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsage$1.class
new file mode 100644
index 0000000000000000000000000000000000000000..d24815257884bb9879fbd4e7482064beac268f54
GIT binary patch
literal 3039
zcmdT`|5F=96#wjT>9y$<2&GymT8gnvNa0G06&qR&7;H)sC;>YC!ErX1C0u*C%iL{h
zb;iHP8Gow&KpmaY-~FSkZ;uddxWQq@{9tBs@9o>&x9@%4m)$@9{N*<QA7jga#_+@s
znwH-dUMP5A?^}|G&qJ#n_|mtwiQf{T-wA9{lU#<IN}N6>eoL|w@}@{H7|<DJY`<kS
zeZT37LzVT;o>i!aGT^q{<UuF`hBM2K=g0>PLz(O@gTCrFL=r<dXCi?!3?pU76V*<u
zE`n`dcLl>(*|)j7%L7M^yFy*=J0Zi<@_-!5GmN&C$z->5xVskkEruU5<v1Ue4~>%7
z?#P-91aIYIR~27M!rk$`EzxuclyAz86#496JRtj%#h12dOFA$#Fvf5@&h(P^g1b&5
z3bpOKE1kVP5%e}DF^+c(Tw>T62+k(n#bvV86JM`%9Jiqogl7f>NxFMPK8Z<88Mwmm
z<v_eTI>^L(c%R{1O9V}Em_R@MZxZOpi3qJ}6W1`qVAfTXx+Ou?H>gn2p(&(Ie2D7|
z<Drl{-X67$a9=bkB2+DhT3I}l-T7{9oj&F1=nQ5JWEmFXcJFwqe^EzpzU>*)s}~bF
z++>*M;mLKyaF?KqQ-AWl2$y-)DJ_P}nesFKf?JMnl{R`N<g>d578owZ%rPV!)ukA&
z#~yyHk1?b~f7fEj#cqyoZwyA1Gpe$`8ceI}Whw)syjYC2?q6_axD&hW#As8Gy%ZY)
zh6{9o+RrPz9bH!j=)OzGg}Wbd1D`Qu<5tGP%OK*bpkMFlZlox6T<$fkjrucTOG-P2
zRTIM)p=Mo+UI=TBx|^>YdmThK$-L4)ov-FJJuW)|t^6()-?v`}%Y#Xf`~!;ANYS%h
zKXkliMaX@>LCvh>c_LVKc^C@1A=k;p|KK_>P@&FoYDH9O$Dr(!MNciNr`}C@wkksT
z&<`c1DLzB=%tQ30cNC2c8d*dc(ZuX)oc)m)4N3Z{X=p{9C*C|<K=cBQn2Is28YNz*
zQA(*{!=yGrlETlpSe?t=Jix@0@3C-CpU~$HaP<Hm{I2)|-1vL=D^gD<^w*d>5-IwM
z6zO#AFez4al6tM8S=^!-W!k(lN?V7nRd8ObVpQ9}q_&AE?J=_27IIn*i`q8wM3=Q)
zwHgm2UkhCq$V}YEoye^M7V#0eqvJmA(j$0?97|#epO9pV9A3gb;&Noo67s|?leTNn
z-;ja20cPO7flm!Gli1X{flSrFt+CMp%@_Jn!VOZdf?&)lgjQY=`wzIu9%ZXW{{%jd
sxFXgf`UQEQ;2x)MiT*RhKSCK*OpxpmHi)Vys^26@Hfj8rcn#&h0QeZG#sB~S

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsage$Builder.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsage$Builder.class
new file mode 100644
index 0000000000000000000000000000000000000000..ea84d3a032ee757f74e921aaca52911c59ab86a7
GIT binary patch
literal 9805
zcmcgxd3+Sr9sj<~ZiY=p$Uy=K5vqV;0|Z4;NJtwlT^f)QAcYp=WHU)tHZ$q&EQeaf
z)~m&%wV>irt!<@V6;T4!D%w`9Xtijow%W_H_WZPewy6ES+1btPX0j&LHTmqm**EWZ
z|9;>1n>UBwf9O#Fr{SLpd;%NIcz3<oryB`fi${9uEiJJrQQsFgEwg?NuUG2{GZ~NQ
zt(ImbR>|q9gQl}))+V%Wed?lQG}fud75D{aN6g;(Zqw|J=_$q?$*%e{bVHA8mfpES
zPe_V&a|dXO1<o#rT4%)_y#z`+qSmsg9_yUbE+E1JV<LUYHPK!@Y^>A_Ga+Y}3ykj7
zd(HT^u(4>HrOU}<x^-)bo`}SweU=%gakVpAyzCoTlbAYi-5}s!Y<B8Fl%YaFxxh&y
zHdI9=#tN*D8kQb6v{-wBp@~M?$*6rGknMIL+wDNM4~kgUj2*G|PM1+LM`qHPmZ+hx
zO!ju@@ikgUOc$tVF(X=RofePE-_B%BTH`bHl<S)#5eDB(6D=IVl^&^LM=p!JLAvx<
z6%#Q@Kub&dn0(VE6D3QWK!c}`hNr87;{?`@IPzI_W*21Ej2*`kOu_LAJ|!^UD=mkm
zpNbPORbVnfAsN@Re4PjzQ7fv&qUY(I0`0Xe=W3g^`j}>P*DsD~iA2Mo3Geb4mL9TN
zte$9sf?5jVtTg0MP;q0FmNf|!)y`N~f+B=eoQPVwv39tDcCclY7S|1{A;o2u<WfiW
zefF%ty#J4zKp+w$LNm8nC53f{w0^FNIXFe&<l)z(V?GO!R;o}iN?x6=B8U=swLnEF
zN(9DcA?Pxe|F%9t#squ1OH0PAut7*OB6{ZD`a;><P=XqKTE%Cukf1eK1G>FK?qns@
zf3b=sa+zw+Fv_wHB>gfKXW&e34bklCU?y#lgv(WY7A*o(41LR5L#CNiK+e{;bZbQK
zv!bRUu-ZG>oP`bEwUn2qOzpUypjQRj3X?b#aSYKYvT23ZXG6Vo%I9R_uNIi=ZIMU)
zr}IY^j=&lfYq5@;-QJ!fu%Wg<Mx?}kUd4J@^@?doeXJl&IbD7&V298ZH+$RNeM7KU
zk9X_KI4y9Yx1j@}D|FEcoTFkRG=YN!^HE`ZpMhbCJP~OG_m-9q^QYJL*4&Y>;#$OV
zyq;mqIyS8yo$y)XiNEP6$;|Ch5yiOz<%EO9Sv{e>IV_ji8B@^<)@ylU@S2X=<%LJ+
z8uY37l2o&dYOZiMsZzg$3QOu&M*VVb)?l-WE!di(Tx)DH%q@n!$8(=OaR|6~FKg8;
z!luA^D$d6RgiX5$+$+fFGVkcQS4lpFcN7a##YM8DgQl^#hmDGCT=sdZCtLH*u+f*a
zTCKRQ^?LVsOSf9=jEL8(_3kM1ZCgv!(hF`1A6YURMMA+>1uE^{D{9t<&&u3UaH+s?
z15Me=WGuGIwA<m#ni5=sPzkQU*A;wCV5(Ok<$6NJ4qQoCq*prEXx(-tge8xwRa_&}
zFevYY4Qt*hvWUN_;#z!*^})6$p}V8bzW3wzeOPX^yKudN>)5h**%LN4vuW+LA7CS9
zY*DhSOOIzfqT&YZrnX6AOI+)7xl>>qE5gIi-17oanJ5C&JrO0>fg~u`a}!6P&Xd?X
z!`KaXng&}Xv4Q@#WE2E{o#M$NzrhU(z9%rl%Tu1R72J`|H@nwg(-Swhq#pGGbZnAp
zRNDP%E?`#Jvsn<7LM3-jBxK6mqv9^y%O=G;J>2V4$l;}Yp0<LmL^2!frg=IpSCG{0
zehGEd?SvuV(b+z19FWlXpo&J>Do)P7o;fkZE|;r>cjGsBm)q{`yg|w6X}M?Qhv+$n
z+GwTqKaxB6c7Y2%DP>&lckTFFKVk7M(U*KuqI1F^6ELHO48@}|6lV)8@m46^_6#q*
zB*Vw$bKyzEt^AptrO422MQ#F12~VhK#zJ}ZltctJ7$vRt3FNY<JXxAJ=q$^|^w|=l
zxeK*MyA93asfED5Jd=EAglH^qbKBHV7y+3>O~Q#9Hh8RRpTy{F5}sqAykIgXZPF>D
z;FrX>VGytpaGur_yeLpV3=(%nDEKvVVwgk<UKR*>Egm>lbsw=R_zi*gL)J5?2B;Oh
z#$DWtVsNr3_&s;r;jK-(HFY4w{m1cH`gcXv$(sG-tl;$_B9K!m3f^Qbc<JFRRPgo?
zK6Vyl2jtH~_{_Cf!C!a?@-aNcvJ)Cq#5r^JQKrDL?sfKDCfNl>t<)3NnP$SmNd$``
zeggdV$%7}p-|)#}Cwt_f6UP~t02Rk@)oA{j%2EFL_hHOljy_cJyI9VOb5L#1@Giz-
zyhG7!O8`puVM0Ysh3LoR0m2F{h3G<&=z$`-dCJvgGf{0ZrI?24HcK8TI_&0hlqv*5
z2QcG)`=->OgqlFa_}0X5F$lOA)Hw{AxRPs89I88jnYkR|2nfsOP@P)kaF906M!hYZ
zIPUOT<=9qDWlnAj7465Vq2PX;Ccox~2F$Fchat9*_g0#?4P(T4d=qiLOVesc4v)t(
zzMgGM^Y-<{E?R$vmc5gsS%&r?ng;Yp#pyCnTJ9YVt;SJ$s4~=#MJ;vxSb8Hy)g46m
zP@QB|WQRNzxg9j=N~q#0zLB}c<+e&kr2vy=1y+*bS)?2VaTMhWj|#Z4X2eD9<O3!?
zjGFay<f@j?gE)0JMujN4l{&Ny61x*Yu?tn=I!qAPyTnd(#0F83E4E6C^~s|#$I6Q-
zwunj{FQqM<<iBt?O6z!i+J0=96iEM?zaL+aIg&E^SY`plO*Hyul!{wWDQ=|(xACRH
z?Y0(EQXCyE$lK8(K-piU`99kXe0_M7q_U*gV>s$)yeXYNzV30<?1mbudki)GXx}T-
zw4=>VCb#GBV7=@?nYa_x;x3m9#%F|&hmJ0Cm!4;lm)YWEY-Jr^&%%@98X4E7J6KJ7
z>Fn;{PFpgs`mw2vGiGMS>_@y!MkLvfZEcLomt86yFOfss$EfT@g}5IR#RGf~@*rlh
z+UJP_JOe!FQn4|kVk1>dCkHVoSYD2Dc_i#8Ig_KTb)Wwp`R#(5M{IT}l<+z1q&K&7
z)x})vC*4=1p<)NG88qyi`4mbY#wF_y;IczSO?z-IZMl4&zsi3%?*gm&k?A1+PT)sE
zVJ$yp{4Dfy{Q_zHRkFC(GhzJOS?hZ+&6%8UPX<zxWudy6RsI9`#*GO0n`(A{aKj!{
zten-4ore|#q~|6C4ml3=5n3<cDa$U7m-0WIXdQ%4h$jeVPqMn6#%OVv74{6qiD%I$
zo<oy(9?jwi!r}$AiWhm_`x3j=m(e3$!6xx4HjCGIP<5D1;Ol&#c!OsfZ{l+C7IuiY
zaW%(l#XGhKn^L~X1Y{>}#7(x(cj9K;LT`?Sfp6nh`eqz7+(y6n>E!^vgWEYLb87}l
z)T7k&C_=(NcI<zken7583WS0y6ns~XyOt{WKFePo5b|4QU_F_qfSfgVFDKmb{kJQ=
zX%H9k<j^5rOW877RiVjQ5y|9bidhPz{>yqjO3ZzaMfbid534d}S78r#5SeU0$Y6U5
z1xWp>?a-FJe_;mP)4A`G;R~SDSBx^Bg0a3)F69Ssoo9}Y@@~uL=UDEma1jq!&NE4e
zILmTZ+Id;-n}~pK62|yyQ0Y7FLoB~@D9hhVTRz`Y#xz<!otB?S%WGZAr!6m+&mxZU
z3mIgIIzb6)cRvQgMONH>vs_9BGvNv1hq#X{%H_GK7puJ<tmfupRo2XNhJ6mJX&h6T
z*pCNtG~x}Xsj*4+kCcR`9}dZM$9DD|M9_R<&PV@<X*S{j`DZ~NUn8Z8L?Isa<6u6K
z8}ZObBY*g#k^lIkk#~Ce>yi8h9~v<Y-|IRw?u>aXpO`uL$;e55I#QBm&s6?dKE;~h
zmCAWZc*yAGvM2M2xyw71^U^Hwv}RF0F-ttH8JdK9*w1a`c^Zf9@fkeJv4gwtFYr8$
z_=9)>zp}@d@Cts*N1!6SYXANn$3GOSn8NXooc|Nvz>(r0-oiWf_%1t!zjD3?@8WM9
U`Qi*mI0pFp?_Bo}TVC1!01HJU@&Et;

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsage.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsage.class
new file mode 100644
index 0000000000000000000000000000000000000000..db9b3548bd578c517a325f6acb3aaff04006ce3a
GIT binary patch
literal 11572
zcmd5?33yc175;BB$;<KxNg&uTq9_nTf&@WaN<_2b&?HcjfQTB0<dF;{GjZlcL|YYY
zt#+}tbt!gHTbI^iRg{2QtyWvtx>fDsR_oS9+qzq8ZU1}cW#-MBn?U>=zvla9-kW>x
zIrl&RIrrTA&ddED-f}yDL&P)#SpuDrXm3qq&<e+_V6?lh#tz0d#%czm5j#@T!TXg~
zEHV`Bw%YBW9a|xrXQnl$v~<RTy_Nx=Kt*?Cpr$tx>Fu}T3fB#-uUTq^t!U7;dRncR
z9Jy+tfn0&(GXi6Iw0<bm-(y7uiepwZ6zpGRMPs2zxHHfwAeISCXo!Skb}($O3ic0K
zIV48?3HTdUban(<n*wcZb#2SryP5+{Esb4movrmvD=8Yt<~SiRv3qc+BQ#(I!fnBD
zB-SM`wY8~r`N}ncw)!<4O{sEHhLjf#SObyh=0Lc9vu#O{GT9J1#p(&f0^yKNnDPf_
zsVDBnrslfNmX5AKTYE=cTSJq;>XwX<wOAl`McvAFY2V&0I^V4bM#&<_<+q1=!$Er}
zY6%RDF|;;ANS6>pUTt@Oh-@tp$gZ5TO2F3;>9GnRu&;^f*qheWs{VX7?QfzCQw+=`
zdl?~b=79y6fqms%vrX)UPcbxFLSd_IXkeWc?Fg>xCsm~_k#2@ykb%hGPUFH#ErIFl
zWTq3#i>0v#k5{U;Y6%4kkc|T*JyjBEjfsiKlXnN2D2?AOG%*R2$)?>GiU}C&Mi$Wg
z@xm0Cl4|ef!Gz7@)Fr`7==%y3hOJEjwPd@=X!{=1&>0?zSv@PFp_7<=7|6i^%VsRk
zY1t4wDOl4V4ENS7U$?>Pw&gMyQiBDK*i)RNXlH)uwd_VK)*THE+7YIqd6jdtI+J5!
zGn4m=^HGNe1Iz;ljyr5kG=kY;O(;x5!@>S8<~cjm-9<%R$%Nmf5`LFT_+4q4J*7ou
z_O2e6HFL*fi@>xIC`&E7Ib`+s)OB}r7l@3kkHbeHN3#~v#T8cp6U*=!f#AqYACuAR
zHE0)Wjo&k@23iG<8@EeSHrjT%Bd4?|2aTkO0xZX84XhA2Oqa{|2&ajaXlFv@>43RD
zh4a*%s;knqjvD%dvDo6Y27Tb~5e}}&5-y~Ml)YBveQx2!>}hrHs9bfSRCwGVj$tbq
z>)zNJ9CR|Tu_+p|t&WI5l|GHg4W(!KkUcnLx7$%GIG|E*LDR|I)}YN(M9jeP0+Un*
z2}NoG%M(2XI05Sn1O;a4$WK#jq8r@s3lyS2*gp6mft<>~GMTXj)|==>U)<8p@Wyat
zQ&{<e`FZvzOU6B{-LjcIH=y6ZMu8bRK%U_yj=@^y!HBY*vuHy-%?ig&?dqf@k1*~0
zQf>;!O(tq0h6w`Z$Z<z@OQwcQoP<rZkI=|94^t!{E~`igNc5XcL@>yWDW;U>S|<(#
z`^i9=JM^3sKIa&@TbyR%RD4bnc!r4%bjrIkO{|i48*mzdMb>SQyRv2r$cfl}^4OTy
z7mW2uL!|-dn)tFbpm@Z9qnu8u`Ku<D;D`d8hw}}5orAnuO?(N11^6Z|Fz_uNv2=c*
z<tkU3xDXdPv$sUTy)?UW*&M~g`Mj5)cnTYo=dtE!WI!P7un=Y(%422y(E9aid&@|U
zS#03D0t@sOoW$cRH(EX^bVvH*I1=lk5Z}jT1}^0>StlGnV4B#9%LV3)W|Eg!hMlh`
zXmhcZ#a-zkL13$1l{TuIPPUouxVl$by`h*L-Q2<?!E-`ph?Im}B@Mn>pyOjeso|!?
z@>(QNJr2_aHtW-)j5FrNP`Edv^lX##Tq|(U9-z>eKV5683%kG-yVb1K@ySQZ4U&rO
z0^DwO%g1GuwtqCh8rIfUuC32x%<qtv4D%5|&7%R3wU&q8v)MZ?OER}eZ;^m+6{s68
zB#mt&$y%Nn!mh(bhH{MD3vV~^bKD^?S?w9CLw29*v?8!VA5igp>>TCN(CR|asp>E#
z=Y*tbiJa__PUd7!$Nz!5C11akeEmw`)bSHDE(^xyuvB@g(drKka1-j0TfGE#pNadW
zGpD6?d%P+~J}5`hjMMdIs1w{L6@m{-N+02~nI6kXtmzoh;M5IE2498N32ABsuF-=@
z8>!VdT0YH87LxvaTyppX51V?}<Kl2!CXG#Z35zmLb*h<9^DOj8H)m-77<s_uGmXIS
zP5c4B<&#qqfoy)-#51xv-;N|Iz`H6llwUJ%XAAyl;(0tvg9fZ<uXE<lS4A6}Y!{$K
z*2XT@M}_7Q+aZPVVukHYo!(rIYQf90>i7za5g!#Ji=Mg6cf`x;r#5zXYbOs*nF)b}
zrF@!H1;6#dp?*7Ard*S$wZMH=lESLIz&@jt0-U5EuxZQznXJ{z5=|UNB0ZF+^OWeD
zF$z#8zpDo_xys)%@j6~*eQNCSB<Z-18g<%0b8sZQF0s64;z_*7C#$isNbD(c|CVyh
zRHGGgymK+twW}9$%^~?p!Jk&LRZrgY<f)UDmOz+q+f+TyiWx$%(xpq}$%3=H_-u%5
zQoEb+gp-su1mEP%(@BiJH2I3bNk)dq=R@B3q#0ByAxua~Xk3LUwMtd*GXyI)hwq_!
zeLbI#EBX#Y6pvC^^SI9trSzE&gfq|(eD^YYi~;TdGQ^ZoJmhGTgAKuVQ4Jr%k%Tqa
zv|#hJsRA@>JMM9+&GjNSug!|tM@3>b4&<`Q<|hYvm<og6+~4FYQWT&ZCMG0)7qN|R
zs@PYKVpn?!+xgx~$?&ZeuT$lFK6T|gILeo+zNwhQQGV>rmT7D`oO1H7>{f_1JF(A=
z*zZ=%;N7enQE>x1vQWwIBEmz~;V8&z!sM)@sYLe34_~11JFdK1soco1vahVFdMD;q
z<?p~e`8B^PYX=rcmDx(=6j}?M!S73G<(0JRI^y1<R8NU3z(L9as=^{1OvHy!!sIpH
zawzX4fDv2T6o<g%s+~AYGjH6K_`GMr$9eNPZxQF6gtOGVaov-hd42da7CSuEawch1
zp2O4iypQY4Rd~*I;m%9o&O<F3mfW)->S&s&#sj|XIMS=-yacg6G-IhFQRmoIxE)88
ziqe*0v?T>gX$Wuuhg`(KxsX&|;4-Dqfx?m+IvsU21THDesk#aCuJzb)xl1@FA<ROt
zMtHtgc$-GJ1gmkhBfP;Ov79q6sP+3ULym8o{}SY6Z>#b#IDFfP#vL8o867v$<2Nz3
zhxsmfr<x!h9pw(X97fG*e)xWm()>@34`7NM{$$~v^Bv1ZAAcREV)Jy~OE(@MZO^}8
zE6i%2yd6dtFZ1Iql9>6jWf)fVFha?gor+uv-^RGPorvz>I=T}xaTn&|ZWpox68=8`
z0|-0FIB{tS?^(L%w_JNW9572c--)&UtV@yO-<Dk~@kk&=eg$n8>=R_00$1c$;8dGm
z;v2@v?Dg-!iT)&c3rHDoFUh-)cMmYcA0&CdW*T@1`{NN*<55C>j7#cq9Em5;#En<3
z=s2-U6U5fz6qRBmv3bar#FkAWc)m+;On8_k$p7V7T3vOObY}IP5L{Mr<$r!#^&Jqc
z1bO;gerS+%^DwsX*OtUDi@#{ZSt<xz{$Ij;06aw#o~BQqr3uf`$Io*my+H0>#D2Wa
z;&nD&qB$?4hS!C>F2XA`=g-QV>2YWYZ!E<Z@I?YI$2^>^jFpC&$T7?hP-;L-n8;qf
znsAJJkn%EER+Ig6wjxhnwiVB*EuQ4>+l8+T<7+3>7SHnc`FL66?~|79!Z+e=If=F{
z@wRDd08PC(?yqxP{)!v>8V&tB;rx@Pzs}HlgT8tb6?lso_Dvf2HvRPuQ_{OkChwpD
z?_mZ0#fAC4%Xh0CV<+M$d^_PgZY?Hbb}KVpazT7Y#o!@qk;!1fc2rc|jPGSJszoxp
zsN}|e86ENDH~~Mv5BW=~yCO|py+c`%R9Ag7uFTfy%XJ|xa`eeP=12H3!AQ;5q-pj5
z{fQQ6p$F(s9iZ2xsq+H8UJJCu161lu1$tweW)IMtv_Q)|KzBMoccrQG0=-!a)b9Z*
z^`!#+nM-p#7aqnI>3VJ}6;-=%TZ-cg*a<Nm1!7+p)I#RFUr<E4=&m${jgIq8<@{Z^
zTcdF{3Pptrtm$Z!;Wgs^d$3!u_i9wnCD>{$*n9Q>>;oE&3ki0?ZoqD3UQI44Ewc}4
zR3ApLhkC$1>M;9QnnEwLztLzsl3<VUfR!4P%nJE@<>a<`yh`W$cHwv4<=*JR<#Q5B
zzAP>|va^*W_uB2)Zx~N`#haD5Oq^2aSx0CQjdG$*3Ncwe=M@aN<}JjZn4v)tR<9ft
z$2uyeRdM30FyU6T@Sys_)hKfAMwG^n5bDe-T49Jb{tsNMOZha%DCfXXvdm!B$S0p#
zotau0$#PpOl#02Rz0^842{yhoI*>0qmCpD!Gjh_R5VxPdP*FbNF2Y~=osYlaRY$e!
z__tqDr^>TgbuQ*!<6bawuKtHg)h@{jujJZ<q~QMHl}tFB3)3rkf{T|CXA4<OaPYch
z)9_m9vc+|jeZ!HR#jEsr4juERXJU3Z4-rb_?eU2;(pm2~A{FFGMq6$b4{Ps^HO-UU
zFXKlqH?sG~7WrVjBF|`N@h%f;P1^qqbhC^u!r=T5EzZJ+_%E;Pcrb&=5<Zmk<eM!F
zU%udZO%&vs{MV;!QOI_a*CMWiiK0Xpx%py}C{x$HP$$ZHBobmTF_qUD)F=O1*kbT^
O4%_`4zc<^mQ1?GFI9Xf(

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsageOrBuilder.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsageOrBuilder.class
new file mode 100644
index 0000000000000000000000000000000000000000..c42b6b378115dd028da49ae230242f0637de4a4a
GIT binary patch
literal 537
zcmb`EKTiTd5XIl3a)2Ozv{73MZQNMdbBPfXzzDV`%Q>Flu}gOLO!#URegHp|aSj^^
zm5Ie>Chuit-~RUV>-_`36^<g56ds*VwOf*9GCq0H!SE~VrFX&UiS+lxF82wIg9&_B
z$lWb@LwR76(#ZGnS@uLe!mdJVZr+T}j7{}uI;SK=C@XXmx6r9`X+}TyP4j0xAl{f)
zXr~n7Wj>iLsBeeHI#$>@JHM5+;tXiv{Hkwzt3YDZ#_O=xvy2o@w}P(oUleH+>V0d;
z$C+U!j&Pt5{{xB$ErrWJFOp|&g;hBDt!;8us0@k2jpHCFg@~Lz`PP!)j!;2?y;@Xp
bYK4w{)TMT$YoLiXj%A{OPPvN1wcq>(S}3Dy

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats.class
new file mode 100644
index 0000000000000000000000000000000000000000..40849a2553a5088388e941e2c482474c29f92921
GIT binary patch
literal 15186
zcmcgz3wTuJnSQ@B6HYEC+%JZJqJoA5h=`X$A{t155eS$N6j9@l9Fl>_Oq`jhcq!JF
zT5r9mtrc6_?L}P6b`>>1X}xs2YinC~w{GqBy0v?0x7}_pdug||y6<<+nVB<_lSq69
zd>%6Aod5s6|NSoi`+xs`jxW9Og=Ya=D36#h1gn#&zQ*LBok-i!R8N0nCYs)zZX8S{
zGs(s+yza2m$)Qw_-I<AI(wp`1{1J~$gav2yBnKM%lF7cf?TYUh+S$0)PS~kv#_ru{
zr_<3sd+Rb269gMdFzBY#s-alC*G>s0r|ncM8sBQC(y?TsE7B^EO9j=dlZkXDn#gR8
z#)s@O8twcinBCFVxv8sTbz4_w%i6Z?HIcRrt=;Wi8&|b;P%;u?HxW!sd8T(M@@~PY
z8-h&S7#&;_v*W!@f{M;qUm}_rO4))t$L!p^VOR9}Xk$E@=xglEq+*G_rc(H%AT$o_
zrj^7sW56Cr#%{8EBk4#YmZ7WkhNiBf?^@f|v~+FQ(j95<+|ts%x=qkl3Md?Q!seEa
zPIc*=KwoT*rWiN&>lvfDxg=QB3FXZ_@ffXNDG1dq+$spKPWIZBU|cPnhFaoncG@fW
z=yVG+Fw?}D^hODCb^g*yoPkqS^H~;V;S|B74Y7pXJ~XhyPHl<qh%;lRZb<epiK9$q
z-g^(1)df0d<h+{i&4wm5?Sk=2HP^4CU?oCWq|R8VNS9cchUxTErazVzm^-r5?VRyK
z63i^LZO>rNzH#bOpbGO;K~=)OA>vH%9(u3yxJ~X#45jVf&8gV+Bqk<dbimFq4;T8T
z<fa|F?4FFK@Q~A4aPjft97Q|XsL#%{+UcHDY%r4~X)UQ+7^pMfCp|xZ-Bf{QtTb_v
zVClFM(!#~KM6foNprMIqyqm0;iS=|-QFosDyB+H9cBsF51jl#x`miq=4|2h@?7(a7
zOqMP=$Lb=%9>{iKparcK+OS4&icd#&O>!7cFmDu3=Jc3YN7BzTZpTm}6C1GGZtSrK
zGh8uDaJ86~Z+98ln^5K0K;cN@da`Ekyn*Q8yq!w-^AgV7T`{i`5wz>1*+inP^CgkT
z>pHC>xXeNaI+;+>L9Vsr-Z^UhC_~cl2)Zn6#pUF!Ow!dPm`+2BMc8*O+Ns#Z!#v|k
z-Lspvdkiwy=QwAfYU%0WVw}v<&PAhmFMwi3iaTj}jfHMpE7+7B>22kg<JBT;O@VoK
ze8^1f5Ud~fTq#&W>B>wx%dC~?#ZD9Cn&m-tz;U6n(1(7(X)L!`B^3CxaB1%LXVU6;
zG@Wkph2DJ-JbR7{2dVAuQR1GRH7Bz~(dA~hg-MuPfdM2<Bv=)cB6I~z(Q5CE4#hKV
ziA-wGx}=tl76x&h!0Pq2j8W$~lALg944KGq4hQ8y)_)eR#|@m0_P}6fPxhf;W$-%1
z4zBj#pl0P6w;5bV3d~xaB%L`$O+=yHY~dE%N<v^iiV3D<Sz{;@i#PI7Qx*2&T_$cL
zI)_fO4Hj<49xnK4mWLduCz;4ZV~KRZXrqwal_uUx&*j;veJCE^oOBo=$Ft>lAM1z#
zQs{1bPbK!DU6I^v;U3(}^*lS?dYd2$sMK4J7hXv-DXO(nek6})S;`iBMo`&m52oxM
z-GK;hDR#ukOmRVtx9n_<rDH7cS`vw*F2mfTXnmBoClA?K06${kL5=6MV(XmX))YV8
zl=9MC@MS-TcwQ<+IbA@J?k;2D3DT?i@vw!D;p2=vO=bP;H!7PKKJR&tOngGnRSF96
zS3+LFk>v|#Un#i!1Q}10IahS6P%ul$0XG#sIk|Z}Yh=o8=}#reb-Vqs$(BDS$T=n+
z6P%HsHIaDS?u*7-Qhh@Mb|RDGoJt(f%|dmoaDC+#kYr-skcwsOElELrFfHpAv3Ju@
zW^gD&d+g|dv%RX!X-}JYf>YCh5lc2kHsxA$lXA$yQ+S$nn|nS%R&|}inX6;=9q*Wd
zRS=ap^+Rxt#8!7biD>;P7`AX2M_i8VO6*P~Z%8=O<esxfDFpo8I_(U}=nMFwiDQB@
zgVw#G?iLQ>FSrUN9p`bBKqE%_m+KYttJ68q(Nl^}{?YQ_1q)wBHP`CwS%x+!J$%K&
zU*m6BCo}4)Jp@|3;wknjd=)R5_*%h=#|8^u$2Ta;EZ{MfZp&sCED{m#ITgH&zccZ-
zTzc}8G23e4@9{0Jn+f|yj$T-$=lJL!vU!qSZRa}ys>G}KM-$%}y_#^kS@<r#N6Wb9
z_4XxeSiy52EvOqMe%Tbr)~~eT75u=$4;8Cc2V7@O{1bB`Ka1S_ti)^hXA?gW%nyom
zv0@AVf`6sTw4+k6!cPM^ias7q4#b~Y_?bd1Cq#!~70%Bs{6YsQ=ODR<zqIh5_?4i{
zIhq)ABj`?sO8f@@W#YGj1wn8|WTS=u#{V$n>`Vr*y+cgRJZh+m1g5mtX#-QLX<<b3
z=64o;kI#{9`lIP~rif0YKUjE9YppUTYgz6TGP;`^Wco>|f<s82Lf#hC^W?4ocLp2o
zQO?Q5GQqxXC>l?bZpE+!xR*7s7<94la66RTv8%9H^wN=zPiFe{?6{mk>DR!MWTeuP
zDkYi8S&~`jHIhQ5+QM?IsFX=E#gxef)5g_mNjdhAl4P1C)183F(rsG(E2Jq3X$na~
z$Kz4)pq_rNNhJpaS9$X#!4+iHo{YU}Xy;DnK&k}gOOq+Jf^&ni-8<57&h&edad*_*
z`c)-!<up^cbj}VEb`NhYIYs6P7LH~>o>+2z5BEkh(OkY4nJl;?SXE%cwcVKEKAHt|
zhus%Tll<K|SBiq8NzGrN=A9+jQUXi?o|r-^D8w&l7>A*w77&_4E|K$4vlKa`&S+3)
zEE1d-T(lI78DQ+ZK*M}eg8SZ5bD)kBodxHp;Y$TPkqMdzJ`)1lM}rsOqe$KMRiz8q
zd5ZgdEofA0z;MQPzW&LubzHbhl~2nR-U>m>cmV`hk|j{Bz!Sbwy(G!6E6YWetdxsc
z+BvL!c`VcKtMmn%gHyxhNblTk1h$}L@@faJ`(-gTB*&9Q(s`aNYB=ekRPVH^ciIFu
zkKYaB!aKIdraG}{wd1h?mR`NOv?{oDmP9mka|@e`VyHdWYfqXn5Nw819G;l;YF7tt
z5=4VX&gM~&{Q;<gy5$q=tU#BKP$T$gFqjcN1NDu@dZl0wja8?5Y>VKYV36bT*tiTB
z+qs*#6)S;>xgDF9otIm3g>>;KGr#rI$5&diT_0CulHP_;@IYNDMlVg#;Iknr*I3dm
zR}t)ho$B+d-U{bMV}@JUN<_grb6;>Q1KwwN1~basJ)Ho!y?mV~+~O^NyNLJ-eggT1
z==d%^Fu&f?D#6B51Tz-~ZiBd=_Rfa$ug%w%CS$o`slhzw;!A*0&Lg}@DX_=vP`WQZ
z^nHLkXzr{;kIRdEkZU`06j=TZz0SOpB}w77^0cx0(<N8G-TVnm84pJ;qKf5uo(l=z
zb2f~PMK?wTa(h&c>@nKeU-4L^pHAm9ur)FLRHfE`DDJ!@b#{?Uv^L`rT_nM;zMOZI
zcG{G^JY5Z<&HTp={tq2Yc^6&#7X6(UJK0YuOnDE#rU;T4eUkAo#v>6^?%<|oe9}xR
zXKGg$5D{ls!3$mI{kti53obfN^}*kcu!Ik8Fy;NDoW&M}&y)``W<emlj;7qlTo|K+
zKY>hnV3Y`X+O#t(*fu?n<&ouxT%mNqD@AWYI{n@EvPDwPYZp`Y3$7`}>gosNsP=tI
zIQzI8owWB!mbcsK%(`ScgQYyK4)I?ZCSW#9l=HfR-xM0CL=7xd=k6!+8DDzyeu~pR
zmG}JSir2IC`!na4UyJ41YtTq-vr)?@bJ%(j`|E!*jzP8^#@wec?-<VD)%>Th;7K+Z
zIGcYb5)Q)mqcZ$3riVX|I;TZj`KcHGx`Wp{D!1`ol~&a^97aRE@eCHLqEKEDT2N*j
zr7f!*MKj&*M5cHth;tkdoXcyAINc}9c%{Q-kvH>B+bZi1<GkD`KDbzoFh{9Ct22tL
zsnQ!IjPr4U=L6NGfXh7}Ji%*M&je?LOMNKIb12JkA>P6E8a>nVG|hMV(^H4gRIFuF
z&S_!Vzsi%?%NXm}OKTtJUocYqa@6}bt$rA*pE!oK+m0c!ZR+~N*jPJ^&BNGo7*{;U
zPOeL5QU&;>&vaZtFjrzOwqr4WHAb#$m*zk(#Wp8-u4G#n#`G}%ZpT#~m=-7L=<Y+f
zda6u~4x=Y;#Z-0$>#PuZn2|dey{ONxRo)PWerrXG+=PfZ3DH6IYSXm(r?KlrR31Y7
z2vSezovL@OaMT+&!!&M1rEv=;8hd@}r+MlXHz&qK>bntpJlGd{`m5Dn!?@`v-YI-{
zR1ietcAvItPn+P~c#o&#YU<TM%xQQL)yJ@J+tfP_<Id+il?_L6m*MDi(N=0-<1V7S
z+vn#wIX}<A`|$y4_Tl{?Zlwo5#3A5$=RVxeYt69-_^Y$A(X*tC!+tpLdM6Ey`+XLa
z<t*Tv{hYh+bCjIxDJl1`7wg&Y)00hSZr1P+<rKtY^n`}GG0+q3i(Owlgvolf-@x;D
z<N(5pbeOO+$K6nVmd-hV8OEcSX*}i(S?{XNIjPZelG^=A{29%d$prosK1~4Gx$i#t
z44<egs}Y*`I!-mQ_YxD25btO4sE7JdcG1tSmj$BUxX4AlA63V2fb{m~&*>8veIEI2
zMgztZM1F|KpCoefq46~8jA6%udF~K73zm5n%;cm~+=dUgKKTrvDDDav#9c$&4E^Ky
zoQHWAn>FWZI29H**M>idvhcy${U{3^tPhhm!<xjtNp5_Ry!j<q#<Q4eJdat%3l1uG
zk}I<-f0mI59_K$d`S^wY>#(GZw|tw*(LT>EVcz|v6YD6i6~T-KO%_hf@DV)8%V!#f
zaa38`<-t=q<6(RaV!T8IUq`v|4OAFkC6aGqy796P#f+S9X5dSBmIH~trs7|wmNd{B
zC95<Ie!jWZ_yo#o4~Ck(L_LbX5*)>gg7yPgzW6A<DNL?cHWJn_zP;!uzOVN`8pe-#
z{cn2x$T0qW82_;%TpO+-@?T%uOsW4B?0@qswQ9vM{_oo6`r2pke670DP0y8FFkyU)
zhP*-pzRh5N2aApGVwv$hTx@(F>y00vo%frKAL26ON7!b(iXFy}5jS4Lb;eJ8shrNa
zJi+gtbWvW6Mff9Lr`t9&=zqd>98*(SL*%x-k!yRCZJHc25z-L7$&0Ybik!ZF8C;%t
zg?nAc;Si-XyPF#7AJrsjcmc8>6<lFO4mLaw*{D8Tr2Ho#H-TtA@1Gf#uygOrr6pWp
zVf>U1_!;T;=XAg?7{y<r#`qQH8o$Qr{GHF=g~o5N-1x08^P6(fZIUukTB^YrVmjuj
zDOI$<dL7eg#w6nB%PbH7VdB?3>!^QPDjq_){v4dVuzB*d+WsSA4a-Ev$zyMs$^c^4
z<OQ|;;cJ^GpI_VWw8#wJ%yn*P)J!L?QsKnaog(#Il3@IfCjFjq{R1W$e?%>_zux#0
zmKtwhB^|gv#Ix3r;Y-*K&!kCMEwgfKBc~1R;F)~|&zNfn-J3Qt+nF{O@`<i!)rYX4
z{;14R5|kpI4V62ixMfGRoGxcjK-HZ&LftCHR=qP()ioTI`Jo_v6Md*Bdip3MXG<Ny
zsAjFi#spd)2y|Kz(8V6mB_q@o18ochT2lm6^%Vj=cZB95k1h)YI=2Yu1s+fpF0{KC
z=sN;|o>>G`^%Vkb%4_x*b2*=A=vgBzs6Qgj1%Y?Uf>0eQLudP-R>>vOLJ<wosu2oX
zz2I9;@Q=vq0F8~P3N7)0wLFcik8|N)BX0?IZGh_Y2zFT@*fqxi_R;{2O$58*Ex?{4
z8%8*y$g>**RJRc9B}HI2d!D^)gu-Iab_8f#N3d&)z^cZ)XGPCBJQ`cVUk!fvh-@vM
z?i+l#!XBwq=)tQed$uD9n1?WLShf|5w>#p>0xFcP$j{Gbn+nwr%hkn#m-)u6l55Gu
zAocQO*BkdLPsQAN4*aOrw$W{eC3*l8y{oKJmqneOUZ@LZXe;LMS9cLEht2hjQlck6
zPPx?N4j`<jN8U&qnaR3HvBZjQ<I2>t(J2bu62hGtSD_+wwWHH5rLx-w3dv6Cqav0{
zI7j;Vw?bmF%Tw*!Sj{VPK=?tQ=XOh+lFsHs1{|vPNiHasd@?5~k{BVG3pOWav7}oL
zx_-$9Tl7%R!|RhBf%lltr=INO7RnBKvJ3dDNybfpTvs$O8@#QzBa$AUNGpSt@kGv|
zpETPh)He*v&=|u|=7xY_ZX8?Wrg4feVS`2~o+i|qw|~0?jWW6j-}>B4iw(I&ZsqUo
zm@My<+vIlC$h+CLFI*w-<?s6@Sp5GqLUJdc-^Jg1m`AVSRoTakyjMOT`zBP#hva_!
z<>zpF<-`0HG|NY{7@}VNFUl#nkM{%oeUQg3+^fh(sgHXsd6@mn*#BeH^Ktey(ER^+
Ci&Dt|

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStatsOrBuilder.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStatsOrBuilder.class
new file mode 100644
index 0000000000000000000000000000000000000000..a980cc969a9ac79160a6ddc09a2d79fe434c1d05
GIT binary patch
literal 1364
zcmcIkOH&g;5dH=<OCl<7B;b=Al8alOJjAj}Ls?P<#v<Us+hl2$fn_E&GpiSW83zs=
z{ZW>kL4@pbp^6-)dZzp9=XCe)Kc{B^-l7p<LSW0-G&Td$j-*WvV=vvYiwD+t6YuhU
zhn&f6LOn0N`#NMdO6;!vn5%4`Y=nCPGe`1=j5DdzxZ6LX#7C$IG!k<Xr^ciiU0Cnu
z2k|yJCsX>bFR+-BzjV1blyyw5y})F%waL=NXfKs^BM{~{x2~M_yj41Fx4v^IMQZ}H
z&DI4r_bQ9G<)AH4+n|A^M0(m6sP<H<rOz!1{3?RqmHpgB0Y^$2(r&-!xK?&JcXdMF
zlvDkTK4@+D7nIRXVCh;USK+hLd@*Ovkxdo3UAsXCGS9fS=QmVuOj)(YWLIFhoZ#-E
zH9rN8Z%A)^anyQYTt2Cc`)9Q@Dq(_N51UnBdQ)q%olH7MF2brn=MIK3!c&1aw>HF+
zQ3^J~3xT~`n;Plnus23Hp}!06{_*Oi5U#C;sW0UGXX89?6J7{>?(-h2@WzQSh2iF@
zq88`_OtbtUOMypxCh!<DOe?H28xV7h5SKF6oX0}oFJg&tlUNQ~Pq4zY&hI+b@Qh#2
R`Sy~j;P<Oa73%@F_7^FWxqkov

literal 0
HcmV?d00001

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto.class
new file mode 100644
index 0000000000000000000000000000000000000000..0f5dc962c8604b09352299f0e795da763f2d4c82
GIT binary patch
literal 4154
zcmcInOLG)e6#j1JCOzqN5*SDf0Rb_><l#&nYJl*}1Be+CWI`|?44s*qp+l!TcK1X^
zSy<(o1uOjrZWXEkwXiIgF5T!}E#L3=#`5%?$vm7vND($UJ@=mTo%cC6AN}+0`v3-U
zML`WipY5ch_L8t%p*zWoQBQX-xzQ!Z_U!01eV-JropF*P?&+R;!ar8P8P+Z6%X-w*
zt#ov1Zb2kHhNFh%3CGgSgiE|eGC|0RB630^CnR#B0y&WqZqhN9JlkRDi6!mDXxg^Z
zrpTExmzj@_7C79F;`b24)B`D=H-wowoJ<PWwVi2w&J+woRSh^QEaB*$NF66$JuPMi
zI*wEblRdK!WKU^mPWfueLZh!Sb~W$MJdlo+f|0h5S)P+Eb6{?*!K-<omR3`5)npbc
z$fYcrqWGIK7~GdM4a@KjFa*M#GYovhP6-7Y$_hX3Ifj)EqJ^=m>JC}ncWIf3tol$p
zbws4t5fLepyW8>Mn>FhC(%j323!PRQoqPw%fVQ#ifpA0rp~&5#A{8i+%AB+hmur*Y
zp;omixs;hU7R9(Vsav*7>R31sYEc^(#iH$G$F1S4C)~Cg|F}J)hANRm4Qk+$$V$oj
z(4<<steY7jB^vq<uFmdKPo#x=Yj(5Yw&B*&i{fOOtCMjaQ1A#t<X$tRJnJf2u}MQa
zHZyEpsnOw#VWtXg?+YAp>_vv<@Yz^#0Osmo=<I6itaG&j^<a2ZLnE40`r4*pJ04?b
zObf4Ay$t=~RRjCZKdzwzPcSqSTz<e!XP1P_5F$Y7ZN@XqXv}cEp$6<ir-Cp;Q~8aC
zE_74Z5C}s{cswszvM7cWJju{?uj~{(^1Y5~s70NEK88KjBnvtEztJ4T07a{;Vpa6w
zX${X{kfCm0zU7C*_e@ODI!b#*C3MdCHt*4(AgH1TLmKw^p>3k5ObVAah>WbybU;Hr
z>Vh~#w<Be(7sN1Gd%U#me1TC7DuVvk5e*H#=rIcSgvbW*EJN*#-)#PEOoN6Xr88z&
zVluNhCsvkQC}t;hb4GUzf7#_XUQ?>DT}O3KXV_51FBJit^rN+oCZc!IpxPLSt@`~y
z^R>khX(}V(95&6d%N{*G4BH~KNcG4USWZeYCmS<7G33wXU=GO1GIUo>T6IyXzx&ig
zTKrx+tKk$#->&;pLN2Ot`E2rM2E*p+^D5$34udvs(ZgcI)LmD&3g~28wHhzh97Rek
z{-Vk$A7u(i<<4plm2E=ZUHOJlaFJnT)rsw>@RFf&r75^X)wu@XQ;r<Zf*y?R6`D&f
z8~m1|KB5kw=-LcpYoNTNPr-`}6KesLcS8Z?HMtgmWg~7>%<CD`lP|GjwwV%+f(*l{
zwNO+VcDbJwyu@(&p+Nf)r#3(LaKH;Wc!lBoLs3zvNc7P_3DCb_3cWUHtI=1xzbPc8
zWgscdcu8r(OG>kxsOs;2qP6s^8S4mVJ-~L7G^5iu_#K311EG!aiLSsMwBAPB4Q#oM
ztv9hF@D6s?-~;sBK;%92&R$0(&)pxtg{N*{H=W$X-V(n3Ille1In;ykSspr^V;;#d
z^CIY2j(IH4eAH(i&oNKDO}5qGIQ?B9Pr*My9sd;dL{<Jd8u%AzCK}?Op@n~i4*n%}
z@o&)0za<;L!yx|}`}q%u@$WIke?px9j2Zq5Qv63O@ZXT-zv2r21F!Nw@f!aN*ZA*v
zo&SwV(x*{eR9wXrPDmSQbLC=&C{aIVwOzOHT+zTfd8ibG{ZPj-O^o&a0>}$@({Epx
z{Z~*e5u`rA^LfG9yx<_woYvboQxtBJ<<Lx5P2gnWis`=g(|AFG&{HoD(jg%zj@Pl}
zExOBvR$9(Kma;W;8o)VucOD6%U4+zw3z)+udg@(3l4vhdm?xShJcH;0QM0Zdi^RW?
S{7u8c5*&C~#$~*Wg?|A-ixPAI

literal 0
HcmV?d00001

diff --git a/server/src/main/java/org/opensearch/action/ActionModule.java b/server/src/main/java/org/opensearch/action/ActionModule.java
index 0a6ba0dae57ca..e7edc75b4f235 100644
--- a/server/src/main/java/org/opensearch/action/ActionModule.java
+++ b/server/src/main/java/org/opensearch/action/ActionModule.java
@@ -51,11 +51,15 @@
 import org.opensearch.action.admin.cluster.node.hotthreads.NodesHotThreadsAction;
 import org.opensearch.action.admin.cluster.node.hotthreads.TransportNodesHotThreadsAction;
 import org.opensearch.action.admin.cluster.node.info.NodesInfoAction;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoAction;
+import org.opensearch.action.admin.cluster.node.info.ProtobufTransportNodesInfoAction;
 import org.opensearch.action.admin.cluster.node.info.TransportNodesInfoAction;
 import org.opensearch.action.admin.cluster.node.liveness.TransportLivenessAction;
 import org.opensearch.action.admin.cluster.node.reload.NodesReloadSecureSettingsAction;
 import org.opensearch.action.admin.cluster.node.reload.TransportNodesReloadSecureSettingsAction;
 import org.opensearch.action.admin.cluster.node.stats.NodesStatsAction;
+import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsAction;
+import org.opensearch.action.admin.cluster.node.stats.ProtobufTransportNodesStatsAction;
 import org.opensearch.action.admin.cluster.remotestore.stats.RemoteStoreStatsAction;
 import org.opensearch.action.admin.cluster.node.stats.TransportNodesStatsAction;
 import org.opensearch.action.admin.cluster.remotestore.stats.TransportRemoteStoreStatsAction;
@@ -106,6 +110,8 @@
 import org.opensearch.action.admin.cluster.snapshots.status.SnapshotsStatusAction;
 import org.opensearch.action.admin.cluster.snapshots.status.TransportSnapshotsStatusAction;
 import org.opensearch.action.admin.cluster.state.ClusterStateAction;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateAction;
+import org.opensearch.action.admin.cluster.state.ProtobufTransportClusterStateAction;
 import org.opensearch.action.admin.cluster.state.TransportClusterStateAction;
 import org.opensearch.action.admin.cluster.stats.ClusterStatsAction;
 import org.opensearch.action.admin.cluster.stats.TransportClusterStatsAction;
@@ -250,6 +256,8 @@
 import org.opensearch.action.ingest.SimulatePipelineAction;
 import org.opensearch.action.ingest.SimulatePipelineTransportAction;
 import org.opensearch.action.main.MainAction;
+import org.opensearch.action.main.ProtobufMainAction;
+import org.opensearch.action.main.ProtobufTransportMainAction;
 import org.opensearch.action.main.TransportMainAction;
 import org.opensearch.action.search.ClearScrollAction;
 import org.opensearch.action.search.CreatePitAction;
@@ -274,6 +282,7 @@
 import org.opensearch.action.support.ActionFilters;
 import org.opensearch.action.support.AutoCreateIndex;
 import org.opensearch.action.support.DestructiveOperations;
+import org.opensearch.action.support.ProtobufActionFilters;
 import org.opensearch.action.support.ProtobufTransportAction;
 import org.opensearch.action.support.TransportAction;
 import org.opensearch.action.termvectors.MultiTermVectorsAction;
@@ -284,8 +293,11 @@
 import org.opensearch.action.update.TransportUpdateAction;
 import org.opensearch.action.update.UpdateAction;
 import org.opensearch.client.node.NodeClient;
+import org.opensearch.client.node.ProtobufNodeClient;
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
+import org.opensearch.cluster.metadata.ProtobufIndexNameExpressionResolver;
 import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
 import org.opensearch.common.NamedRegistry;
 import org.opensearch.common.inject.AbstractModule;
 import org.opensearch.common.inject.TypeLiteral;
@@ -308,8 +320,10 @@
 import org.opensearch.persistent.StartPersistentTaskAction;
 import org.opensearch.persistent.UpdatePersistentTaskStatusAction;
 import org.opensearch.plugins.ActionPlugin;
+import org.opensearch.plugins.ProtobufActionPlugin;
 import org.opensearch.plugins.ActionPlugin.ActionHandler;
 import org.opensearch.rest.NamedRoute;
+import org.opensearch.rest.ProtobufRestHandler;
 import org.opensearch.rest.RestController;
 import org.opensearch.rest.RestHandler;
 import org.opensearch.rest.RestHeaderDefinition;
@@ -409,6 +423,9 @@
 import org.opensearch.rest.action.admin.indices.RestUpgradeStatusAction;
 import org.opensearch.rest.action.admin.indices.RestValidateQueryAction;
 import org.opensearch.rest.action.cat.AbstractCatAction;
+import org.opensearch.rest.action.cat.ProtobufAbstractCatAction;
+import org.opensearch.rest.action.cat.ProtobufRestCatAction;
+import org.opensearch.rest.action.cat.ProtobufRestNodesAction;
 import org.opensearch.rest.action.cat.RestAliasAction;
 import org.opensearch.rest.action.cat.RestAllocationAction;
 import org.opensearch.rest.action.cat.RestCatAction;
@@ -463,6 +480,7 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -489,22 +507,27 @@ public class ActionModule extends AbstractModule {
 
     private final Settings settings;
     private final IndexNameExpressionResolver indexNameExpressionResolver;
+    private final ProtobufIndexNameExpressionResolver protobufIndexNameExpressionResolver;
     private final IndexScopedSettings indexScopedSettings;
     private final ClusterSettings clusterSettings;
     private final SettingsFilter settingsFilter;
     private final List<ActionPlugin> actionPlugins;
+    private final List<ProtobufActionPlugin> protobufActionPlugins;
     // The unmodifiable map containing OpenSearch and Plugin actions
     // This is initialized at node bootstrap and contains same-JVM actions
     // It will be wrapped in the Dynamic Action Registry but otherwise
     // remains unchanged from its prior purpose, and registered actions
     // will remain accessible.
     private final Map<String, ActionHandler<?, ?>> actions;
+    private final Map<String, ProtobufActionPlugin.ActionHandler<?, ?>> protobufActions;
     // A dynamic action registry which includes the above immutable actions
     // and also registers dynamic actions which may be unregistered. Usually
     // associated with remote action execution on extensions, possibly in
     // a different JVM and possibly on a different server.
     private final DynamicActionRegistry dynamicActionRegistry;
+    private final ProtobufDynamicActionRegistry protobufDynamicActionRegistry;
     private final ActionFilters actionFilters;
+    private final ProtobufActionFilters protobufActionFilters;
     private final AutoCreateIndex autoCreateIndex;
     private final DestructiveOperations destructiveOperations;
     private final RestController restController;
@@ -534,11 +557,16 @@ public ActionModule(
         this.clusterSettings = clusterSettings;
         this.settingsFilter = settingsFilter;
         this.actionPlugins = actionPlugins;
+        this.protobufIndexNameExpressionResolver = null;
+        this.protobufActionPlugins = new ArrayList<>();;
+        this.protobufActions = new HashMap<String, ProtobufActionPlugin.ActionHandler<?, ?>>();
+        this.protobufActionFilters = setupProtobufActionFilters(this.protobufActionPlugins);;
         this.threadPool = threadPool;
         this.extensionsManager = extensionsManager;
         actions = setupActions(actionPlugins);
         actionFilters = setupActionFilters(actionPlugins);
         dynamicActionRegistry = new DynamicActionRegistry();
+        protobufDynamicActionRegistry = new ProtobufDynamicActionRegistry();
         autoCreateIndex = new AutoCreateIndex(settings, clusterSettings, indexNameExpressionResolver, systemIndices);
         destructiveOperations = new DestructiveOperations(settings, clusterSettings);
         Set<RestHeaderDefinition> headers = Stream.concat(
@@ -566,6 +594,75 @@ public ActionModule(
         restController = new RestController(headers, restWrapper, nodeClient, circuitBreakerService, usageService, identityService);
     }
 
+    public ActionModule(
+        Settings settings,
+        IndexNameExpressionResolver indexNameExpressionResolver,
+        ProtobufIndexNameExpressionResolver protobufIndexNameExpressionResolver,
+        IndexScopedSettings indexScopedSettings,
+        ClusterSettings clusterSettings,
+        SettingsFilter settingsFilter,
+        ThreadPool threadPool,
+        List<ActionPlugin> actionPlugins,
+        NodeClient nodeClient,
+        List<ProtobufActionPlugin> protobufActionPlugins,
+        ProtobufNodeClient protobufNodeClient,
+        CircuitBreakerService circuitBreakerService,
+        UsageService usageService,
+        SystemIndices systemIndices
+    ) {
+        this.settings = settings;
+        this.indexNameExpressionResolver = indexNameExpressionResolver;
+        this.protobufIndexNameExpressionResolver = protobufIndexNameExpressionResolver;
+        this.indexScopedSettings = indexScopedSettings;
+        this.clusterSettings = clusterSettings;
+        this.settingsFilter = settingsFilter;
+        this.protobufActionPlugins = protobufActionPlugins;
+        this.threadPool = threadPool;
+        this.actionPlugins = actionPlugins;
+        actions = setupActions(actionPlugins);
+        actionFilters = setupActionFilters(actionPlugins);
+        protobufActions = setupProtobufActions(protobufActionPlugins);
+        protobufActionFilters = setupProtobufActionFilters(protobufActionPlugins);
+        dynamicActionRegistry = new DynamicActionRegistry();
+        protobufDynamicActionRegistry = new ProtobufDynamicActionRegistry();
+        autoCreateIndex = new AutoCreateIndex(settings, clusterSettings, indexNameExpressionResolver, systemIndices);
+        destructiveOperations = new DestructiveOperations(settings, clusterSettings);
+        Set<RestHeaderDefinition> headers = Stream.concat(
+            actionPlugins.stream().flatMap(p -> p.getRestHeaders().stream()),
+            Stream.of(new RestHeaderDefinition(Task.X_OPAQUE_ID, false))
+        ).collect(Collectors.toSet());
+        UnaryOperator<RestHandler> restWrapper = null;
+        for (ActionPlugin plugin : actionPlugins) {
+            UnaryOperator<RestHandler> newRestWrapper = plugin.getRestHandlerWrapper(threadPool.getThreadContext());
+            if (newRestWrapper != null) {
+                logger.debug("Using REST wrapper from plugin " + plugin.getClass().getName());
+                if (restWrapper != null) {
+                    throw new IllegalArgumentException("Cannot have more than one plugin implementing a REST wrapper");
+                }
+                restWrapper = newRestWrapper;
+            }
+        }
+        UnaryOperator<ProtobufRestHandler> protobufRestWrapper = null;
+        for (ProtobufActionPlugin plugin : protobufActionPlugins) {
+            UnaryOperator<ProtobufRestHandler> newRestWrapper = plugin.getRestHandlerWrapper(threadPool.getThreadContext());
+            if (newRestWrapper != null) {
+                logger.debug("Using REST wrapper from plugin " + plugin.getClass().getName());
+                if (protobufRestWrapper != null) {
+                    throw new IllegalArgumentException("Cannot have more than one plugin implementing a REST wrapper");
+                }
+                protobufRestWrapper = newRestWrapper;
+            }
+        }
+        mappingRequestValidators = new RequestValidators<>(
+            actionPlugins.stream().flatMap(p -> p.mappingRequestValidators().stream()).collect(Collectors.toList())
+        );
+        indicesAliasesRequestRequestValidators = new RequestValidators<>(
+            actionPlugins.stream().flatMap(p -> p.indicesAliasesRequestValidators().stream()).collect(Collectors.toList())
+        );
+
+        restController = new RestController(headers, restWrapper, nodeClient, protobufRestWrapper, protobufNodeClient, circuitBreakerService, usageService);
+    }
+
     public Map<String, ActionHandler<?, ?>> getActions() {
         return actions;
     }
@@ -765,12 +862,47 @@ public <Request extends ActionRequest, Response extends ActionResponse> void reg
         return unmodifiableMap(actions.getRegistry());
     }
 
+    static Map<String, ProtobufActionPlugin.ActionHandler<?, ?>> setupProtobufActions(List<ProtobufActionPlugin> actionPlugins) {
+        // Subclass NamedRegistry for easy registration
+        class ActionRegistry extends NamedRegistry<ProtobufActionPlugin.ActionHandler<?, ?>> {
+            ActionRegistry() {
+                super("action");
+            }
+
+            public void register(ProtobufActionPlugin.ActionHandler<?, ?> handler) {
+                register(handler.getAction().name(), handler);
+            }
+
+            public <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> void register(
+                ProtobufActionType<Response> action,
+                Class<? extends ProtobufTransportAction<Request, Response>> transportAction,
+                Class<?>... supportTransportActions
+            ) {
+                register(new ProtobufActionPlugin.ActionHandler<>(action, transportAction, supportTransportActions));
+            }
+        }
+        ActionRegistry actions = new ActionRegistry();
+
+        actions.register(ProtobufMainAction.INSTANCE, ProtobufTransportMainAction.class);
+        actions.register(ProtobufNodesInfoAction.INSTANCE, ProtobufTransportNodesInfoAction.class);
+        actions.register(ProtobufNodesStatsAction.INSTANCE, ProtobufTransportNodesStatsAction.class);
+        actions.register(ProtobufClusterStateAction.INSTANCE, ProtobufTransportClusterStateAction.class);
+
+        return unmodifiableMap(actions.getRegistry());
+    }
+
     private ActionFilters setupActionFilters(List<ActionPlugin> actionPlugins) {
         return new ActionFilters(
             Collections.unmodifiableSet(actionPlugins.stream().flatMap(p -> p.getActionFilters().stream()).collect(Collectors.toSet()))
         );
     }
 
+    private ProtobufActionFilters setupProtobufActionFilters(List<ProtobufActionPlugin> actionPlugins) {
+        return new ProtobufActionFilters(
+            Collections.unmodifiableSet(actionPlugins.stream().flatMap(p -> p.getActionFilters().stream()).collect(Collectors.toSet()))
+        );
+    }
+
     public void initRestHandlers(Supplier<DiscoveryNodes> nodesInCluster) {
         List<AbstractCatAction> catActions = new ArrayList<>();
         Consumer<RestHandler> registerHandler = handler -> {
@@ -980,9 +1112,38 @@ public void initRestHandlers(Supplier<DiscoveryNodes> nodesInCluster) {
         }
     }
 
+    public void initProtobufRestHandlers() {
+        List<ProtobufAbstractCatAction> catActions = new ArrayList<>();
+        Consumer<ProtobufRestHandler> registerHandler = handler -> {
+            if (handler instanceof ProtobufAbstractCatAction) {
+                catActions.add((ProtobufAbstractCatAction) handler);
+            }
+            restController.registerProtobufHandler(handler);
+        };
+
+        // CAT API
+        registerHandler.accept(new ProtobufRestNodesAction());
+
+        // for (ActionPlugin plugin : actionPlugins) {
+        //     for (ProtobufActionPlugin handler : plugin.getRestHandlers(
+        //         settings,
+        //         restController,
+        //         clusterSettings,
+        //         indexScopedSettings,
+        //         settingsFilter,
+        //         indexNameExpressionResolver,
+        //         nodesInCluster
+        //     )) {
+        //         registerHandler.accept(handler);
+        //     }
+        // }
+        registerHandler.accept(new ProtobufRestCatAction(catActions));
+    }
+
     @Override
     protected void configure() {
         bind(ActionFilters.class).toInstance(actionFilters);
+        bind(ProtobufActionFilters.class).toInstance(protobufActionFilters);
         bind(DestructiveOperations.class).toInstance(destructiveOperations);
         bind(new TypeLiteral<RequestValidators<PutMappingRequest>>() {
         }).toInstance(mappingRequestValidators);
@@ -1011,6 +1172,27 @@ protected void configure() {
 
         // register dynamic ActionType -> transportAction Map used by NodeClient
         bind(DynamicActionRegistry.class).toInstance(dynamicActionRegistry);
+
+        // register ActionType -> transportAction Map used by NodeClient
+        @SuppressWarnings("rawtypes")
+        MapBinder<ProtobufActionType, ProtobufTransportAction> protobufTransportActionsBinder = MapBinder.newMapBinder(
+            binder(),
+            ProtobufActionType.class,
+            ProtobufTransportAction.class
+        );
+        for (ProtobufActionPlugin.ActionHandler<?, ?> action : protobufActions.values()) {
+            // bind the action as eager singleton, so the map binder one will reuse it
+            bind(action.getTransportAction()).asEagerSingleton();
+            protobufTransportActionsBinder.addBinding(action.getAction()).to(action.getTransportAction()).asEagerSingleton();
+            for (Class<?> supportAction : action.getSupportTransportActions()) {
+                bind(supportAction).asEagerSingleton();
+            }
+        }
+
+        // register dynamic ActionType -> transportAction Map used by NodeClient
+        bind(ProtobufDynamicActionRegistry.class).toInstance(protobufDynamicActionRegistry);
+
+
     }
 
     public ActionFilters getActionFilters() {
@@ -1021,6 +1203,10 @@ public DynamicActionRegistry getDynamicActionRegistry() {
         return dynamicActionRegistry;
     }
 
+    public ProtobufDynamicActionRegistry getProtobufDynamicActionRegistry() {
+        return protobufDynamicActionRegistry;
+    }
+
     public RestController getRestController() {
         return restController;
     }
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java b/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
index 4bae1f6c3bb04..ffb013af87251 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
@@ -10,7 +10,7 @@
 
 import com.google.protobuf.CodedInputStream;
 import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ProtobufTransportResponseHandler;
 import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.ProtobufTransportResponse;
@@ -43,7 +43,7 @@ public ProtobufActionListenerResponseHandler(
     }
 
     public ProtobufActionListenerResponseHandler(ActionListener<? super Response> listener, ProtobufWriteable.Reader<Response> reader) {
-        this(listener, reader, ProtobufThreadPool.Names.SAME);
+        this(listener, reader, ThreadPool.Names.SAME);
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
new file mode 100644
index 0000000000000..223520853fafe
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
@@ -0,0 +1,128 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.admin.cluster.node.info;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.action.ProtobufFailedNodeException;
+import org.opensearch.action.support.ProtobufActionFilters;
+import org.opensearch.action.support.nodes.ProtobufTransportNodesAction;
+import org.opensearch.cluster.ProtobufClusterName;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.inject.Inject;
+import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.StreamOutput;
+import org.opensearch.node.ProtobufNodeService;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportRequest;
+import org.opensearch.transport.ProtobufTransportService;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Transport action for OpenSearch Node Information
+*
+* @opensearch.internal
+*/
+public class ProtobufTransportNodesInfoAction extends ProtobufTransportNodesAction<
+    ProtobufNodesInfoRequest,
+    ProtobufNodesInfoResponse,
+    ProtobufTransportNodesInfoAction.NodeInfoRequest,
+    ProtobufNodeInfo> {
+
+    private final ProtobufNodeService nodeService;
+
+    @Inject
+    public ProtobufTransportNodesInfoAction(
+        ThreadPool threadPool,
+        ClusterService clusterService,
+        ProtobufTransportService transportService,
+        ProtobufNodeService nodeService,
+        ProtobufActionFilters actionFilters
+    ) {
+        super(
+            NodesInfoAction.NAME,
+            threadPool,
+            clusterService,
+            transportService,
+            actionFilters,
+            ProtobufNodesInfoRequest::new,
+            NodeInfoRequest::new,
+            ThreadPool.Names.MANAGEMENT,
+            ProtobufNodeInfo.class
+        );
+        this.nodeService = nodeService;
+    }
+
+    @Override
+    protected ProtobufNodesInfoResponse newResponse(
+        ProtobufNodesInfoRequest nodesInfoRequest,
+        List<ProtobufNodeInfo> responses,
+        List<ProtobufFailedNodeException> failures
+    ) {
+        return new ProtobufNodesInfoResponse(new ProtobufClusterName(clusterService.getClusterName().value()), responses, failures);
+    }
+
+    @Override
+    protected NodeInfoRequest newNodeRequest(ProtobufNodesInfoRequest request) {
+        return new NodeInfoRequest(request);
+    }
+
+    @Override
+    protected ProtobufNodeInfo newNodeResponse(CodedInputStream in) throws IOException {
+        return new ProtobufNodeInfo(in);
+    }
+
+    @Override
+    protected ProtobufNodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
+        ProtobufNodesInfoRequest request = nodeRequest.request;
+        Set<String> metrics = request.requestedMetrics();
+        return nodeService.info(
+            metrics.contains(NodesInfoRequest.Metric.SETTINGS.metricName()),
+            metrics.contains(NodesInfoRequest.Metric.OS.metricName()),
+            metrics.contains(NodesInfoRequest.Metric.PROCESS.metricName()),
+            metrics.contains(NodesInfoRequest.Metric.JVM.metricName()),
+            metrics.contains(NodesInfoRequest.Metric.THREAD_POOL.metricName()),
+            metrics.contains(NodesInfoRequest.Metric.TRANSPORT.metricName()),
+            metrics.contains(NodesInfoRequest.Metric.HTTP.metricName()),
+            metrics.contains(NodesInfoRequest.Metric.PLUGINS.metricName()),
+            metrics.contains(NodesInfoRequest.Metric.INGEST.metricName()),
+            metrics.contains(NodesInfoRequest.Metric.AGGREGATIONS.metricName()),
+            metrics.contains(NodesInfoRequest.Metric.INDICES.metricName()),
+            metrics.contains(NodesInfoRequest.Metric.SEARCH_PIPELINES.metricName())
+        );
+    }
+
+    /**
+     * Inner Node Info Request
+    *
+    * @opensearch.internal
+    */
+    public static class NodeInfoRequest extends ProtobufTransportRequest {
+
+        ProtobufNodesInfoRequest request;
+
+        public NodeInfoRequest(CodedInputStream in) throws IOException {
+            super(in);
+            request = new ProtobufNodesInfoRequest(in);
+        }
+
+        public NodeInfoRequest(ProtobufNodesInfoRequest request) {
+            this.request = request;
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            super.writeTo(out);
+            request.writeTo(out);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
new file mode 100644
index 0000000000000..b12bd7ac0a4d1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
@@ -0,0 +1,132 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.admin.cluster.node.stats;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.action.ProtobufFailedNodeException;
+import org.opensearch.action.support.ProtobufActionFilters;
+import org.opensearch.action.support.nodes.ProtobufTransportNodesAction;
+import org.opensearch.cluster.ProtobufClusterName;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.inject.Inject;
+import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.StreamOutput;
+import org.opensearch.node.ProtobufNodeService;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportRequest;
+import org.opensearch.transport.ProtobufTransportService;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Transport action for obtaining OpenSearch Node Stats
+*
+* @opensearch.internal
+*/
+public class ProtobufTransportNodesStatsAction extends ProtobufTransportNodesAction<
+    ProtobufNodesStatsRequest,
+    ProtobufNodesStatsResponse,
+    ProtobufTransportNodesStatsAction.NodeStatsRequest,
+    ProtobufNodeStats> {
+
+    private final ProtobufNodeService nodeService;
+
+    @Inject
+    public ProtobufTransportNodesStatsAction(
+        ThreadPool threadPool,
+        ClusterService clusterService,
+        ProtobufTransportService transportService,
+        ProtobufNodeService nodeService,
+        ProtobufActionFilters actionFilters
+    ) {
+        super(
+            NodesStatsAction.NAME,
+            threadPool,
+            clusterService,
+            transportService,
+            actionFilters,
+            ProtobufNodesStatsRequest::new,
+            NodeStatsRequest::new,
+            ThreadPool.Names.MANAGEMENT,
+            ProtobufNodeStats.class
+        );
+        this.nodeService = nodeService;
+    }
+
+    @Override
+    protected ProtobufNodesStatsResponse newResponse(ProtobufNodesStatsRequest request, List<ProtobufNodeStats> responses, List<ProtobufFailedNodeException> failures) {
+        return new ProtobufNodesStatsResponse(new ProtobufClusterName(clusterService.getClusterName().value()), responses, failures);
+    }
+
+    @Override
+    protected NodeStatsRequest newNodeRequest(ProtobufNodesStatsRequest request) {
+        return new NodeStatsRequest(request);
+    }
+
+    @Override
+    protected ProtobufNodeStats newNodeResponse(CodedInputStream in) throws IOException {
+        return new ProtobufNodeStats(in);
+    }
+
+    @Override
+    protected ProtobufNodeStats nodeOperation(NodeStatsRequest nodeStatsRequest) {
+        ProtobufNodesStatsRequest request = nodeStatsRequest.request;
+        Set<String> metrics = request.requestedMetrics();
+        return nodeService.stats(
+            request.indices(),
+            ProtobufNodesStatsRequest.Metric.OS.containedIn(metrics),
+            ProtobufNodesStatsRequest.Metric.PROCESS.containedIn(metrics),
+            ProtobufNodesStatsRequest.Metric.JVM.containedIn(metrics),
+            ProtobufNodesStatsRequest.Metric.THREAD_POOL.containedIn(metrics),
+            ProtobufNodesStatsRequest.Metric.FS.containedIn(metrics),
+            ProtobufNodesStatsRequest.Metric.TRANSPORT.containedIn(metrics),
+            ProtobufNodesStatsRequest.Metric.HTTP.containedIn(metrics),
+            ProtobufNodesStatsRequest.Metric.BREAKER.containedIn(metrics),
+            ProtobufNodesStatsRequest.Metric.SCRIPT.containedIn(metrics),
+            ProtobufNodesStatsRequest.Metric.DISCOVERY.containedIn(metrics),
+            ProtobufNodesStatsRequest.Metric.INGEST.containedIn(metrics),
+            ProtobufNodesStatsRequest.Metric.ADAPTIVE_SELECTION.containedIn(metrics),
+            ProtobufNodesStatsRequest.Metric.SCRIPT_CACHE.containedIn(metrics),
+            ProtobufNodesStatsRequest.Metric.INDEXING_PRESSURE.containedIn(metrics),
+            ProtobufNodesStatsRequest.Metric.SHARD_INDEXING_PRESSURE.containedIn(metrics),
+            ProtobufNodesStatsRequest.Metric.SEARCH_BACKPRESSURE.containedIn(metrics),
+            ProtobufNodesStatsRequest.Metric.CLUSTER_MANAGER_THROTTLING.containedIn(metrics),
+            ProtobufNodesStatsRequest.Metric.WEIGHTED_ROUTING_STATS.containedIn(metrics),
+            ProtobufNodesStatsRequest.Metric.FILE_CACHE_STATS.containedIn(metrics)
+        );
+    }
+
+    /**
+     * Inner Node Stats Request
+    *
+    * @opensearch.internal
+    */
+    public static class NodeStatsRequest extends ProtobufTransportRequest {
+
+        ProtobufNodesStatsRequest request;
+
+        public NodeStatsRequest(CodedInputStream in) throws IOException {
+            super(in);
+            request = new ProtobufNodesStatsRequest(in);
+        }
+
+        NodeStatsRequest(ProtobufNodesStatsRequest request) {
+            this.request = request;
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            super.writeTo(out);
+            request.writeTo(out);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
new file mode 100644
index 0000000000000..b8a663c409904
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
@@ -0,0 +1,212 @@
+/*
+ * 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.
+ */
+
+package org.opensearch.action.admin.cluster.state;
+
+import com.google.protobuf.CodedInputStream;
+import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.support.ProtobufActionFilters;
+import org.opensearch.action.support.clustermanager.ProtobufTransportClusterManagerNodeReadAction;
+import org.opensearch.cluster.ProtobufClusterState;
+import org.opensearch.cluster.ProtobufClusterStateObserver;
+import org.opensearch.cluster.NotClusterManagerException;
+import org.opensearch.cluster.block.ClusterBlockException;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.ProtobufIndexNameExpressionResolver;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.metadata.Metadata.Custom;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.inject.Inject;
+import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.node.NodeClosedException;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportService;
+
+import java.io.IOException;
+import java.util.function.Predicate;
+import java.util.Map;
+
+/**
+ * Transport action for obtaining cluster state
+ *
+ * @opensearch.internal
+ */
+public class ProtobufTransportClusterStateAction extends ProtobufTransportClusterManagerNodeReadAction<ProtobufClusterStateRequest, ProtobufClusterStateResponse> {
+
+    private final Logger logger = LogManager.getLogger(getClass());
+
+    static {
+        final String property = System.getProperty("opensearch.cluster_state.size");
+        if (property != null) {
+            throw new IllegalArgumentException("opensearch.cluster_state.size is no longer respected but was [" + property + "]");
+        }
+    }
+
+    @Inject
+    public ProtobufTransportClusterStateAction(
+        ProtobufTransportService transportService,
+        ClusterService clusterService,
+        ThreadPool threadPool,
+        ProtobufActionFilters actionFilters,
+        ProtobufIndexNameExpressionResolver indexNameExpressionResolver
+    ) {
+        super(
+            ClusterStateAction.NAME,
+            false,
+            transportService,
+            clusterService,
+            threadPool,
+            actionFilters,
+            ProtobufClusterStateRequest::new,
+            indexNameExpressionResolver
+        );
+    }
+
+    @Override
+    protected String executor() {
+        // very lightweight operation in memory, no need to fork to a thread
+        return ThreadPool.Names.SAME;
+    }
+
+    @Override
+    protected ProtobufClusterStateResponse read(CodedInputStream in) throws IOException {
+        return new ProtobufClusterStateResponse(in);
+    }
+
+    @Override
+    protected ClusterBlockException checkBlock(ProtobufClusterStateRequest request, ProtobufClusterState state) {
+        // cluster state calls are done also on a fully blocked cluster to figure out what is going
+        // on in the cluster. For example, which nodes have joined yet the recovery has not yet kicked
+        // in, we need to make sure we allow those calls
+        // return state.blocks().globalBlockedException(ClusterBlockLevel.METADATA);
+        return null;
+    }
+
+    @Override
+    protected void clusterManagerOperation(
+        final ProtobufClusterStateRequest request,
+        final ProtobufClusterState state,
+        final ActionListener<ProtobufClusterStateResponse> listener
+    ) throws IOException {
+
+        final Predicate<ProtobufClusterState> acceptableClusterStatePredicate = request.waitForMetadataVersion() == null
+            ? clusterState -> true
+            : clusterState -> clusterState.metadata().version() >= request.waitForMetadataVersion();
+
+        final Predicate<ProtobufClusterState> acceptableClusterStateOrNotMasterPredicate = request.local()
+            ? acceptableClusterStatePredicate
+            : acceptableClusterStatePredicate.or(clusterState -> clusterState.nodes().isLocalNodeElectedClusterManager() == false);
+
+        if (acceptableClusterStatePredicate.test(state)) {
+            ActionListener.completeWith(listener, () -> buildResponse(request, state));
+        } else {
+            assert acceptableClusterStateOrNotMasterPredicate.test(state) == false;
+            new ProtobufClusterStateObserver(state, clusterService, request.waitForTimeout(), logger, threadPool.getThreadContext())
+                .waitForNextChange(new ProtobufClusterStateObserver.Listener() {
+
+                    @Override
+                    public void onNewClusterState(ProtobufClusterState newState) {
+                        if (acceptableClusterStatePredicate.test(newState)) {
+                            ActionListener.completeWith(listener, () -> buildResponse(request, newState));
+                        } else {
+                            listener.onFailure(
+                                new NotClusterManagerException(
+                                    "cluster-manager stepped down waiting for metadata version " + request.waitForMetadataVersion()
+                                )
+                            );
+                        }
+                    }
+
+                    @Override
+                    public void onClusterServiceClose() {
+                        listener.onFailure(new NodeClosedException(clusterService.localNode()));
+                    }
+
+                    @Override
+                    public void onTimeout(TimeValue timeout) {
+                        try {
+                            listener.onResponse(new ProtobufClusterStateResponse(state.getClusterName(), null, true));
+                        } catch (Exception e) {
+                            listener.onFailure(e);
+                        }
+                    }
+                }, acceptableClusterStateOrNotMasterPredicate);
+        }
+    }
+
+    private ProtobufClusterStateResponse buildResponse(final ProtobufClusterStateRequest request, final ProtobufClusterState currentState) {
+        logger.trace("Serving cluster state request using version {}", currentState.version());
+        ProtobufClusterState.Builder builder = ProtobufClusterState.builder(currentState.getClusterName());
+        builder.version(currentState.version());
+        builder.stateUUID(currentState.stateUUID());
+
+        if (request.nodes()) {
+            builder.nodes(currentState.nodes());
+        }
+        if (request.routingTable()) {
+            if (request.indices().length > 0) {
+                RoutingTable.Builder routingTableBuilder = RoutingTable.builder();
+                String[] indices = indexNameExpressionResolver.concreteIndexNames(currentState, request);
+                for (String filteredIndex : indices) {
+                    if (currentState.routingTable().getIndicesRouting().containsKey(filteredIndex)) {
+                        routingTableBuilder.add(currentState.routingTable().getIndicesRouting().get(filteredIndex));
+                    }
+                }
+                builder.routingTable(routingTableBuilder.build());
+            } else {
+                builder.routingTable(currentState.routingTable());
+            }
+        }
+        if (request.blocks()) {
+            builder.blocks(currentState.blocks());
+        }
+
+        Metadata.Builder mdBuilder = Metadata.builder();
+        mdBuilder.clusterUUID(currentState.metadata().clusterUUID());
+        mdBuilder.coordinationMetadata(currentState.coordinationMetadata());
+
+        if (request.metadata()) {
+            if (request.indices().length > 0) {
+                mdBuilder.version(currentState.metadata().version());
+                String[] indices = indexNameExpressionResolver.concreteIndexNames(currentState, request);
+                for (String filteredIndex : indices) {
+                    IndexMetadata indexMetadata = currentState.metadata().index(filteredIndex);
+                    if (indexMetadata != null) {
+                        mdBuilder.put(indexMetadata, false);
+                    }
+                }
+            } else {
+                mdBuilder = Metadata.builder(currentState.metadata());
+            }
+
+            // filter out metadata that shouldn't be returned by the API
+            for (final Map.Entry<String, Custom> custom : currentState.metadata().customs().entrySet()) {
+                if (custom.getValue().context().contains(Metadata.XContentContext.API) == false) {
+                    mdBuilder.removeCustom(custom.getKey());
+                }
+            }
+        }
+        builder.metadata(mdBuilder);
+
+        if (request.customs()) {
+            for (ObjectObjectCursor<String, ProtobufClusterState.Custom> custom : currentState.customs()) {
+                if (custom.value.isPrivate() == false) {
+                    builder.putCustom(custom.key, custom.value);
+                }
+            }
+        }
+
+        return new ProtobufClusterStateResponse(currentState.getClusterName(), builder.build(), false);
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/action/main/ProtobufMainAction.java b/server/src/main/java/org/opensearch/action/main/ProtobufMainAction.java
new file mode 100644
index 0000000000000..1a457423f0b00
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/main/ProtobufMainAction.java
@@ -0,0 +1,26 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.main;
+
+import org.opensearch.action.ProtobufActionType;
+
+/**
+ * The main OpenSearch Action
+*
+* @opensearch.internal
+*/
+public class ProtobufMainAction extends ProtobufActionType<ProtobufMainResponse> {
+
+    public static final String NAME = "cluster:monitor/main";
+    public static final ProtobufMainAction INSTANCE = new ProtobufMainAction();
+
+    public ProtobufMainAction() {
+        super(NAME, ProtobufMainResponse::new);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/main/ProtobufMainRequest.java b/server/src/main/java/org/opensearch/action/main/ProtobufMainRequest.java
new file mode 100644
index 0000000000000..3fb3e35d679f0
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/main/ProtobufMainRequest.java
@@ -0,0 +1,35 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.main;
+
+import com.google.protobuf.CodedInputStream;
+import org.opensearch.action.ProtobufActionRequest;
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.common.io.stream.StreamInput;
+
+import java.io.IOException;
+
+/**
+ * Transport request for main action
+*
+* @opensearch.internal
+*/
+public class ProtobufMainRequest extends ProtobufActionRequest {
+
+    public ProtobufMainRequest() {}
+
+    ProtobufMainRequest(CodedInputStream in) throws IOException {
+        super(in);
+    }
+
+    @Override
+    public ActionRequestValidationException validate() {
+        return null;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java b/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java
new file mode 100644
index 0000000000000..36963fd5894f5
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java
@@ -0,0 +1,185 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.main;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import org.opensearch.Build;
+import org.opensearch.Version;
+import org.opensearch.action.ProtobufActionResponse;
+import org.opensearch.cluster.ProtobufClusterName;
+import org.opensearch.core.ParseField;
+import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.StreamOutput;
+import org.opensearch.core.xcontent.ObjectParser;
+import org.opensearch.core.xcontent.ToXContentObject;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParser;
+
+import java.io.IOException;
+import java.util.Objects;
+
+/**
+ * The main response of opensearch
+*
+* @opensearch.internal
+*/
+public class ProtobufMainResponse extends ProtobufActionResponse implements ToXContentObject {
+
+    private String nodeName;
+    private Version version;
+    private ProtobufClusterName clusterName;
+    private String clusterUuid;
+    private Build build;
+    public static final String TAGLINE = "The OpenSearch Project: https://opensearch.org/";
+
+    ProtobufMainResponse() {}
+
+    ProtobufMainResponse(CodedInputStream in) throws IOException {
+        super(in);
+        nodeName = in.readString();
+        version = Version.readVersionProtobuf(in);
+        clusterName = new ProtobufClusterName(in);
+        clusterUuid = in.readString();
+        build = Build.readBuildProtobuf(in);
+    }
+
+    public ProtobufMainResponse(String nodeName, Version version, ProtobufClusterName clusterName, String clusterUuid, Build build) {
+        this.nodeName = nodeName;
+        this.version = version;
+        this.clusterName = clusterName;
+        this.clusterUuid = clusterUuid;
+        this.build = build;
+    }
+
+    public String getNodeName() {
+        return nodeName;
+    }
+
+    public Version getVersion() {
+        return version;
+    }
+
+    public ProtobufClusterName getClusterName() {
+        return clusterName;
+    }
+
+    public String getClusterUuid() {
+        return clusterUuid;
+    }
+
+    public Build getBuild() {
+        return build;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeStringNoTag(nodeName);
+        out.writeInt32NoTag(version.id);
+        clusterName.writeTo(out);
+        out.writeStringNoTag(clusterUuid);
+        Build.writeBuildProtobuf(build, out);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        builder.field("name", nodeName);
+        builder.field("cluster_name", clusterName.value());
+        builder.field("cluster_uuid", clusterUuid);
+        builder.startObject("version")
+            .field("distribution", build.getDistribution())
+            .field("number", build.getQualifiedVersion())
+            .field("build_type", build.type().displayName())
+            .field("build_hash", build.hash())
+            .field("build_date", build.date())
+            .field("build_snapshot", build.isSnapshot())
+            .field("lucene_version", version.luceneVersion.toString())
+            .field("minimum_wire_compatibility_version", version.minimumCompatibilityVersion().toString())
+            .field("minimum_index_compatibility_version", version.minimumIndexCompatibilityVersion().toString())
+            .endObject();
+        builder.field("tagline", TAGLINE);
+        builder.endObject();
+        return builder;
+    }
+
+    private static final ObjectParser<ProtobufMainResponse, Void> PARSER = new ObjectParser<>(
+        ProtobufMainResponse.class.getName(),
+        true,
+        ProtobufMainResponse::new
+    );
+
+    static {
+        PARSER.declareString((response, value) -> response.nodeName = value, new ParseField("name"));
+        PARSER.declareString((response, value) -> response.clusterName = new ProtobufClusterName(value), new ParseField("cluster_name"));
+        PARSER.declareString((response, value) -> response.clusterUuid = value, new ParseField("cluster_uuid"));
+        PARSER.declareString((response, value) -> {}, new ParseField("tagline"));
+        PARSER.declareObject((response, value) -> {
+            final String buildType = (String) value.get("build_type");
+            response.build = new Build(
+                /*
+                * Be lenient when reading on the wire, the enumeration values from other versions might be different than what
+                * we know.
+                */
+                buildType == null ? Build.Type.UNKNOWN : Build.Type.fromDisplayName(buildType, false),
+                (String) value.get("build_hash"),
+                (String) value.get("build_date"),
+                (boolean) value.get("build_snapshot"),
+                (String) value.get("number"),
+                (String) value.get("distribution")
+            );
+            response.version = Version.fromString(
+                ((String) value.get("number")).replace("-SNAPSHOT", "").replaceFirst("-(alpha\\d+|beta\\d+|rc\\d+)", "")
+            );
+        }, (parser, context) -> parser.map(), new ParseField("version"));
+    }
+
+    public static ProtobufMainResponse fromXContent(XContentParser parser) {
+        return PARSER.apply(parser, null);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        ProtobufMainResponse other = (ProtobufMainResponse) o;
+        return Objects.equals(nodeName, other.nodeName)
+            && Objects.equals(version, other.version)
+            && Objects.equals(clusterUuid, other.clusterUuid)
+            && Objects.equals(build, other.build)
+            && Objects.equals(clusterName, other.clusterName);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(nodeName, version, clusterUuid, build, clusterName);
+    }
+
+    @Override
+    public String toString() {
+        return "ProtobufMainResponse{"
+            + "nodeName='"
+            + nodeName
+            + '\''
+            + ", version="
+            + version
+            + ", clusterName="
+            + clusterName
+            + ", clusterUuid='"
+            + clusterUuid
+            + '\''
+            + ", build="
+            + build
+            + '}';
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/main/ProtobufTransportMainAction.java b/server/src/main/java/org/opensearch/action/main/ProtobufTransportMainAction.java
new file mode 100644
index 0000000000000..d5f91651d2fb0
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/main/ProtobufTransportMainAction.java
@@ -0,0 +1,56 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.main;
+
+import org.opensearch.Build;
+import org.opensearch.Version;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.support.ProtobufActionFilters;
+import org.opensearch.action.support.ProtobufHandledTransportAction;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.ProtobufClusterName;
+import org.opensearch.cluster.ProtobufClusterState;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.inject.Inject;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.node.Node;
+import org.opensearch.tasks.ProtobufTask;
+import org.opensearch.transport.ProtobufTransportService;
+
+/**
+ * Performs the main action
+*
+* @opensearch.internal
+*/
+public class ProtobufTransportMainAction extends ProtobufHandledTransportAction<ProtobufMainRequest, ProtobufMainResponse> {
+
+    private final String nodeName;
+    private final ClusterService clusterService;
+
+    @Inject
+    public ProtobufTransportMainAction(
+        Settings settings,
+        ProtobufTransportService transportService,
+        ProtobufActionFilters actionFilters,
+        ClusterService clusterService
+    ) {
+        super(MainAction.NAME, transportService, actionFilters, ProtobufMainRequest::new);
+        this.nodeName = Node.NODE_NAME_SETTING.get(settings);
+        this.clusterService = clusterService;
+    }
+
+    @Override
+    protected void doExecute(ProtobufTask task, ProtobufMainRequest request, ActionListener<ProtobufMainResponse> listener) {
+        ClusterState clusterState = clusterService.state();
+        ProtobufClusterName clusterName = new ProtobufClusterName(clusterState.getClusterName().value());
+        listener.onResponse(
+            new ProtobufMainResponse(nodeName, Version.CURRENT, clusterName, clusterState.metadata().clusterUUID(), Build.CURRENT)
+        );
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java b/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
new file mode 100644
index 0000000000000..5d85e62ea9def
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
@@ -0,0 +1,83 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.support;
+
+import org.opensearch.action.ProtobufActionRequest;
+import org.opensearch.action.ProtobufActionResponse;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.tasks.ProtobufTask;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportChannel;
+import org.opensearch.transport.ProtobufTransportRequestHandler;
+import org.opensearch.transport.ProtobufTransportService;
+
+/**
+ * A ProtobufTransportAction that self registers a handler into the transport service
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufHandledTransportAction<Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> extends ProtobufTransportAction<
+    Request,
+    Response> {
+
+    protected ProtobufHandledTransportAction(
+        String actionName,
+        ProtobufTransportService transportService,
+        ProtobufActionFilters actionFilters,
+        ProtobufWriteable.Reader<Request> requestReader
+    ) {
+        this(actionName, true, transportService, actionFilters, requestReader);
+    }
+
+    protected ProtobufHandledTransportAction(
+        String actionName,
+        ProtobufTransportService transportService,
+        ProtobufActionFilters actionFilters,
+        ProtobufWriteable.Reader<Request> requestReader,
+        String executor
+    ) {
+        this(actionName, true, transportService, actionFilters, requestReader, executor);
+    }
+
+    protected ProtobufHandledTransportAction(
+        String actionName,
+        boolean canTripCircuitBreaker,
+        ProtobufTransportService transportService,
+        ProtobufActionFilters actionFilters,
+        ProtobufWriteable.Reader<Request> requestReader
+    ) {
+        this(actionName, canTripCircuitBreaker, transportService, actionFilters, requestReader, ThreadPool.Names.SAME);
+    }
+
+    protected ProtobufHandledTransportAction(
+        String actionName,
+        boolean canTripCircuitBreaker,
+        ProtobufTransportService transportService,
+        ProtobufActionFilters actionFilters,
+        ProtobufWriteable.Reader<Request> requestReader,
+        String executor
+    ) {
+        super(actionName, actionFilters, transportService.getTaskManager());
+        transportService.registerRequestHandler(actionName, executor, false, canTripCircuitBreaker, requestReader, new TransportHandler());
+    }
+
+    /**
+     * Inner transport handler
+    *
+    * @opensearch.internal
+    */
+    class TransportHandler implements ProtobufTransportRequestHandler<Request> {
+        @Override
+        public final void messageReceived(final Request request, final ProtobufTransportChannel channel, ProtobufTask task) {
+            // We already got the task created on the network layer - no need to create it again on the transport layer
+            execute(task, request, new ProtobufChannelActionListener<>(channel, actionName, request));
+        }
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java b/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
index 72e4ac90403b0..6f0356fb0dabc 100644
--- a/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
@@ -19,8 +19,8 @@
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.tasks.ProtobufTask;
 import org.opensearch.tasks.ProtobufTaskId;
-import org.opensearch.tasks.ProtobufTaskManager;
 import org.opensearch.tasks.TaskCancelledException;
+import org.opensearch.tasks.TaskManager;
 import org.opensearch.tasks.ProtobufTaskListener;
 import java.util.concurrent.atomic.AtomicInteger;
 
@@ -33,14 +33,14 @@ public abstract class ProtobufTransportAction<Request extends ProtobufActionRequ
 
     public final String actionName;
     private final ProtobufActionFilter[] filters;
-    protected final ProtobufTaskManager taskManager;
+    protected final TaskManager taskManager;
     /**
      * @deprecated declare your own logger.
     */
     @Deprecated
     protected Logger logger = LogManager.getLogger(getClass());
 
-    protected ProtobufTransportAction(String actionName, ProtobufActionFilters actionFilters, ProtobufTaskManager taskManager) {
+    protected ProtobufTransportAction(String actionName, ProtobufActionFilters actionFilters, TaskManager taskManager) {
         this.actionName = actionName;
         this.filters = actionFilters.filters();
         this.taskManager = taskManager;
@@ -48,7 +48,7 @@ protected ProtobufTransportAction(String actionName, ProtobufActionFilters actio
 
     private Releasable registerChildNode(ProtobufTaskId parentTask) {
         if (parentTask.isSet()) {
-            return taskManager.registerChildNode(parentTask.getId(), taskManager.localNode());
+            return taskManager.registerProtobufChildNode(parentTask.getId(), taskManager.localProtobufNode());
         } else {
             return () -> {};
         }
@@ -71,19 +71,19 @@ public final ProtobufTask execute(Request request, ActionListener<Response> list
         final ProtobufTask task;
 
         try {
-            task = taskManager.register("transport", actionName, request);
+            task = taskManager.registerProtobuf("transport", actionName, request);
         } catch (TaskCancelledException e) {
             unregisterChildNode.close();
             throw e;
         }
 
-        ThreadContext.StoredContext storedContext = taskManager.taskExecutionStarted(task);
+        ThreadContext.StoredContext storedContext = taskManager.protobufTaskExecutionStarted(task);
         try {
             execute(task, request, new ActionListener<Response>() {
                 @Override
                 public void onResponse(Response response) {
                     try {
-                        Releasables.close(unregisterChildNode, () -> taskManager.unregister(task));
+                        Releasables.close(unregisterChildNode, () -> taskManager.unregisterProtobufTask(task));
                     } finally {
                         listener.onResponse(response);
                     }
@@ -92,7 +92,7 @@ public void onResponse(Response response) {
                 @Override
                 public void onFailure(Exception e) {
                     try {
-                        Releasables.close(unregisterChildNode, () -> taskManager.unregister(task));
+                        Releasables.close(unregisterChildNode, () -> taskManager.unregisterProtobufTask(task));
                     } finally {
                         listener.onFailure(e);
                     }
@@ -113,18 +113,18 @@ public final ProtobufTask execute(Request request, ProtobufTaskListener<Response
         final Releasable unregisterChildNode = registerChildNode(request.getParentTask());
         final ProtobufTask task;
         try {
-            task = taskManager.register("transport", actionName, request);
+            task = taskManager.registerProtobuf("transport", actionName, request);
         } catch (TaskCancelledException e) {
             unregisterChildNode.close();
             throw e;
         }
-        ThreadContext.StoredContext storedContext = taskManager.taskExecutionStarted(task);
+        ThreadContext.StoredContext storedContext = taskManager.protobufTaskExecutionStarted(task);
         try {
             execute(task, request, new ActionListener<Response>() {
                 @Override
                 public void onResponse(Response response) {
                     try {
-                        Releasables.close(unregisterChildNode, () -> taskManager.unregister(task));
+                        Releasables.close(unregisterChildNode, () -> taskManager.unregisterProtobufTask(task));
                     } finally {
                         listener.onResponse(task, response);
                     }
@@ -133,7 +133,7 @@ public void onResponse(Response response) {
                 @Override
                 public void onFailure(Exception e) {
                     try {
-                        Releasables.close(unregisterChildNode, () -> taskManager.unregister(task));
+                        Releasables.close(unregisterChildNode, () -> taskManager.unregisterProtobufTask(task));
                     } finally {
                         listener.onFailure(task, e);
                     }
@@ -210,9 +210,9 @@ public void proceed(ProtobufTask task, String actionName, Request request, Actio
     private static class TaskResultStoringActionListener<Response extends ProtobufActionResponse> implements ActionListener<Response> {
         private final ActionListener<Response> delegate;
         private final ProtobufTask task;
-        private final ProtobufTaskManager taskManager;
+        private final TaskManager taskManager;
 
-        private TaskResultStoringActionListener(ProtobufTaskManager taskManager, ProtobufTask task, ActionListener<Response> delegate) {
+        private TaskResultStoringActionListener(TaskManager taskManager, ProtobufTask task, ActionListener<Response> delegate) {
             this.taskManager = taskManager;
             this.task = task;
             this.delegate = delegate;
@@ -221,7 +221,7 @@ private TaskResultStoringActionListener(ProtobufTaskManager taskManager, Protobu
         @Override
         public void onResponse(Response response) {
             try {
-                taskManager.storeResult(task, response, delegate);
+                taskManager.storeResultProtobuf(task, response, delegate);
             } catch (Exception e) {
                 delegate.onFailure(e);
             }
@@ -230,7 +230,7 @@ public void onResponse(Response response) {
         @Override
         public void onFailure(Exception e) {
             try {
-                taskManager.storeResult(task, e, delegate);
+                taskManager.storeResultProtobuf(task, e, delegate);
             } catch (Exception inner) {
                 inner.addSuppressed(e);
                 delegate.onFailure(inner);
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
new file mode 100644
index 0000000000000..5b2e3b4d927d0
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
@@ -0,0 +1,352 @@
+/*
+ * 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.
+ */
+
+package org.opensearch.action.support.clustermanager;
+
+import com.google.protobuf.CodedInputStream;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.ProtobufActionListenerResponseHandler;
+import org.opensearch.action.ProtobufActionResponse;
+import org.opensearch.action.ActionRunnable;
+import org.opensearch.action.bulk.BackoffPolicy;
+import org.opensearch.action.support.ProtobufActionFilters;
+import org.opensearch.action.support.ProtobufHandledTransportAction;
+import org.opensearch.action.support.RetryableAction;
+import org.opensearch.cluster.ProtobufClusterState;
+import org.opensearch.cluster.ProtobufClusterStateObserver;
+import org.opensearch.cluster.ClusterManagerNodeChangePredicate;
+import org.opensearch.cluster.NotClusterManagerException;
+import org.opensearch.cluster.block.ClusterBlockException;
+import org.opensearch.cluster.coordination.FailedToCommitClusterStateException;
+import org.opensearch.cluster.metadata.ProtobufIndexNameExpressionResolver;
+import org.opensearch.cluster.metadata.ProcessClusterEventTimeoutException;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
+import org.opensearch.cluster.service.ClusterManagerTaskThrottler;
+import org.opensearch.cluster.service.ClusterManagerThrottlingException;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.discovery.ClusterManagerNotDiscoveredException;
+import org.opensearch.node.NodeClosedException;
+import org.opensearch.tasks.ProtobufTask;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ConnectTransportException;
+import org.opensearch.transport.ProtobufRemoteTransportException;
+import org.opensearch.transport.ProtobufTransportException;
+import org.opensearch.transport.ProtobufTransportService;
+
+import java.io.IOException;
+import java.util.function.Predicate;
+
+/**
+ * A base class for operations that needs to be performed on the cluster-manager node.
+ *
+ * @opensearch.internal
+ */
+public abstract class ProtobufTransportClusterManagerNodeAction<Request extends ProtobufClusterManagerNodeRequest<Request>, Response extends ProtobufActionResponse>
+    extends ProtobufHandledTransportAction<Request, Response> {
+
+    private static final Logger logger = LogManager.getLogger(ProtobufTransportClusterManagerNodeAction.class);
+
+    protected final ThreadPool threadPool;
+    protected final ProtobufTransportService transportService;
+    protected final ClusterService clusterService;
+    protected final ProtobufIndexNameExpressionResolver indexNameExpressionResolver;
+
+    private final String executor;
+
+    protected ProtobufTransportClusterManagerNodeAction(
+        String actionName,
+        ProtobufTransportService transportService,
+        ClusterService clusterService,
+        ThreadPool threadPool,
+        ProtobufActionFilters actionFilters,
+        ProtobufWriteable.Reader<Request> request,
+        ProtobufIndexNameExpressionResolver indexNameExpressionResolver
+    ) {
+        this(actionName, true, transportService, clusterService, threadPool, actionFilters, request, indexNameExpressionResolver);
+    }
+
+    protected ProtobufTransportClusterManagerNodeAction(
+        String actionName,
+        boolean canTripCircuitBreaker,
+        ProtobufTransportService transportService,
+        ClusterService clusterService,
+        ThreadPool threadPool,
+        ProtobufActionFilters actionFilters,
+        ProtobufWriteable.Reader<Request> request,
+        ProtobufIndexNameExpressionResolver indexNameExpressionResolver
+    ) {
+        super(actionName, canTripCircuitBreaker, transportService, actionFilters, request);
+        this.transportService = transportService;
+        this.clusterService = clusterService;
+        this.threadPool = threadPool;
+        this.indexNameExpressionResolver = indexNameExpressionResolver;
+        this.executor = executor();
+    }
+
+    protected abstract String executor();
+
+    protected abstract Response read(CodedInputStream in) throws IOException;
+
+    /**
+     * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #clusterManagerOperation(ProtobufClusterManagerNodeRequest, ProtobufClusterState, ActionListener)}
+     */
+    @Deprecated
+    protected void masterOperation(Request request, ProtobufClusterState state, ActionListener<Response> listener) throws Exception {
+        throw new UnsupportedOperationException("Must be overridden");
+    }
+
+    // TODO: Add abstract keyword after removing the deprecated masterOperation()
+    protected void clusterManagerOperation(Request request, ProtobufClusterState state, ActionListener<Response> listener) throws Exception {
+        masterOperation(request, state, listener);
+    }
+
+    /**
+     * Override this operation if access to the task parameter is needed
+     * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #clusterManagerOperation(ProtobufTask, ProtobufClusterManagerNodeRequest, ProtobufClusterState, ActionListener)}
+     */
+    @Deprecated
+    protected void masterOperation(ProtobufTask task, Request request, ProtobufClusterState state, ActionListener<Response> listener) throws Exception {
+        clusterManagerOperation(request, state, listener);
+    }
+
+    /**
+     * Override this operation if access to the task parameter is needed
+     */
+    // TODO: Change the implementation to call 'clusterManagerOperation(request...)' after removing the deprecated masterOperation()
+    protected void clusterManagerOperation(ProtobufTask task, Request request, ProtobufClusterState state, ActionListener<Response> listener)
+        throws Exception {
+        masterOperation(task, request, state, listener);
+    }
+
+    protected boolean localExecute(Request request) {
+        return false;
+    }
+
+    protected abstract ClusterBlockException checkBlock(Request request, ProtobufClusterState state);
+
+    @Override
+    protected void doExecute(ProtobufTask task, final Request request, ActionListener<Response> listener) {
+        if (task != null) {
+            request.setParentTask(clusterService.localNode().getId(), task.getId());
+        }
+        new AsyncSingleAction(task, request, listener).run();
+    }
+
+    /**
+     * Asynchronous single action
+     *
+     * @opensearch.internal
+     */
+    class AsyncSingleAction extends RetryableAction {
+
+        private ActionListener<Response> listener;
+        private final Request request;
+        private ProtobufClusterStateObserver observer;
+        private final long startTime;
+        private final ProtobufTask task;
+
+        AsyncSingleAction(ProtobufTask task, Request request, ActionListener<Response> listener) {
+            super(
+                logger,
+                threadPool,
+                ClusterManagerTaskThrottler.getBaseDelayForRetry(),
+                request.clusterManagerNodeTimeout,
+                listener,
+                BackoffPolicy.exponentialEqualJitterBackoff(
+                    ClusterManagerTaskThrottler.getBaseDelayForRetry().millis(),
+                    ClusterManagerTaskThrottler.getMaxDelayForRetry().millis()
+                ),
+                ThreadPool.Names.SAME
+            );
+            this.task = task;
+            this.request = request;
+            this.startTime = threadPool.relativeTimeInMillis();
+        }
+
+        @Override
+        public void tryAction(ActionListener retryListener) {
+            ProtobufClusterState state = clusterService.protobufState();
+            logger.trace("starting processing request [{}] with cluster state version [{}]", request, state.version());
+            this.listener = retryListener;
+            doStart(state);
+        }
+
+        @Override
+        public boolean shouldRetry(Exception e) {
+            // If remote address is null, i.e request is generated from same node and we would want to perform retry for it
+            // If remote address is not null, i.e request is generated from remote node and received on this master node on transport layer
+            // in that case we would want throttling retry to perform on remote node only not on this master node.
+            if (request.remoteAddress() == null) {
+                if (e instanceof ProtobufTransportException) {
+                    return ((ProtobufTransportException) e).unwrapCause() instanceof ClusterManagerThrottlingException;
+                }
+                return e instanceof ClusterManagerThrottlingException;
+            }
+            return false;
+        }
+
+        /**
+         * If tasks gets timed out in retrying on throttling,
+         * it should send cluster event timeout exception.
+         */
+        @Override
+        public Exception getTimeoutException(Exception e) {
+            return new ProcessClusterEventTimeoutException(request.masterNodeTimeout, actionName);
+        }
+
+        protected void doStart(ProtobufClusterState clusterState) {
+            try {
+                final ProtobufDiscoveryNodes nodes = clusterState.nodes();
+                if (nodes.isLocalNodeElectedClusterManager() || localExecute(request)) {
+                    // check for block, if blocked, retry, else, execute locally
+                    final ClusterBlockException blockException = checkBlock(request, clusterState);
+                    if (blockException != null) {
+                        if (!blockException.retryable()) {
+                            listener.onFailure(blockException);
+                        } else {
+                            logger.debug("can't execute due to a cluster block, retrying", blockException);
+                            retry(clusterState, blockException, newState -> {
+                                try {
+                                    ClusterBlockException newException = checkBlock(request, newState);
+                                    return (newException == null || !newException.retryable());
+                                } catch (Exception e) {
+                                    // accept state as block will be rechecked by doStart() and listener.onFailure() then called
+                                    logger.trace("exception occurred during cluster block checking, accepting state", e);
+                                    return true;
+                                }
+                            });
+                        }
+                    } else {
+                        ActionListener<Response> delegate = ActionListener.delegateResponse(listener, (delegatedListener, t) -> {
+                            if (t instanceof FailedToCommitClusterStateException || t instanceof NotClusterManagerException) {
+                                logger.debug(
+                                    () -> new ParameterizedMessage(
+                                        "master could not publish cluster state or "
+                                            + "stepped down before publishing action [{}], scheduling a retry",
+                                        actionName
+                                    ),
+                                    t
+                                );
+                                retryOnMasterChange(clusterState, t);
+                            } else {
+                                delegatedListener.onFailure(t);
+                            }
+                        });
+                        threadPool.executor(executor)
+                            .execute(ActionRunnable.wrap(delegate, l -> clusterManagerOperation(task, request, clusterState, l)));
+                    }
+                } else {
+                    if (nodes.getClusterManagerNode() == null) {
+                        logger.debug("no known cluster-manager node, scheduling a retry");
+                        retryOnMasterChange(clusterState, null);
+                    } else {
+                        ProtobufDiscoveryNode clusterManagerNode = nodes.getClusterManagerNode();
+                        final String actionName = getClusterManagerActionName(clusterManagerNode);
+                        transportService.sendRequest(
+                            clusterManagerNode,
+                            actionName,
+                            request,
+                            new ProtobufActionListenerResponseHandler<Response>(listener, ProtobufTransportClusterManagerNodeAction.this::read) {
+                                @Override
+                                public void handleException(final ProtobufTransportException exp) {
+                                    Throwable cause = exp.unwrapCause();
+                                    if (cause instanceof ConnectTransportException
+                                        || (exp instanceof ProtobufRemoteTransportException && cause instanceof NodeClosedException)) {
+                                        // we want to retry here a bit to see if a new cluster-manager is elected
+                                        logger.debug(
+                                            "connection exception while trying to forward request with action name [{}] to "
+                                                + "master node [{}], scheduling a retry. Error: [{}]",
+                                            actionName,
+                                            nodes.getClusterManagerNode(),
+                                            exp.getDetailedMessage()
+                                        );
+                                        retryOnMasterChange(clusterState, cause);
+                                    } else {
+                                        listener.onFailure(exp);
+                                    }
+                                }
+                            }
+                        );
+                    }
+                }
+            } catch (Exception e) {
+                listener.onFailure(e);
+            }
+        }
+
+        private void retryOnMasterChange(ProtobufClusterState state, Throwable failure) {
+            retry(state, failure, ClusterManagerNodeChangePredicate.buildProtobuf(state));
+        }
+
+        private void retry(ProtobufClusterState state, final Throwable failure, final Predicate<ProtobufClusterState> statePredicate) {
+            if (observer == null) {
+                final long remainingTimeoutMS = request.clusterManagerNodeTimeout().millis() - (threadPool.relativeTimeInMillis()
+                    - startTime);
+                if (remainingTimeoutMS <= 0) {
+                    logger.debug(() -> new ParameterizedMessage("timed out before retrying [{}] after failure", actionName), failure);
+                    listener.onFailure(new ClusterManagerNotDiscoveredException(failure));
+                    return;
+                }
+                this.observer = new ProtobufClusterStateObserver(
+                    state,
+                    clusterService,
+                    TimeValue.timeValueMillis(remainingTimeoutMS),
+                    logger,
+                    threadPool.getThreadContext()
+                );
+            }
+            observer.waitForNextChange(new ProtobufClusterStateObserver.Listener() {
+                @Override
+                public void onNewClusterState(ProtobufClusterState state) {
+                    doStart(state);
+                }
+
+                @Override
+                public void onClusterServiceClose() {
+                    listener.onFailure(new NodeClosedException(clusterService.localNode()));
+                }
+
+                @Override
+                public void onTimeout(TimeValue timeout) {
+                    logger.debug(
+                        () -> new ParameterizedMessage("timed out while retrying [{}] after failure (timeout [{}])", actionName, timeout),
+                        failure
+                    );
+                    listener.onFailure(new ClusterManagerNotDiscoveredException(failure));
+                }
+            }, statePredicate);
+        }
+    }
+
+    /**
+     * Allows to conditionally return a different cluster-manager node action name in the case an action gets renamed.
+     * This mainly for backwards compatibility should be used rarely
+     */
+    protected String getClusterManagerActionName(ProtobufDiscoveryNode node) {
+        return actionName;
+    }
+
+    /**
+     * Allows to conditionally return a different cluster-manager node action name in the case an action gets renamed.
+     * This mainly for backwards compatibility should be used rarely
+     *
+     * @deprecated As of 2.1, because supporting inclusive language, replaced by {@link #getClusterManagerActionName(ProtobufDiscoveryNode)}
+     */
+    @Deprecated
+    protected String getMasterActionName(ProtobufDiscoveryNode node) {
+        return getClusterManagerActionName(node);
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeReadAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeReadAction.java
new file mode 100644
index 0000000000000..18475a6ce6283
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeReadAction.java
@@ -0,0 +1,67 @@
+/*
+ * 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.
+ */
+
+package org.opensearch.action.support.clustermanager;
+
+import org.opensearch.action.ProtobufActionResponse;
+import org.opensearch.action.support.ProtobufActionFilters;
+import org.opensearch.cluster.metadata.ProtobufIndexNameExpressionResolver;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportService;
+
+/**
+ * A base class for read operations that needs to be performed on the cluster-manager node.
+ * Can also be executed on the local node if needed.
+ *
+ * @opensearch.internal
+ */
+public abstract class ProtobufTransportClusterManagerNodeReadAction<
+    Request extends ProtobufClusterManagerNodeReadRequest<Request>,
+    Response extends ProtobufActionResponse> extends ProtobufTransportClusterManagerNodeAction<Request, Response> {
+
+    protected ProtobufTransportClusterManagerNodeReadAction(
+        String actionName,
+        ProtobufTransportService transportService,
+        ClusterService clusterService,
+        ThreadPool threadPool,
+        ProtobufActionFilters actionFilters,
+        ProtobufWriteable.Reader<Request> request,
+        ProtobufIndexNameExpressionResolver indexNameExpressionResolver
+    ) {
+        this(actionName, true, transportService, clusterService, threadPool, actionFilters, request, indexNameExpressionResolver);
+    }
+
+    protected ProtobufTransportClusterManagerNodeReadAction(
+        String actionName,
+        boolean checkSizeLimit,
+        ProtobufTransportService transportService,
+        ClusterService clusterService,
+        ThreadPool threadPool,
+        ProtobufActionFilters actionFilters,
+        ProtobufWriteable.Reader<Request> request,
+        ProtobufIndexNameExpressionResolver indexNameExpressionResolver
+    ) {
+        super(
+            actionName,
+            checkSizeLimit,
+            transportService,
+            clusterService,
+            threadPool,
+            actionFilters,
+            request,
+            indexNameExpressionResolver
+        );
+    }
+
+    @Override
+    protected final boolean localExecute(Request request) {
+        return request.local();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
new file mode 100644
index 0000000000000..4b805811f49c2
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
@@ -0,0 +1,309 @@
+/*
+* 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.
+*/
+
+package org.opensearch.action.support.nodes;
+
+import com.google.protobuf.CodedInputStream;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.action.ActionListener;
+import org.opensearch.action.ActionRunnable;
+import org.opensearch.action.ProtobufFailedNodeException;
+import org.opensearch.action.support.ProtobufActionFilters;
+import org.opensearch.action.support.ProtobufHandledTransportAction;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.tasks.ProtobufTask;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.NodeShouldNotConnectException;
+import org.opensearch.transport.ProtobufTransportChannel;
+import org.opensearch.transport.ProtobufTransportException;
+import org.opensearch.transport.ProtobufTransportRequest;
+import org.opensearch.transport.ProtobufTransportRequestHandler;
+import org.opensearch.transport.TransportRequestOptions;
+import org.opensearch.transport.ProtobufTransportResponseHandler;
+import org.opensearch.transport.ProtobufTransportService;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReferenceArray;
+
+/**
+ * Base action class for transport nodes
+*
+* @opensearch.internal
+*/
+public abstract class ProtobufTransportNodesAction<
+    NodesRequest extends ProtobufBaseNodesRequest<NodesRequest>,
+    NodesResponse extends ProtobufBaseNodesResponse,
+    NodeRequest extends ProtobufTransportRequest,
+    NodeResponse extends ProtobufBaseNodeResponse> extends ProtobufHandledTransportAction<NodesRequest, NodesResponse> {
+
+    protected final ThreadPool threadPool;
+    protected final ClusterService clusterService;
+    protected final ProtobufTransportService transportService;
+    protected final Class<NodeResponse> nodeResponseClass;
+    protected final String transportNodeAction;
+
+    private final String finalExecutor;
+
+    /**
+     * @param actionName        action name
+    * @param threadPool        thread-pool
+    * @param clusterService    cluster service
+    * @param transportService  transport service
+    * @param actionFilters     action filters
+    * @param request           node request writer
+    * @param nodeRequest       node request reader
+    * @param nodeExecutor      executor to execute node action on
+    * @param finalExecutor     executor to execute final collection of all responses on
+    * @param nodeResponseClass class of the node responses
+    */
+    protected ProtobufTransportNodesAction(
+        String actionName,
+        ThreadPool threadPool,
+        ClusterService clusterService,
+        ProtobufTransportService transportService,
+        ProtobufActionFilters actionFilters,
+        ProtobufWriteable.Reader<NodesRequest> request,
+        ProtobufWriteable.Reader<NodeRequest> nodeRequest,
+        String nodeExecutor,
+        String finalExecutor,
+        Class<NodeResponse> nodeResponseClass
+    ) {
+        super(actionName, transportService, actionFilters, request);
+        this.threadPool = threadPool;
+        this.clusterService = Objects.requireNonNull(clusterService);
+        this.transportService = Objects.requireNonNull(transportService);
+        this.nodeResponseClass = Objects.requireNonNull(nodeResponseClass);
+
+        this.transportNodeAction = actionName + "[n]";
+        this.finalExecutor = finalExecutor;
+        transportService.registerRequestHandler(transportNodeAction, nodeExecutor, nodeRequest, new NodeTransportHandler());
+    }
+
+    /**
+     * Same as {@link #ProtobufTransportNodesAction(String, ThreadPool, ClusterService, ProtobufTransportService, ProtobufActionFilters, ProtobufWriteable.Reader,
+    * ProtobufWriteable.Reader, String, String, Class)} but executes final response collection on the transport thread except for when the final
+    * node response is received from the local node, in which case {@code nodeExecutor} is used.
+    * This constructor should only be used for actions for which the creation of the final response is fast enough to be safely executed
+    * on a transport thread.
+    */
+    protected ProtobufTransportNodesAction(
+        String actionName,
+        ThreadPool threadPool,
+        ClusterService clusterService,
+        ProtobufTransportService transportService,
+        ProtobufActionFilters actionFilters,
+        ProtobufWriteable.Reader<NodesRequest> request,
+        ProtobufWriteable.Reader<NodeRequest> nodeRequest,
+        String nodeExecutor,
+        Class<NodeResponse> nodeResponseClass
+    ) {
+        this(
+            actionName,
+            threadPool,
+            clusterService,
+            transportService,
+            actionFilters,
+            request,
+            nodeRequest,
+            nodeExecutor,
+            ThreadPool.Names.SAME,
+            nodeResponseClass
+        );
+    }
+
+    @Override
+    protected void doExecute(ProtobufTask task, NodesRequest request, ActionListener<NodesResponse> listener) {
+        new AsyncAction(task, request, listener).start();
+    }
+
+    /**
+     * Map the responses into {@code nodeResponseClass} responses and {@link ProtobufFailedNodeException}s.
+    *
+    * @param request The associated request.
+    * @param nodesResponses All node-level responses
+    * @return Never {@code null}.
+    * @throws NullPointerException if {@code nodesResponses} is {@code null}
+    * @see #newResponse(ProtobufBaseNodesRequest, List, List)
+    */
+    protected NodesResponse newResponse(NodesRequest request, AtomicReferenceArray<?> nodesResponses) {
+        final List<NodeResponse> responses = new ArrayList<>();
+        final List<ProtobufFailedNodeException> failures = new ArrayList<>();
+
+        for (int i = 0; i < nodesResponses.length(); ++i) {
+            Object response = nodesResponses.get(i);
+
+            if (response instanceof ProtobufFailedNodeException) {
+                failures.add((ProtobufFailedNodeException) response);
+            } else {
+                responses.add(nodeResponseClass.cast(response));
+            }
+        }
+
+        return newResponse(request, responses, failures);
+    }
+
+    /**
+     * Create a new {@link NodesResponse} (multi-node response).
+    *
+    * @param request The associated request.
+    * @param responses All successful node-level responses.
+    * @param failures All node-level failures.
+    * @return Never {@code null}.
+    * @throws NullPointerException if any parameter is {@code null}.
+    */
+    protected abstract NodesResponse newResponse(NodesRequest request, List<NodeResponse> responses, List<ProtobufFailedNodeException> failures);
+
+    protected abstract NodeRequest newNodeRequest(NodesRequest request);
+
+    protected abstract NodeResponse newNodeResponse(CodedInputStream in) throws IOException;
+
+    protected abstract NodeResponse nodeOperation(NodeRequest request);
+
+    protected NodeResponse nodeOperation(NodeRequest request, ProtobufTask task) {
+        return nodeOperation(request);
+    }
+
+    /**
+     * resolve node ids to concrete nodes of the incoming request
+    **/
+    protected void resolveRequest(NodesRequest request, ClusterState clusterState) {
+        assert request.concreteNodes() == null : "request concreteNodes shouldn't be set";
+        String[] nodesIds = clusterState.nodes().resolveNodes(request.nodesIds());
+        request.setConcreteNodes(Arrays.stream(nodesIds).map(clusterState.nodes()::get).toArray(ProtobufDiscoveryNode[]::new));
+    }
+
+    /**
+     * Get a backwards compatible transport action name
+    */
+    protected String getTransportNodeAction(ProtobufDiscoveryNode node) {
+        return transportNodeAction;
+    }
+
+    /**
+     * Asynchronous action
+    *
+    * @opensearch.internal
+    */
+    class AsyncAction {
+
+        private final NodesRequest request;
+        private final ActionListener<NodesResponse> listener;
+        private final AtomicReferenceArray<Object> responses;
+        private final AtomicInteger counter = new AtomicInteger();
+        private final ProtobufTask task;
+
+        AsyncAction(ProtobufTask task, NodesRequest request, ActionListener<NodesResponse> listener) {
+            this.task = task;
+            this.request = request;
+            this.listener = listener;
+            if (request.concreteNodes() == null) {
+                resolveRequest(request, clusterService.state());
+                assert request.concreteNodes() != null;
+            }
+            this.responses = new AtomicReferenceArray<>(request.concreteNodes().length);
+        }
+
+        void start() {
+            final ProtobufDiscoveryNode[] nodes = request.concreteNodes();
+            if (nodes.length == 0) {
+                // nothing to notify
+                threadPool.generic().execute(() -> listener.onResponse(newResponse(request, responses)));
+                return;
+            }
+            TransportRequestOptions.Builder builder = TransportRequestOptions.builder();
+            if (request.timeout() != null) {
+                builder.withTimeout(request.timeout());
+            }
+            for (int i = 0; i < nodes.length; i++) {
+                final int idx = i;
+                final ProtobufDiscoveryNode node = nodes[i];
+                final String nodeId = node.getId();
+                try {
+                    ProtobufTransportRequest nodeRequest = newNodeRequest(request);
+                    if (task != null) {
+                        nodeRequest.setParentTask(clusterService.localNode().getId(), task.getId());
+                    }
+
+                    transportService.sendRequest(
+                        node,
+                        getTransportNodeAction(node),
+                        nodeRequest,
+                        builder.build(),
+                        new ProtobufTransportResponseHandler<NodeResponse>() {
+                            @Override
+                            public NodeResponse read(CodedInputStream in) throws IOException {
+                                return newNodeResponse(in);
+                            }
+
+                            @Override
+                            public void handleResponse(NodeResponse response) {
+                                onOperation(idx, response);
+                            }
+
+                            @Override
+                            public void handleException(ProtobufTransportException exp) {
+                                onFailure(idx, node.getId(), exp);
+                            }
+
+                            @Override
+                            public String executor() {
+                                return ThreadPool.Names.SAME;
+                            }
+                        }
+                    );
+                } catch (Exception e) {
+                    onFailure(idx, nodeId, e);
+                }
+            }
+        }
+
+        private void onOperation(int idx, NodeResponse nodeResponse) {
+            responses.set(idx, nodeResponse);
+            if (counter.incrementAndGet() == responses.length()) {
+                finishHim();
+            }
+        }
+
+        private void onFailure(int idx, String nodeId, Throwable t) {
+            if (logger.isDebugEnabled() && !(t instanceof NodeShouldNotConnectException)) {
+                logger.debug(new ParameterizedMessage("failed to execute on node [{}]", nodeId), t);
+            }
+            responses.set(idx, new ProtobufFailedNodeException(nodeId, "Failed node [" + nodeId + "]", t));
+            if (counter.incrementAndGet() == responses.length()) {
+                finishHim();
+            }
+        }
+
+        private void finishHim() {
+            threadPool.executor(finalExecutor).execute(ActionRunnable.supply(listener, () -> newResponse(request, responses)));
+        }
+    }
+
+    /**
+     * A node transport handler
+    *
+    * @opensearch.internal
+    */
+    class NodeTransportHandler implements ProtobufTransportRequestHandler<NodeRequest> {
+
+        @Override
+        public void messageReceived(NodeRequest request, ProtobufTransportChannel channel, ProtobufTask task) throws Exception {
+            channel.sendResponse(nodeOperation(request, task));
+        }
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/client/ProtobufFilterClient.java b/server/src/main/java/org/opensearch/client/ProtobufFilterClient.java
index d5bbd47379070..f4e76450f679a 100644
--- a/server/src/main/java/org/opensearch/client/ProtobufFilterClient.java
+++ b/server/src/main/java/org/opensearch/client/ProtobufFilterClient.java
@@ -14,7 +14,7 @@
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.client.support.ProtobufAbstractClient;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.threadpool.ThreadPool;
 
 /**
  * A {@link ProtobufClient} that contains another {@link ProtobufClient} which it
@@ -41,7 +41,7 @@ public ProtobufFilterClient(ProtobufClient in) {
      * A Constructor that allows to pass settings and threadpool separately. This is useful if the
     * client is a proxy and not yet fully constructed ie. both dependencies are not available yet.
     */
-    protected ProtobufFilterClient(Settings settings, ProtobufThreadPool threadPool, ProtobufClient in) {
+    protected ProtobufFilterClient(Settings settings, ThreadPool threadPool, ProtobufClient in) {
         super(settings, threadPool);
         this.in = in;
     }
diff --git a/server/src/main/java/org/opensearch/client/ProtobufOpenSearchClient.java b/server/src/main/java/org/opensearch/client/ProtobufOpenSearchClient.java
index a521ae469deed..2db9f9c93e940 100644
--- a/server/src/main/java/org/opensearch/client/ProtobufOpenSearchClient.java
+++ b/server/src/main/java/org/opensearch/client/ProtobufOpenSearchClient.java
@@ -13,7 +13,7 @@
 import org.opensearch.action.ProtobufActionType;
 import org.opensearch.action.ActionFuture;
 import org.opensearch.action.ActionListener;
-import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.threadpool.ThreadPool;
 
 /**
  * Interface for an OpenSearch client implementation
@@ -54,6 +54,6 @@ <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse>
     /**
      * Returns the threadpool used to execute requests on this client
     */
-    ProtobufThreadPool threadPool();
+    ThreadPool threadPool();
 
 }
diff --git a/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java b/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java
index 0602740a0e304..b5d729b59cb82 100644
--- a/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java
+++ b/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java
@@ -18,12 +18,12 @@
 import org.opensearch.client.ProtobufClient;
 import org.opensearch.client.support.ProtobufAbstractClient;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.common.io.stream.ProtobufNamedWriteableRegistry;
+import org.opensearch.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.tasks.ProtobufTask;
 import org.opensearch.tasks.ProtobufTaskListener;
-import org.opensearch.threadpool.ProtobufThreadPool;
-import org.opensearch.transport.ProtobufRemoteClusterService;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.RemoteClusterService;
 
 import java.util.function.Supplier;
 
@@ -40,18 +40,18 @@ public class ProtobufNodeClient extends ProtobufAbstractClient {
     * {@link #executeLocally(ProtobufActionType, ProtobufActionRequest, ProtobufTaskListener)}.
     */
     private Supplier<String> localNodeId;
-    private ProtobufRemoteClusterService remoteClusterService;
-    private ProtobufNamedWriteableRegistry namedWriteableRegistry;
+    private RemoteClusterService remoteClusterService;
+    private NamedWriteableRegistry namedWriteableRegistry;
 
-    public ProtobufNodeClient(Settings settings, ProtobufThreadPool threadPool) {
+    public ProtobufNodeClient(Settings settings, ThreadPool threadPool) {
         super(settings, threadPool);
     }
 
     public void initialize(
         ProtobufDynamicActionRegistry actionRegistry,
         Supplier<String> localNodeId,
-        ProtobufRemoteClusterService remoteClusterService,
-        ProtobufNamedWriteableRegistry namedWriteableRegistry
+        RemoteClusterService remoteClusterService,
+        NamedWriteableRegistry namedWriteableRegistry
     ) {
         this.actionRegistry = actionRegistry;
         this.localNodeId = localNodeId;
@@ -130,10 +130,10 @@ Response extends ProtobufActionResponse> ProtobufTransportAction<Request, Respon
 
     @Override
     public ProtobufClient getRemoteClusterClient(String clusterAlias) {
-        return remoteClusterService.getRemoteClusterClient(threadPool(), clusterAlias);
+        return remoteClusterService.getRemoteClusterClientProtobuf(threadPool(), clusterAlias);
     }
 
-    public ProtobufNamedWriteableRegistry getNamedWriteableRegistry() {
+    public NamedWriteableRegistry getNamedWriteableRegistry() {
         return namedWriteableRegistry;
     }
 }
diff --git a/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java b/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
index ae47220331874..0ed6bc96ef3d2 100644
--- a/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
+++ b/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
@@ -35,7 +35,7 @@
 import org.opensearch.client.ProtobufOpenSearchClient;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.threadpool.ThreadPool;
 
 import java.util.Map;
 
@@ -49,10 +49,10 @@ public abstract class ProtobufAbstractClient implements ProtobufClient {
     protected final Logger logger;
 
     protected final Settings settings;
-    private final ProtobufThreadPool threadPool;
+    private final ThreadPool threadPool;
     private final Admin admin;
 
-    public ProtobufAbstractClient(Settings settings, ProtobufThreadPool threadPool) {
+    public ProtobufAbstractClient(Settings settings, ThreadPool threadPool) {
         this.settings = settings;
         this.threadPool = threadPool;
         this.admin = new Admin(this);
@@ -65,7 +65,7 @@ public final Settings settings() {
     }
 
     @Override
-    public final ProtobufThreadPool threadPool() {
+    public final ThreadPool threadPool() {
         return this.threadPool;
     }
 
@@ -125,7 +125,7 @@ static class ClusterAdmin implements ProtobufClusterAdminClient {
         }
 
         @Override
-        public ProtobufThreadPool threadPool() {
+        public ThreadPool threadPool() {
             return client.threadPool();
         }
 
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterManagerNodeChangePredicate.java b/server/src/main/java/org/opensearch/cluster/ClusterManagerNodeChangePredicate.java
index b5c65dacb9542..13127640beb4f 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterManagerNodeChangePredicate.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterManagerNodeChangePredicate.java
@@ -33,6 +33,7 @@
 package org.opensearch.cluster;
 
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
 
 import java.util.function.Predicate;
 
@@ -68,4 +69,26 @@ public static Predicate<ClusterState> build(ClusterState currentState) {
             return accept;
         };
     }
+
+    /**
+     * builds a predicate that will accept a cluster state only if it was generated after the current has
+     * (re-)joined the master
+     */
+    public static Predicate<ProtobufClusterState> buildProtobuf(ProtobufClusterState currentState) {
+        final long currentVersion = currentState.version();
+        final ProtobufDiscoveryNode clusterManagerNode = currentState.nodes().getClusterManagerNode();
+        final String currentMasterId = clusterManagerNode == null ? null : clusterManagerNode.getEphemeralId();
+        return newState -> {
+            final ProtobufDiscoveryNode newClusterManager = newState.nodes().getClusterManagerNode();
+            final boolean accept;
+            if (newClusterManager == null) {
+                accept = false;
+            } else if (newClusterManager.getEphemeralId().equals(currentMasterId) == false) {
+                accept = true;
+            } else {
+                accept = newState.version() > currentVersion;
+            }
+            return accept;
+        };
+    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterModule.java b/server/src/main/java/org/opensearch/cluster/ClusterModule.java
index b80fd1d746831..d6c84eab5213b 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterModule.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterModule.java
@@ -41,6 +41,7 @@
 import org.opensearch.cluster.metadata.DataStreamMetadata;
 import org.opensearch.cluster.metadata.IndexGraveyard;
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
+import org.opensearch.cluster.metadata.ProtobufIndexNameExpressionResolver;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.metadata.MetadataDeleteIndexService;
 import org.opensearch.cluster.metadata.MetadataIndexAliasesService;
@@ -129,6 +130,7 @@ public class ClusterModule extends AbstractModule {
 
     private final ClusterService clusterService;
     private final IndexNameExpressionResolver indexNameExpressionResolver;
+    private final ProtobufIndexNameExpressionResolver protobufIndexNameExpressionResolver;
     private final AllocationDeciders allocationDeciders;
     private final AllocationService allocationService;
     private final List<ClusterPlugin> clusterPlugins;
@@ -150,6 +152,7 @@ public ClusterModule(
         this.shardsAllocator = createShardsAllocator(settings, clusterService.getClusterSettings(), clusterPlugins);
         this.clusterService = clusterService;
         this.indexNameExpressionResolver = new IndexNameExpressionResolver(threadContext);
+        this.protobufIndexNameExpressionResolver = new ProtobufIndexNameExpressionResolver(threadContext);
         this.allocationService = new AllocationService(allocationDeciders, shardsAllocator, clusterInfoService, snapshotsInfoService);
     }
 
@@ -342,6 +345,10 @@ public IndexNameExpressionResolver getIndexNameExpressionResolver() {
         return indexNameExpressionResolver;
     }
 
+    public ProtobufIndexNameExpressionResolver getProtobufIndexNameExpressionResolver() {
+        return protobufIndexNameExpressionResolver;
+    }
+
     // TODO: this is public so allocation benchmark can access the default deciders...can we do that in another way?
     /** Return a new {@link AllocationDecider} instance with builtin deciders as well as those from plugins. */
     public static Collection<AllocationDecider> createAllocationDeciders(
@@ -425,6 +432,7 @@ protected void configure() {
         bind(MetadataUpdateSettingsService.class).asEagerSingleton();
         bind(MetadataIndexTemplateService.class).asEagerSingleton();
         bind(IndexNameExpressionResolver.class).toInstance(indexNameExpressionResolver);
+        bind(ProtobufIndexNameExpressionResolver.class).toInstance(protobufIndexNameExpressionResolver);
         bind(DelayedAllocationService.class).asEagerSingleton();
         bind(ShardStateAction.class).asEagerSingleton();
         bind(NodeMappingRefreshAction.class).asEagerSingleton();
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateApplier.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateApplier.java
index 3169688ba9b3e..3d502f396c0c6 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateApplier.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateApplier.java
@@ -25,5 +25,5 @@ public interface ProtobufClusterStateApplier {
     * reached all the other appliers, and will likely result in another attempt to apply the same (or very similar) cluster state which
     * might continue until this node is removed from the cluster.
     */
-    void applyClusterState(ProtobufClusterChangedEvent event);
+    void applyProtobufClusterState(ProtobufClusterChangedEvent event);
 }
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateListener.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateListener.java
new file mode 100644
index 0000000000000..b5638d6de0611
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateListener.java
@@ -0,0 +1,22 @@
+/*
+ * 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.
+ */
+
+package org.opensearch.cluster;
+
+/**
+ * A listener to be notified when a cluster state changes.
+ *
+ * @opensearch.internal
+ */
+public interface ProtobufClusterStateListener {
+
+    /**
+     * Called when cluster state changes.
+     */
+    void clusterChanged(ProtobufClusterChangedEvent event);
+}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateObserver.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateObserver.java
new file mode 100644
index 0000000000000..828d181b37a09
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateObserver.java
@@ -0,0 +1,379 @@
+/*
+ * 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.
+ */
+
+package org.opensearch.cluster;
+
+import org.apache.logging.log4j.Logger;
+import org.opensearch.OpenSearchException;
+import org.opensearch.cluster.service.ClusterApplierService;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+/**
+ * A utility class which simplifies interacting with the cluster state in cases where
+ * one tries to take action based on the current state but may want to wait for a new state
+ * and retry upon failure.
+ *
+ * @opensearch.internal
+ */
+public class ProtobufClusterStateObserver {
+
+    protected final Logger logger;
+
+    private final Predicate<ProtobufClusterState> MATCH_ALL_CHANGES_PREDICATE = state -> true;
+
+    private final ClusterApplierService clusterApplierService;
+    private final ThreadPool threadPool;
+    private final ThreadContext contextHolder;
+    volatile TimeValue timeOutValue;
+
+    final AtomicReference<StoredState> lastObservedState;
+    final ProtobufTimeoutClusterStateListener clusterStateListener = new ObserverClusterStateListener();
+    // observingContext is not null when waiting on cluster state changes
+    final AtomicReference<ObservingContext> observingContext = new AtomicReference<>(null);
+    volatile Long startTimeMS;
+    volatile boolean timedOut;
+
+    public ProtobufClusterStateObserver(ClusterService clusterService, Logger logger, ThreadContext contextHolder) {
+        this(clusterService, new TimeValue(60000), logger, contextHolder);
+    }
+
+    /**
+     * @param timeout        a global timeout for this observer. After it has expired the observer
+     *                       will fail any existing or new #waitForNextChange calls. Set to null
+     *                       to wait indefinitely
+     */
+    public ProtobufClusterStateObserver(ClusterService clusterService, @Nullable TimeValue timeout, Logger logger, ThreadContext contextHolder) {
+        this(clusterService.protobufState(), clusterService, timeout, logger, contextHolder);
+    }
+
+    /**
+     * @param timeout        a global timeout for this observer. After it has expired the observer
+     *                       will fail any existing or new #waitForNextChange calls. Set to null
+     *                       to wait indefinitely
+     */
+    public ProtobufClusterStateObserver(
+        ProtobufClusterState initialState,
+        ClusterService clusterService,
+        @Nullable TimeValue timeout,
+        Logger logger,
+        ThreadContext contextHolder
+    ) {
+        this(initialState, clusterService.getClusterApplierService(), timeout, logger, contextHolder);
+    }
+
+    public ProtobufClusterStateObserver(
+        ProtobufClusterState initialState,
+        ClusterApplierService clusterApplierService,
+        @Nullable TimeValue timeout,
+        Logger logger,
+        ThreadContext contextHolder
+    ) {
+        this.clusterApplierService = clusterApplierService;
+        this.threadPool = clusterApplierService.threadPool();
+        this.lastObservedState = new AtomicReference<>(new StoredState(initialState));
+        this.timeOutValue = timeout;
+        if (timeOutValue != null) {
+            this.startTimeMS = threadPool.relativeTimeInMillis();
+        }
+        this.logger = logger;
+        this.contextHolder = contextHolder;
+    }
+
+    /** sets the last observed state to the currently applied cluster state and returns it */
+    public ProtobufClusterState setAndGetObservedState() {
+        if (observingContext.get() != null) {
+            throw new OpenSearchException("cannot set current cluster state while waiting for a cluster state change");
+        }
+        ProtobufClusterState clusterState = clusterApplierService.protobufState();
+        lastObservedState.set(new StoredState(clusterState));
+        return clusterState;
+    }
+
+    /** indicates whether this observer has timed out */
+    public boolean isTimedOut() {
+        return timedOut;
+    }
+
+    public void waitForNextChange(Listener listener) {
+        waitForNextChange(listener, MATCH_ALL_CHANGES_PREDICATE);
+    }
+
+    public void waitForNextChange(Listener listener, @Nullable TimeValue timeOutValue) {
+        waitForNextChange(listener, MATCH_ALL_CHANGES_PREDICATE, timeOutValue);
+    }
+
+    public void waitForNextChange(Listener listener, Predicate<ProtobufClusterState> statePredicate) {
+        waitForNextChange(listener, statePredicate, null);
+    }
+
+    /**
+     * Wait for the next cluster state which satisfies statePredicate
+     *
+     * @param listener        callback listener
+     * @param statePredicate predicate to check whether cluster state changes are relevant and the callback should be called
+     * @param timeOutValue    a timeout for waiting. If null the global observer timeout will be used.
+     */
+    public void waitForNextChange(Listener listener, Predicate<ProtobufClusterState> statePredicate, @Nullable TimeValue timeOutValue) {
+        listener = new ContextPreservingListener(listener, contextHolder.newRestorableContext(false));
+        if (observingContext.get() != null) {
+            throw new OpenSearchException("already waiting for a cluster state change");
+        }
+
+        Long timeoutTimeLeftMS;
+        if (timeOutValue == null) {
+            timeOutValue = this.timeOutValue;
+            if (timeOutValue != null) {
+                long timeSinceStartMS = threadPool.relativeTimeInMillis() - startTimeMS;
+                timeoutTimeLeftMS = timeOutValue.millis() - timeSinceStartMS;
+                if (timeoutTimeLeftMS <= 0L) {
+                    // things have timeout while we were busy -> notify
+                    logger.trace(
+                        "observer timed out. notifying listener. timeout setting [{}], time since start [{}]",
+                        timeOutValue,
+                        new TimeValue(timeSinceStartMS)
+                    );
+                    // update to latest, in case people want to retry
+                    timedOut = true;
+                    lastObservedState.set(new StoredState(clusterApplierService.protobufState()));
+                    listener.onTimeout(timeOutValue);
+                    return;
+                }
+            } else {
+                timeoutTimeLeftMS = null;
+            }
+        } else {
+            this.startTimeMS = threadPool.relativeTimeInMillis();
+            this.timeOutValue = timeOutValue;
+            timeoutTimeLeftMS = timeOutValue.millis();
+            timedOut = false;
+        }
+
+        // sample a new state. This state maybe *older* than the supplied state if we are called from an applier,
+        // which wants to wait for something else to happen
+        ProtobufClusterState newState = clusterApplierService.protobufState();
+        if (lastObservedState.get().isOlderOrDifferentClusterManager(newState) && statePredicate.test(newState)) {
+            // good enough, let's go.
+            logger.trace("observer: sampled state accepted by predicate ({})", newState);
+            lastObservedState.set(new StoredState(newState));
+            listener.onNewClusterState(newState);
+        } else {
+            logger.trace("observer: sampled state rejected by predicate ({}). adding listener to ClusterService", newState);
+            final ObservingContext context = new ObservingContext(listener, statePredicate);
+            if (!observingContext.compareAndSet(null, context)) {
+                throw new OpenSearchException("already waiting for a cluster state change");
+            }
+            // clusterApplierService.addTimeoutListener(
+            //     timeoutTimeLeftMS == null ? null : new TimeValue(timeoutTimeLeftMS),
+            //     clusterStateListener
+            // );
+        }
+    }
+
+    /**
+     * An observer of the cluster state for changes.
+     *
+     * @opensearch.internal
+     */
+    class ObserverClusterStateListener implements ProtobufTimeoutClusterStateListener {
+
+        @Override
+        public void clusterChanged(ProtobufClusterChangedEvent event) {
+            ObservingContext context = observingContext.get();
+            if (context == null) {
+                // No need to remove listener as it is the responsibility of the thread that set observingContext to null
+                return;
+            }
+            final ProtobufClusterState state = event.state();
+            if (context.statePredicate.test(state)) {
+                if (observingContext.compareAndSet(context, null)) {
+                    // clusterApplierService.removeTimeoutListener(this);
+                    logger.trace("observer: accepting cluster state change ({})", state);
+                    lastObservedState.set(new StoredState(state));
+                    context.listener.onNewClusterState(state);
+                } else {
+                    logger.trace(
+                        "observer: predicate approved change but observing context has changed "
+                            + "- ignoring (new cluster state version [{}])",
+                        state.version()
+                    );
+                }
+            } else {
+                logger.trace("observer: predicate rejected change (new cluster state version [{}])", state.version());
+            }
+        }
+
+        @Override
+        public void postAdded() {
+            ObservingContext context = observingContext.get();
+            if (context == null) {
+                // No need to remove listener as it is the responsibility of the thread that set observingContext to null
+                return;
+            }
+            ProtobufClusterState newState = clusterApplierService.protobufState();
+            if (lastObservedState.get().isOlderOrDifferentClusterManager(newState) && context.statePredicate.test(newState)) {
+                // double check we're still listening
+                if (observingContext.compareAndSet(context, null)) {
+                    logger.trace("observer: post adding listener: accepting current cluster state ({})", newState);
+                    // clusterApplierService.removeTimeoutListener(this);
+                    lastObservedState.set(new StoredState(newState));
+                    context.listener.onNewClusterState(newState);
+                } else {
+                    logger.trace(
+                        "observer: postAdded - predicate approved state but observing context has changed - ignoring ({})",
+                        newState
+                    );
+                }
+            } else {
+                logger.trace("observer: postAdded - predicate rejected state ({})", newState);
+            }
+        }
+
+        @Override
+        public void onClose() {
+            ObservingContext context = observingContext.getAndSet(null);
+
+            if (context != null) {
+                logger.trace("observer: cluster service closed. notifying listener.");
+                // clusterApplierService.removeTimeoutListener(this);
+                context.listener.onClusterServiceClose();
+            }
+        }
+
+        @Override
+        public void onTimeout(TimeValue timeout) {
+            ObservingContext context = observingContext.getAndSet(null);
+            if (context != null) {
+                // clusterApplierService.removeTimeoutListener(this);
+                long timeSinceStartMS = threadPool.relativeTimeInMillis() - startTimeMS;
+                logger.trace(
+                    "observer: timeout notification from cluster service. timeout setting [{}], time since start [{}]",
+                    timeOutValue,
+                    new TimeValue(timeSinceStartMS)
+                );
+                // update to latest, in case people want to retry
+                lastObservedState.set(new StoredState(clusterApplierService.protobufState()));
+                timedOut = true;
+                context.listener.onTimeout(timeOutValue);
+            }
+        }
+
+        @Override
+        public String toString() {
+            return "ProtobufClusterStateObserver[" + observingContext.get() + "]";
+        }
+    }
+
+    /**
+     * The observer considers two cluster states to be the same if they have the same version and cluster-manager node id (i.e. null or set)
+     *
+     * @opensearch.internal
+     */
+    private static class StoredState {
+        private final String clusterManagerNodeId;
+        private final long version;
+
+        StoredState(ProtobufClusterState clusterState) {
+            this.clusterManagerNodeId = clusterState.nodes().getClusterManagerNodeId();
+            this.version = clusterState.version();
+        }
+
+        /**
+         * returns true if stored state is older then given state or they are from a different cluster-manager, meaning they can't be compared
+         * */
+        public boolean isOlderOrDifferentClusterManager(ProtobufClusterState clusterState) {
+            return version < clusterState.version()
+                || Objects.equals(clusterManagerNodeId, clusterState.nodes().getClusterManagerNodeId()) == false;
+        }
+    }
+
+    /**
+     * Listener for the observer.
+     *
+     * @opensearch.internal
+     */
+    public interface Listener {
+
+        /** called when a new state is observed */
+        void onNewClusterState(ProtobufClusterState state);
+
+        /** called when the cluster service is closed */
+        void onClusterServiceClose();
+
+        void onTimeout(TimeValue timeout);
+    }
+
+    /**
+     * Context for the observer.
+     *
+     * @opensearch.internal
+     */
+    static class ObservingContext {
+        public final Listener listener;
+        public final Predicate<ProtobufClusterState> statePredicate;
+
+        ObservingContext(Listener listener, Predicate<ProtobufClusterState> statePredicate) {
+            this.listener = listener;
+            this.statePredicate = statePredicate;
+        }
+
+        @Override
+        public String toString() {
+            return "ObservingContext[" + listener + "]";
+        }
+    }
+
+    /**
+     * A context preserving listener.
+     *
+     * @opensearch.internal
+     */
+    private static final class ContextPreservingListener implements Listener {
+        private final Listener delegate;
+        private final Supplier<ThreadContext.StoredContext> contextSupplier;
+
+        private ContextPreservingListener(Listener delegate, Supplier<ThreadContext.StoredContext> contextSupplier) {
+            this.contextSupplier = contextSupplier;
+            this.delegate = delegate;
+        }
+
+        @Override
+        public void onNewClusterState(ProtobufClusterState state) {
+            try (ThreadContext.StoredContext context = contextSupplier.get()) {
+                delegate.onNewClusterState(state);
+            }
+        }
+
+        @Override
+        public void onClusterServiceClose() {
+            try (ThreadContext.StoredContext context = contextSupplier.get()) {
+                delegate.onClusterServiceClose();
+            }
+        }
+
+        @Override
+        public void onTimeout(TimeValue timeout) {
+            try (ThreadContext.StoredContext context = contextSupplier.get()) {
+                delegate.onTimeout(timeout);
+            }
+        }
+
+        @Override
+        public String toString() {
+            return "ContextPreservingListener[" + delegate + "]";
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufTimeoutClusterStateListener.java b/server/src/main/java/org/opensearch/cluster/ProtobufTimeoutClusterStateListener.java
new file mode 100644
index 0000000000000..99ce33a6a71e6
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufTimeoutClusterStateListener.java
@@ -0,0 +1,49 @@
+/*
+ * 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.cluster;
+
+import org.opensearch.common.unit.TimeValue;
+
+/**
+ * An exception to cluster state listener that allows for timeouts and for post added notifications.
+ *
+ * @opensearch.internal
+ */
+public interface ProtobufTimeoutClusterStateListener extends ProtobufClusterStateListener {
+
+    void postAdded();
+
+    void onClose();
+
+    void onTimeout(TimeValue timeout);
+}
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/ProtobufIndexNameExpressionResolver.java b/server/src/main/java/org/opensearch/cluster/metadata/ProtobufIndexNameExpressionResolver.java
new file mode 100644
index 0000000000000..dbb1bc319575d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/metadata/ProtobufIndexNameExpressionResolver.java
@@ -0,0 +1,1342 @@
+/*
+ * 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.
+ */
+
+
+package org.opensearch.cluster.metadata;
+
+import org.opensearch.OpenSearchParseException;
+import org.opensearch.action.IndicesRequest;
+import org.opensearch.action.support.IndicesOptions;
+import org.opensearch.cluster.ProtobufClusterState;
+import org.opensearch.common.Booleans;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.Strings;
+import org.opensearch.common.collect.ImmutableOpenMap;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.logging.DeprecationLogger;
+import org.opensearch.common.regex.Regex;
+import org.opensearch.common.time.DateFormatter;
+import org.opensearch.common.time.DateMathParser;
+import org.opensearch.common.time.DateUtils;
+import org.opensearch.common.util.CollectionUtils;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.util.set.Sets;
+import org.opensearch.index.Index;
+import org.opensearch.index.IndexNotFoundException;
+import org.opensearch.indices.IndexClosedException;
+import org.opensearch.indices.InvalidIndexNameException;
+
+import java.time.Instant;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.SortedMap;
+import java.util.Spliterators;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+/**
+ * Resolves index name from an expression
+ *
+ * @opensearch.internal
+ */
+public class ProtobufIndexNameExpressionResolver {
+    private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(ProtobufIndexNameExpressionResolver.class);
+
+    public static final String EXCLUDED_DATA_STREAMS_KEY = "opensearch.excluded_ds";
+    public static final String SYSTEM_INDEX_ACCESS_CONTROL_HEADER_KEY = "_system_index_access_allowed";
+
+    private final DateMathExpressionResolver dateMathExpressionResolver = new DateMathExpressionResolver();
+    private final WildcardExpressionResolver wildcardExpressionResolver = new WildcardExpressionResolver();
+    private final List<ExpressionResolver> expressionResolvers = List.of(dateMathExpressionResolver, wildcardExpressionResolver);
+
+    private final ThreadContext threadContext;
+
+    public ProtobufIndexNameExpressionResolver(ThreadContext threadContext) {
+        this.threadContext = Objects.requireNonNull(threadContext, "Thread Context must not be null");
+    }
+
+    /**
+     * Same as {@link #concreteIndexNames(ProtobufClusterState, IndicesOptions, String...)}, but the index expressions and options
+     * are encapsulated in the specified request.
+     */
+    public String[] concreteIndexNames(ProtobufClusterState state, IndicesRequest request) {
+        Context context = new Context(
+            state,
+            request.indicesOptions(),
+            false,
+            false,
+            request.includeDataStreams(),
+            isSystemIndexAccessAllowed()
+        );
+        return concreteIndexNames(context, request.indices());
+    }
+
+    /**
+     * Same as {@link #concreteIndexNames(ProtobufClusterState, IndicesRequest)}, but access to system indices is always allowed.
+     */
+    public String[] concreteIndexNamesWithSystemIndexAccess(ProtobufClusterState state, IndicesRequest request) {
+        Context context = new Context(state, request.indicesOptions(), false, false, request.includeDataStreams(), true);
+        return concreteIndexNames(context, request.indices());
+    }
+
+    /**
+     * Same as {@link #concreteIndices(ProtobufClusterState, IndicesOptions, String...)}, but the index expressions and options
+     * are encapsulated in the specified request and resolves data streams.
+     */
+    public Index[] concreteIndices(ProtobufClusterState state, IndicesRequest request) {
+        Context context = new Context(
+            state,
+            request.indicesOptions(),
+            false,
+            false,
+            request.includeDataStreams(),
+            isSystemIndexAccessAllowed()
+        );
+        return concreteIndices(context, request.indices());
+    }
+
+    /**
+     * Translates the provided index expression into actual concrete indices, properly deduplicated.
+     *
+     * @param state             the cluster state containing all the data to resolve to expressions to concrete indices
+     * @param options           defines how the aliases or indices need to be resolved to concrete indices
+     * @param indexExpressions  expressions that can be resolved to alias or index names.
+     * @return the resolved concrete indices based on the cluster state, indices options and index expressions
+     * @throws IndexNotFoundException if one of the index expressions is pointing to a missing index or alias and the
+     * provided indices options in the context don't allow such a case, or if the final result of the indices resolution
+     * contains no indices and the indices options in the context don't allow such a case.
+     * @throws IllegalArgumentException if one of the aliases resolve to multiple indices and the provided
+     * indices options in the context don't allow such a case.
+     */
+    public String[] concreteIndexNames(ProtobufClusterState state, IndicesOptions options, String... indexExpressions) {
+        Context context = new Context(state, options, isSystemIndexAccessAllowed());
+        return concreteIndexNames(context, indexExpressions);
+    }
+
+    public String[] concreteIndexNames(ProtobufClusterState state, IndicesOptions options, boolean includeDataStreams, String... indexExpressions) {
+        Context context = new Context(state, options, false, false, includeDataStreams, isSystemIndexAccessAllowed());
+        return concreteIndexNames(context, indexExpressions);
+    }
+
+    public String[] concreteIndexNames(ProtobufClusterState state, IndicesOptions options, IndicesRequest request) {
+        Context context = new Context(state, options, false, false, request.includeDataStreams(), isSystemIndexAccessAllowed());
+        return concreteIndexNames(context, request.indices());
+    }
+
+    public List<String> dataStreamNames(ProtobufClusterState state, IndicesOptions options, String... indexExpressions) {
+        // Allow system index access - they'll be filtered out below as there's no such thing (yet) as system data streams
+        Context context = new Context(state, options, false, false, true, true, true);
+        if (indexExpressions == null || indexExpressions.length == 0) {
+            indexExpressions = new String[] { "*" };
+        }
+
+        List<String> dataStreams = wildcardExpressionResolver.resolve(context, Arrays.asList(indexExpressions));
+        return ((dataStreams == null) ? List.<String>of() : dataStreams).stream()
+            .map(x -> state.metadata().getIndicesLookup().get(x))
+            .filter(Objects::nonNull)
+            .filter(ia -> ia.getType() == IndexAbstraction.Type.DATA_STREAM)
+            .map(IndexAbstraction::getName)
+            .collect(Collectors.toList());
+    }
+
+    /**
+     * Translates the provided index expression into actual concrete indices, properly deduplicated.
+     *
+     * @param state             the cluster state containing all the data to resolve to expressions to concrete indices
+     * @param options           defines how the aliases or indices need to be resolved to concrete indices
+     * @param indexExpressions  expressions that can be resolved to alias or index names.
+     * @return the resolved concrete indices based on the cluster state, indices options and index expressions
+     * @throws IndexNotFoundException if one of the index expressions is pointing to a missing index or alias and the
+     * provided indices options in the context don't allow such a case, or if the final result of the indices resolution
+     * contains no indices and the indices options in the context don't allow such a case.
+     * @throws IllegalArgumentException if one of the aliases resolve to multiple indices and the provided
+     * indices options in the context don't allow such a case.
+     */
+    public Index[] concreteIndices(ProtobufClusterState state, IndicesOptions options, String... indexExpressions) {
+        return concreteIndices(state, options, false, indexExpressions);
+    }
+
+    public Index[] concreteIndices(ProtobufClusterState state, IndicesOptions options, boolean includeDataStreams, String... indexExpressions) {
+        Context context = new Context(state, options, false, false, includeDataStreams, isSystemIndexAccessAllowed());
+        return concreteIndices(context, indexExpressions);
+    }
+
+    /**
+     * Translates the provided index expression into actual concrete indices, properly deduplicated.
+     *
+     * @param state      the cluster state containing all the data to resolve to expressions to concrete indices
+     * @param startTime  The start of the request where concrete indices is being invoked for
+     * @param request    request containing expressions that can be resolved to alias, index, or data stream names.
+     * @return the resolved concrete indices based on the cluster state, indices options and index expressions
+     * provided indices options in the context don't allow such a case, or if the final result of the indices resolution
+     * contains no indices and the indices options in the context don't allow such a case.
+     * @throws IllegalArgumentException if one of the aliases resolve to multiple indices and the provided
+     * indices options in the context don't allow such a case.
+     */
+    public Index[] concreteIndices(ProtobufClusterState state, IndicesRequest request, long startTime) {
+        Context context = new Context(
+            state,
+            request.indicesOptions(),
+            startTime,
+            false,
+            false,
+            request.includeDataStreams(),
+            false,
+            isSystemIndexAccessAllowed()
+        );
+        return concreteIndices(context, request.indices());
+    }
+
+    String[] concreteIndexNames(Context context, String... indexExpressions) {
+        Index[] indexes = concreteIndices(context, indexExpressions);
+        String[] names = new String[indexes.length];
+        for (int i = 0; i < indexes.length; i++) {
+            names[i] = indexes[i].getName();
+        }
+        return names;
+    }
+
+    Index[] concreteIndices(Context context, String... indexExpressions) {
+        if (indexExpressions == null || indexExpressions.length == 0) {
+            indexExpressions = new String[] { Metadata.ALL };
+        }
+        Metadata metadata = context.getState().metadata();
+        IndicesOptions options = context.getOptions();
+        // If only one index is specified then whether we fail a request if an index is missing depends on the allow_no_indices
+        // option. At some point we should change this, because there shouldn't be a reason why whether a single index
+        // or multiple indices are specified yield different behaviour.
+        final boolean failNoIndices = indexExpressions.length == 1 ? !options.allowNoIndices() : !options.ignoreUnavailable();
+        List<String> expressions = Arrays.asList(indexExpressions);
+        for (ExpressionResolver expressionResolver : expressionResolvers) {
+            expressions = expressionResolver.resolve(context, expressions);
+        }
+
+        if (expressions.isEmpty()) {
+            if (!options.allowNoIndices()) {
+                IndexNotFoundException infe;
+                if (indexExpressions.length == 1) {
+                    if (indexExpressions[0].equals(Metadata.ALL)) {
+                        infe = new IndexNotFoundException("no indices exist", (String) null);
+                    } else {
+                        infe = new IndexNotFoundException((String) null);
+                    }
+                } else {
+                    infe = new IndexNotFoundException((String) null);
+                }
+                infe.setResources("index_expression", indexExpressions);
+                throw infe;
+            } else {
+                return Index.EMPTY_ARRAY;
+            }
+        }
+
+        boolean excludedDataStreams = false;
+        final Set<Index> concreteIndices = new HashSet<>(expressions.size());
+        for (String expression : expressions) {
+            IndexAbstraction indexAbstraction = metadata.getIndicesLookup().get(expression);
+            if (indexAbstraction == null) {
+                if (failNoIndices) {
+                    IndexNotFoundException infe;
+                    if (expression.equals(Metadata.ALL)) {
+                        infe = new IndexNotFoundException("no indices exist", expression);
+                    } else {
+                        infe = new IndexNotFoundException(expression);
+                    }
+                    infe.setResources("index_expression", expression);
+                    throw infe;
+                } else {
+                    continue;
+                }
+            } else if (indexAbstraction.getType() == IndexAbstraction.Type.ALIAS && context.getOptions().ignoreAliases()) {
+                if (failNoIndices) {
+                    throw aliasesNotSupportedException(expression);
+                } else {
+                    continue;
+                }
+            } else if (indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM && context.includeDataStreams() == false) {
+                excludedDataStreams = true;
+                continue;
+            }
+
+            if (indexAbstraction.getType() == IndexAbstraction.Type.ALIAS && context.isResolveToWriteIndex()) {
+                IndexMetadata writeIndex = indexAbstraction.getWriteIndex();
+                if (writeIndex == null) {
+                    throw new IllegalArgumentException(
+                        "no write index is defined for alias ["
+                            + indexAbstraction.getName()
+                            + "]."
+                            + " The write index may be explicitly disabled using is_write_index=false or the alias points to multiple"
+                            + " indices without one being designated as a write index"
+                    );
+                }
+                if (addIndex(writeIndex, context)) {
+                    concreteIndices.add(writeIndex.getIndex());
+                }
+            } else if (indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM && context.isResolveToWriteIndex()) {
+                IndexMetadata writeIndex = indexAbstraction.getWriteIndex();
+                if (addIndex(writeIndex, context)) {
+                    concreteIndices.add(writeIndex.getIndex());
+                }
+            } else {
+                if (indexAbstraction.getIndices().size() > 1 && !options.allowAliasesToMultipleIndices()) {
+                    String[] indexNames = new String[indexAbstraction.getIndices().size()];
+                    int i = 0;
+                    for (IndexMetadata indexMetadata : indexAbstraction.getIndices()) {
+                        indexNames[i++] = indexMetadata.getIndex().getName();
+                    }
+                    throw new IllegalArgumentException(
+                        indexAbstraction.getType().getDisplayName()
+                            + " ["
+                            + expression
+                            + "] has more than one index associated with it "
+                            + Arrays.toString(indexNames)
+                            + ", can't execute a single index op"
+                    );
+                }
+
+                for (IndexMetadata index : indexAbstraction.getIndices()) {
+                    if (shouldTrackConcreteIndex(context, options, index)) {
+                        concreteIndices.add(index.getIndex());
+                    }
+                }
+            }
+        }
+
+        if (options.allowNoIndices() == false && concreteIndices.isEmpty()) {
+            IndexNotFoundException infe = new IndexNotFoundException((String) null);
+            infe.setResources("index_expression", indexExpressions);
+            if (excludedDataStreams) {
+                // Allows callers to handle IndexNotFoundException differently based on whether data streams were excluded.
+                infe.addMetadata(EXCLUDED_DATA_STREAMS_KEY, "true");
+            }
+            throw infe;
+        }
+        checkSystemIndexAccess(context, metadata, concreteIndices, indexExpressions);
+        return concreteIndices.toArray(new Index[0]);
+    }
+
+    private void checkSystemIndexAccess(Context context, Metadata metadata, Set<Index> concreteIndices, String[] originalPatterns) {
+        if (context.isSystemIndexAccessAllowed() == false) {
+            final List<String> resolvedSystemIndices = concreteIndices.stream()
+                .map(metadata::index)
+                .filter(IndexMetadata::isSystem)
+                .map(i -> i.getIndex().getName())
+                .sorted() // reliable order for testing
+                .collect(Collectors.toList());
+            if (resolvedSystemIndices.isEmpty() == false) {
+                resolvedSystemIndices.forEach(
+                    systemIndexName -> deprecationLogger.deprecate(
+                        "open_system_index_access_" + systemIndexName,
+                        "this request accesses system indices: [{}], but in a future major version, direct access to system "
+                            + "indices will be prevented by default",
+                        systemIndexName
+                    )
+                );
+            }
+        }
+    }
+
+    private static boolean shouldTrackConcreteIndex(Context context, IndicesOptions options, IndexMetadata index) {
+        if (index.getState() == IndexMetadata.State.CLOSE) {
+            if (options.forbidClosedIndices() && options.ignoreUnavailable() == false) {
+                throw new IndexClosedException(index.getIndex());
+            } else {
+                return options.forbidClosedIndices() == false && addIndex(index, context);
+            }
+        } else if (index.getState() == IndexMetadata.State.OPEN) {
+            return addIndex(index, context);
+        } else {
+            throw new IllegalStateException("index state [" + index.getState() + "] not supported");
+        }
+    }
+
+    private static boolean addIndex(IndexMetadata metadata, Context context) {
+        // This used to check the `index.search.throttled` setting, but we eventually decided that it was
+        // trappy to hide throttled indices by default. In order to avoid breaking backward compatibility,
+        // we changed it to look at the `index.frozen` setting instead, since frozen indices were the only
+        // type of index to use the `search_throttled` threadpool at that time.
+        // NOTE: The Setting object was defined in an external plugin prior to OpenSearch fork.
+        return (context.options.ignoreThrottled() && metadata.getSettings().getAsBoolean("index.frozen", false)) == false;
+    }
+
+    private static IllegalArgumentException aliasesNotSupportedException(String expression) {
+        return new IllegalArgumentException(
+            "The provided expression [" + expression + "] matches an " + "alias, specify the corresponding concrete indices instead."
+        );
+    }
+
+    /**
+     * Utility method that allows to resolve an index expression to its corresponding single concrete index.
+     * Callers should make sure they provide proper {@link org.opensearch.action.support.IndicesOptions}
+     * that require a single index as a result. The indices resolution must in fact return a single index when
+     * using this method, an {@link IllegalArgumentException} gets thrown otherwise.
+     *
+     * @param state             the cluster state containing all the data to resolve to expression to a concrete index
+     * @param request           The request that defines how the an alias or an index need to be resolved to a concrete index
+     *                          and the expression that can be resolved to an alias or an index name.
+     * @throws IllegalArgumentException if the index resolution lead to more than one index
+     * @return the concrete index obtained as a result of the index resolution
+     */
+    public Index concreteSingleIndex(ProtobufClusterState state, IndicesRequest request) {
+        String indexExpression = CollectionUtils.isEmpty(request.indices()) ? null : request.indices()[0];
+        Index[] indices = concreteIndices(state, request.indicesOptions(), indexExpression);
+        if (indices.length != 1) {
+            throw new IllegalArgumentException(
+                "unable to return a single index as the index and options" + " provided got resolved to multiple indices"
+            );
+        }
+        return indices[0];
+    }
+
+    /**
+     * Utility method that allows to resolve an index expression to its corresponding single write index.
+     *
+     * @param state             the cluster state containing all the data to resolve to expression to a concrete index
+     * @param request           The request that defines how the an alias or an index need to be resolved to a concrete index
+     *                          and the expression that can be resolved to an alias or an index name.
+     * @throws IllegalArgumentException if the index resolution does not lead to an index, or leads to more than one index
+     * @return the write index obtained as a result of the index resolution
+     */
+    public Index concreteWriteIndex(ProtobufClusterState state, IndicesRequest request) {
+        if (request.indices() == null || (request.indices() != null && request.indices().length != 1)) {
+            throw new IllegalArgumentException("indices request must specify a single index expression");
+        }
+        return concreteWriteIndex(state, request.indicesOptions(), request.indices()[0], false, request.includeDataStreams());
+    }
+
+    /**
+     * Utility method that allows to resolve an index expression to its corresponding single write index.
+     *
+     * @param state             the cluster state containing all the data to resolve to expression to a concrete index
+     * @param options           defines how the aliases or indices need to be resolved to concrete indices
+     * @param index             index that can be resolved to alias or index name.
+     * @param allowNoIndices    whether to allow resolve to no index
+     * @param includeDataStreams Whether data streams should be included in the evaluation.
+     * @throws IllegalArgumentException if the index resolution does not lead to an index, or leads to more than one index
+     * @return the write index obtained as a result of the index resolution or null if no index
+     */
+    public Index concreteWriteIndex(
+        ProtobufClusterState state,
+        IndicesOptions options,
+        String index,
+        boolean allowNoIndices,
+        boolean includeDataStreams
+    ) {
+        IndicesOptions combinedOptions = IndicesOptions.fromOptions(
+            options.ignoreUnavailable(),
+            allowNoIndices,
+            options.expandWildcardsOpen(),
+            options.expandWildcardsClosed(),
+            options.expandWildcardsHidden(),
+            options.allowAliasesToMultipleIndices(),
+            options.forbidClosedIndices(),
+            options.ignoreAliases(),
+            options.ignoreThrottled()
+        );
+
+        Context context = new Context(state, combinedOptions, false, true, includeDataStreams, isSystemIndexAccessAllowed());
+        Index[] indices = concreteIndices(context, index);
+        if (allowNoIndices && indices.length == 0) {
+            return null;
+        }
+        if (indices.length != 1) {
+            throw new IllegalArgumentException(
+                "The index expression [" + index + "] and options provided did not point to a single write-index"
+            );
+        }
+        return indices[0];
+    }
+
+    /**
+     * @return whether the specified index, data stream or alias exists.
+     *         If the data stream, index or alias contains date math then that is resolved too.
+     */
+    public boolean hasIndexAbstraction(String indexAbstraction, ProtobufClusterState state) {
+        Context context = new Context(state, IndicesOptions.lenientExpandOpen(), false, false, true, isSystemIndexAccessAllowed());
+        String resolvedAliasOrIndex = dateMathExpressionResolver.resolveExpression(indexAbstraction, context);
+        return state.metadata().getIndicesLookup().containsKey(resolvedAliasOrIndex);
+    }
+
+    /**
+     * @return If the specified string is data math expression then this method returns the resolved expression.
+     */
+    public String resolveDateMathExpression(String dateExpression) {
+        // The data math expression resolver doesn't rely on cluster state or indices options, because
+        // it just resolves the date math to an actual date.
+        return dateMathExpressionResolver.resolveExpression(dateExpression, new Context(null, null, isSystemIndexAccessAllowed()));
+    }
+
+    /**
+     * Resolve an array of expressions to the set of indices and aliases that these expressions match.
+     */
+    public Set<String> resolveExpressions(ProtobufClusterState state, String... expressions) {
+        Context context = new Context(state, IndicesOptions.lenientExpandOpen(), true, false, true, isSystemIndexAccessAllowed());
+        List<String> resolvedExpressions = Arrays.asList(expressions);
+        for (ExpressionResolver expressionResolver : expressionResolvers) {
+            resolvedExpressions = expressionResolver.resolve(context, resolvedExpressions);
+        }
+        return Collections.unmodifiableSet(new HashSet<>(resolvedExpressions));
+    }
+
+    /**
+     * Iterates through the list of indices and selects the effective list of filtering aliases for the
+     * given index.
+     * <p>Only aliases with filters are returned. If the indices list contains a non-filtering reference to
+     * the index itself - null is returned. Returns {@code null} if no filtering is required.
+     * <b>NOTE</b>: The provided expressions must have been resolved already via {@link #resolveExpressions}.
+     */
+    public String[] filteringAliases(ProtobufClusterState state, String index, Set<String> resolvedExpressions) {
+        return indexAliases(state, index, AliasMetadata::filteringRequired, false, resolvedExpressions);
+    }
+
+    /**
+     * Whether to generate the candidate set from index aliases, or from the set of resolved expressions.
+     * @param indexAliasesSize        the number of aliases of the index
+     * @param resolvedExpressionsSize the number of resolved expressions
+     */
+    // pkg-private for testing
+    boolean iterateIndexAliases(int indexAliasesSize, int resolvedExpressionsSize) {
+        return indexAliasesSize <= resolvedExpressionsSize;
+    }
+
+    /**
+     * Iterates through the list of indices and selects the effective list of required aliases for the given index.
+     * <p>Only aliases where the given predicate tests successfully are returned. If the indices list contains a non-required reference to
+     * the index itself - null is returned. Returns {@code null} if no filtering is required.
+     * <p><b>NOTE</b>: the provided expressions must have been resolved already via {@link #resolveExpressions}.
+     */
+    public String[] indexAliases(
+        ProtobufClusterState state,
+        String index,
+        Predicate<AliasMetadata> requiredAlias,
+        boolean skipIdentity,
+        Set<String> resolvedExpressions
+    ) {
+        if (isAllIndices(resolvedExpressions)) {
+            return null;
+        }
+
+        final IndexMetadata indexMetadata = state.metadata().getIndices().get(index);
+        if (indexMetadata == null) {
+            // Shouldn't happen
+            throw new IndexNotFoundException(index);
+        }
+
+        if (skipIdentity == false && resolvedExpressions.contains(index)) {
+            return null;
+        }
+
+        final ImmutableOpenMap<String, AliasMetadata> indexAliases = indexMetadata.getAliases();
+        final AliasMetadata[] aliasCandidates;
+        if (iterateIndexAliases(indexAliases.size(), resolvedExpressions.size())) {
+            // faster to iterate indexAliases
+            aliasCandidates = StreamSupport.stream(Spliterators.spliteratorUnknownSize(indexAliases.values().iterator(), 0), false)
+                .map(cursor -> cursor.value)
+                .filter(aliasMetadata -> resolvedExpressions.contains(aliasMetadata.alias()))
+                .toArray(AliasMetadata[]::new);
+        } else {
+            // faster to iterate resolvedExpressions
+            aliasCandidates = resolvedExpressions.stream().map(indexAliases::get).filter(Objects::nonNull).toArray(AliasMetadata[]::new);
+        }
+
+        List<String> aliases = null;
+        for (AliasMetadata aliasMetadata : aliasCandidates) {
+            if (requiredAlias.test(aliasMetadata)) {
+                // If required - add it to the list of aliases
+                if (aliases == null) {
+                    aliases = new ArrayList<>();
+                }
+                aliases.add(aliasMetadata.alias());
+            } else {
+                // If not, we have a non required alias for this index - no further checking needed
+                return null;
+            }
+        }
+        if (aliases == null) {
+            return null;
+        }
+        return aliases.toArray(new String[0]);
+    }
+
+    /**
+     * Resolves the search routing if in the expression aliases are used. If expressions point to concrete indices
+     * or aliases with no routing defined the specified routing is used.
+     *
+     * @return routing values grouped by concrete index
+     */
+    public Map<String, Set<String>> resolveSearchRouting(ProtobufClusterState state, @Nullable String routing, String... expressions) {
+        List<String> resolvedExpressions = expressions != null ? Arrays.asList(expressions) : Collections.emptyList();
+        Context context = new Context(state, IndicesOptions.lenientExpandOpen(), false, false, true, isSystemIndexAccessAllowed());
+        for (ExpressionResolver expressionResolver : expressionResolvers) {
+            resolvedExpressions = expressionResolver.resolve(context, resolvedExpressions);
+        }
+
+        // TODO: it appears that this can never be true?
+        if (isAllIndices(resolvedExpressions)) {
+            return resolveSearchRoutingAllIndices(state.metadata(), routing);
+        }
+
+        Map<String, Set<String>> routings = null;
+        Set<String> paramRouting = null;
+        // List of indices that don't require any routing
+        Set<String> norouting = new HashSet<>();
+        if (routing != null) {
+            paramRouting = Sets.newHashSet(Strings.splitStringByCommaToArray(routing));
+        }
+
+        for (String expression : resolvedExpressions) {
+            IndexAbstraction indexAbstraction = state.metadata().getIndicesLookup().get(expression);
+            if (indexAbstraction != null && indexAbstraction.getType() == IndexAbstraction.Type.ALIAS) {
+                IndexAbstraction.Alias alias = (IndexAbstraction.Alias) indexAbstraction;
+                for (Tuple<String, AliasMetadata> item : alias.getConcreteIndexAndAliasMetadatas()) {
+                    String concreteIndex = item.v1();
+                    AliasMetadata aliasMetadata = item.v2();
+                    if (!norouting.contains(concreteIndex)) {
+                        if (!aliasMetadata.searchRoutingValues().isEmpty()) {
+                            // Routing alias
+                            if (routings == null) {
+                                routings = new HashMap<>();
+                            }
+                            Set<String> r = routings.get(concreteIndex);
+                            if (r == null) {
+                                r = new HashSet<>();
+                                routings.put(concreteIndex, r);
+                            }
+                            r.addAll(aliasMetadata.searchRoutingValues());
+                            if (paramRouting != null) {
+                                r.retainAll(paramRouting);
+                            }
+                            if (r.isEmpty()) {
+                                routings.remove(concreteIndex);
+                            }
+                        } else {
+                            // Non-routing alias
+                            if (!norouting.contains(concreteIndex)) {
+                                norouting.add(concreteIndex);
+                                if (paramRouting != null) {
+                                    Set<String> r = new HashSet<>(paramRouting);
+                                    if (routings == null) {
+                                        routings = new HashMap<>();
+                                    }
+                                    routings.put(concreteIndex, r);
+                                } else {
+                                    if (routings != null) {
+                                        routings.remove(concreteIndex);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            } else {
+                // Index
+                if (!norouting.contains(expression)) {
+                    norouting.add(expression);
+                    if (paramRouting != null) {
+                        Set<String> r = new HashSet<>(paramRouting);
+                        if (routings == null) {
+                            routings = new HashMap<>();
+                        }
+                        routings.put(expression, r);
+                    } else {
+                        if (routings != null) {
+                            routings.remove(expression);
+                        }
+                    }
+                }
+            }
+
+        }
+        if (routings == null || routings.isEmpty()) {
+            return null;
+        }
+        return routings;
+    }
+
+    /**
+     * Sets the same routing for all indices
+     */
+    public Map<String, Set<String>> resolveSearchRoutingAllIndices(Metadata metadata, String routing) {
+        if (routing != null) {
+            Set<String> r = Sets.newHashSet(Strings.splitStringByCommaToArray(routing));
+            Map<String, Set<String>> routings = new HashMap<>();
+            String[] concreteIndices = metadata.getConcreteAllIndices();
+            for (String index : concreteIndices) {
+                routings.put(index, r);
+            }
+            return routings;
+        }
+        return null;
+    }
+
+    /**
+     * Identifies whether the array containing index names given as argument refers to all indices
+     * The empty or null array identifies all indices
+     *
+     * @param aliasesOrIndices the array containing index names
+     * @return true if the provided array maps to all indices, false otherwise
+     */
+    public static boolean isAllIndices(Collection<String> aliasesOrIndices) {
+        return aliasesOrIndices == null || aliasesOrIndices.isEmpty() || isExplicitAllPattern(aliasesOrIndices);
+    }
+
+    /**
+     * Identifies whether the array containing index names given as argument explicitly refers to all indices
+     * The empty or null array doesn't explicitly map to all indices
+     *
+     * @param aliasesOrIndices the array containing index names
+     * @return true if the provided array explicitly maps to all indices, false otherwise
+     */
+    static boolean isExplicitAllPattern(Collection<String> aliasesOrIndices) {
+        return aliasesOrIndices != null && aliasesOrIndices.size() == 1 && Metadata.ALL.equals(aliasesOrIndices.iterator().next());
+    }
+
+    /**
+     * Identifies whether the first argument (an array containing index names) is a pattern that matches all indices
+     *
+     * @param indicesOrAliases the array containing index names
+     * @param concreteIndices  array containing the concrete indices that the first argument refers to
+     * @return true if the first argument is a pattern that maps to all available indices, false otherwise
+     */
+    boolean isPatternMatchingAllIndices(Metadata metadata, String[] indicesOrAliases, String[] concreteIndices) {
+        // if we end up matching on all indices, check, if its a wildcard parameter, or a "-something" structure
+        if (concreteIndices.length == metadata.getConcreteAllIndices().length && indicesOrAliases.length > 0) {
+
+            // we might have something like /-test1,+test1 that would identify all indices
+            // or something like /-test1 with test1 index missing and IndicesOptions.lenient()
+            if (indicesOrAliases[0].charAt(0) == '-') {
+                return true;
+            }
+
+            // otherwise we check if there's any simple regex
+            for (String indexOrAlias : indicesOrAliases) {
+                if (Regex.isSimpleMatchPattern(indexOrAlias)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Determines whether or not system index access should be allowed in the current context.
+     *
+     * @return True if system index access should be allowed, false otherwise.
+     */
+    public boolean isSystemIndexAccessAllowed() {
+        return Booleans.parseBoolean(threadContext.getHeader(SYSTEM_INDEX_ACCESS_CONTROL_HEADER_KEY), true);
+    }
+
+    /**
+     * Context for the resolver.
+     *
+     * @opensearch.internal
+     */
+    public static class Context {
+
+        private final ProtobufClusterState state;
+        private final IndicesOptions options;
+        private final long startTime;
+        private final boolean preserveAliases;
+        private final boolean resolveToWriteIndex;
+        private final boolean includeDataStreams;
+        private final boolean preserveDataStreams;
+        private final boolean isSystemIndexAccessAllowed;
+
+        Context(ProtobufClusterState state, IndicesOptions options, boolean isSystemIndexAccessAllowed) {
+            this(state, options, System.currentTimeMillis(), isSystemIndexAccessAllowed);
+        }
+
+        Context(
+            ProtobufClusterState state,
+            IndicesOptions options,
+            boolean preserveAliases,
+            boolean resolveToWriteIndex,
+            boolean includeDataStreams,
+            boolean isSystemIndexAccessAllowed
+        ) {
+            this(
+                state,
+                options,
+                System.currentTimeMillis(),
+                preserveAliases,
+                resolveToWriteIndex,
+                includeDataStreams,
+                false,
+                isSystemIndexAccessAllowed
+            );
+        }
+
+        Context(
+            ProtobufClusterState state,
+            IndicesOptions options,
+            boolean preserveAliases,
+            boolean resolveToWriteIndex,
+            boolean includeDataStreams,
+            boolean preserveDataStreams,
+            boolean isSystemIndexAccessAllowed
+        ) {
+            this(
+                state,
+                options,
+                System.currentTimeMillis(),
+                preserveAliases,
+                resolveToWriteIndex,
+                includeDataStreams,
+                preserveDataStreams,
+                isSystemIndexAccessAllowed
+            );
+        }
+
+        Context(ProtobufClusterState state, IndicesOptions options, long startTime, boolean isSystemIndexAccessAllowed) {
+            this(state, options, startTime, false, false, false, false, isSystemIndexAccessAllowed);
+        }
+
+        protected Context(
+            ProtobufClusterState state,
+            IndicesOptions options,
+            long startTime,
+            boolean preserveAliases,
+            boolean resolveToWriteIndex,
+            boolean includeDataStreams,
+            boolean preserveDataStreams,
+            boolean isSystemIndexAccessAllowed
+        ) {
+            this.state = state;
+            this.options = options;
+            this.startTime = startTime;
+            this.preserveAliases = preserveAliases;
+            this.resolveToWriteIndex = resolveToWriteIndex;
+            this.includeDataStreams = includeDataStreams;
+            this.preserveDataStreams = preserveDataStreams;
+            this.isSystemIndexAccessAllowed = isSystemIndexAccessAllowed;
+        }
+
+        public ProtobufClusterState getState() {
+            return state;
+        }
+
+        public IndicesOptions getOptions() {
+            return options;
+        }
+
+        public long getStartTime() {
+            return startTime;
+        }
+
+        /**
+         * This is used to prevent resolving aliases to concrete indices but this also means
+         * that we might return aliases that point to a closed index. This is currently only used
+         * by {@link #filteringAliases(ProtobufClusterState, String, Set)} since it's the only one that needs aliases
+         */
+        boolean isPreserveAliases() {
+            return preserveAliases;
+        }
+
+        /**
+         * This is used to require that aliases resolve to their write-index. It is currently not used in conjunction
+         * with <code>preserveAliases</code>.
+         */
+        boolean isResolveToWriteIndex() {
+            return resolveToWriteIndex;
+        }
+
+        public boolean includeDataStreams() {
+            return includeDataStreams;
+        }
+
+        public boolean isPreserveDataStreams() {
+            return preserveDataStreams;
+        }
+
+        /**
+         * Used to determine if it is allowed to access system indices in this context (e.g. for this request).
+         */
+        public boolean isSystemIndexAccessAllowed() {
+            return isSystemIndexAccessAllowed;
+        }
+    }
+
+    private interface ExpressionResolver {
+
+        /**
+         * Resolves the list of expressions into other expressions if possible (possible concrete indices and aliases, but
+         * that isn't required). The provided implementations can also be left untouched.
+         *
+         * @return a new list with expressions based on the provided expressions
+         */
+        List<String> resolve(Context context, List<String> expressions);
+
+    }
+
+    /**
+     * Resolves alias/index name expressions with wildcards into the corresponding concrete indices/aliases
+     *
+     * @opensearch.internal
+     */
+    static final class WildcardExpressionResolver implements ExpressionResolver {
+
+        @Override
+        public List<String> resolve(Context context, List<String> expressions) {
+            IndicesOptions options = context.getOptions();
+            Metadata metadata = context.getState().metadata();
+            // only check open/closed since if we do not expand to open or closed it doesn't make sense to
+            // expand to hidden
+            if (options.expandWildcardsClosed() == false && options.expandWildcardsOpen() == false) {
+                return expressions;
+            }
+
+            if (isEmptyOrTrivialWildcard(expressions)) {
+                List<String> resolvedExpressions = resolveEmptyOrTrivialWildcard(options, metadata);
+                if (context.includeDataStreams()) {
+                    final IndexMetadata.State excludeState = excludeState(options);
+                    final Map<String, IndexAbstraction> dataStreamsAbstractions = metadata.getIndicesLookup()
+                        .entrySet()
+                        .stream()
+                        .filter(entry -> entry.getValue().getType() == IndexAbstraction.Type.DATA_STREAM)
+                        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+                    // dedup backing indices if expand hidden indices option is true
+                    Set<String> resolvedIncludingDataStreams = new HashSet<>(resolvedExpressions);
+                    resolvedIncludingDataStreams.addAll(
+                        expand(
+                            context,
+                            excludeState,
+                            dataStreamsAbstractions,
+                            expressions.isEmpty() ? "_all" : expressions.get(0),
+                            options.expandWildcardsHidden()
+                        )
+                    );
+                    return new ArrayList<>(resolvedIncludingDataStreams);
+                }
+                return resolvedExpressions;
+            }
+
+            Set<String> result = innerResolve(context, expressions, options, metadata);
+
+            if (result == null) {
+                return expressions;
+            }
+            if (result.isEmpty() && !options.allowNoIndices()) {
+                IndexNotFoundException infe = new IndexNotFoundException((String) null);
+                infe.setResources("index_or_alias", expressions.toArray(new String[0]));
+                throw infe;
+            }
+            return new ArrayList<>(result);
+        }
+
+        private Set<String> innerResolve(Context context, List<String> expressions, IndicesOptions options, Metadata metadata) {
+            Set<String> result = null;
+            boolean wildcardSeen = false;
+            for (int i = 0; i < expressions.size(); i++) {
+                String expression = expressions.get(i);
+                if (Strings.isEmpty(expression)) {
+                    throw indexNotFoundException(expression);
+                }
+                validateAliasOrIndex(expression);
+                if (aliasOrIndexExists(context, options, metadata, expression)) {
+                    if (result != null) {
+                        result.add(expression);
+                    }
+                    continue;
+                }
+                final boolean add;
+                if (expression.charAt(0) == '-' && wildcardSeen) {
+                    add = false;
+                    expression = expression.substring(1);
+                } else {
+                    add = true;
+                }
+                if (result == null) {
+                    // add all the previous ones...
+                    result = new HashSet<>(expressions.subList(0, i));
+                }
+                if (Regex.isSimpleMatchPattern(expression) == false) {
+                    // TODO why does wildcard resolver throw exceptions regarding non wildcarded expressions? This should not be done here.
+                    if (options.ignoreUnavailable() == false) {
+                        IndexAbstraction indexAbstraction = metadata.getIndicesLookup().get(expression);
+                        if (indexAbstraction == null) {
+                            throw indexNotFoundException(expression);
+                        } else if (indexAbstraction.getType() == IndexAbstraction.Type.ALIAS && options.ignoreAliases()) {
+                            throw aliasesNotSupportedException(expression);
+                        } else if (indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM
+                            && context.includeDataStreams() == false) {
+                                throw indexNotFoundException(expression);
+                            }
+                    }
+                    if (add) {
+                        result.add(expression);
+                    } else {
+                        result.remove(expression);
+                    }
+                    continue;
+                }
+
+                final IndexMetadata.State excludeState = excludeState(options);
+                final Map<String, IndexAbstraction> matches = matches(context, metadata, expression);
+                Set<String> expand = expand(context, excludeState, matches, expression, options.expandWildcardsHidden());
+                if (add) {
+                    result.addAll(expand);
+                } else {
+                    result.removeAll(expand);
+                }
+                if (options.allowNoIndices() == false && matches.isEmpty()) {
+                    throw indexNotFoundException(expression);
+                }
+                if (Regex.isSimpleMatchPattern(expression)) {
+                    wildcardSeen = true;
+                }
+            }
+            return result;
+        }
+
+        private static void validateAliasOrIndex(String expression) {
+            // Expressions can not start with an underscore. This is reserved for APIs. If the check gets here, the API
+            // does not exist and the path is interpreted as an expression. If the expression begins with an underscore,
+            // throw a specific error that is different from the [[IndexNotFoundException]], which is typically thrown
+            // if the expression can't be found.
+            if (expression.charAt(0) == '_') {
+                throw new InvalidIndexNameException(expression, "must not start with '_'.");
+            }
+        }
+
+        private static boolean aliasOrIndexExists(Context context, IndicesOptions options, Metadata metadata, String expression) {
+            IndexAbstraction indexAbstraction = metadata.getIndicesLookup().get(expression);
+            if (indexAbstraction == null) {
+                return false;
+            }
+
+            // treat aliases as unavailable indices when ignoreAliases is set to true (e.g. delete index and update aliases api)
+            if (indexAbstraction.getType() == IndexAbstraction.Type.ALIAS && options.ignoreAliases()) {
+                return false;
+            }
+
+            if (indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM && context.includeDataStreams() == false) {
+                return false;
+            }
+
+            return true;
+        }
+
+        private static IndexNotFoundException indexNotFoundException(String expression) {
+            IndexNotFoundException infe = new IndexNotFoundException(expression);
+            infe.setResources("index_or_alias", expression);
+            return infe;
+        }
+
+        private static IndexMetadata.State excludeState(IndicesOptions options) {
+            final IndexMetadata.State excludeState;
+            if (options.expandWildcardsOpen() && options.expandWildcardsClosed()) {
+                excludeState = null;
+            } else if (options.expandWildcardsOpen() && options.expandWildcardsClosed() == false) {
+                excludeState = IndexMetadata.State.CLOSE;
+            } else if (options.expandWildcardsClosed() && options.expandWildcardsOpen() == false) {
+                excludeState = IndexMetadata.State.OPEN;
+            } else {
+                assert false : "this shouldn't get called if wildcards expand to none";
+                excludeState = null;
+            }
+            return excludeState;
+        }
+
+        public static Map<String, IndexAbstraction> matches(Context context, Metadata metadata, String expression) {
+            if (Regex.isMatchAllPattern(expression)) {
+                return filterIndicesLookup(context, metadata.getIndicesLookup(), null, context.getOptions());
+            } else if (expression.indexOf("*") == expression.length() - 1) {
+                return suffixWildcard(context, metadata, expression);
+            } else {
+                return otherWildcard(context, metadata, expression);
+            }
+        }
+
+        private static Map<String, IndexAbstraction> suffixWildcard(Context context, Metadata metadata, String expression) {
+            assert expression.length() >= 2 : "expression [" + expression + "] should have at least a length of 2";
+            String fromPrefix = expression.substring(0, expression.length() - 1);
+            char[] toPrefixCharArr = fromPrefix.toCharArray();
+            toPrefixCharArr[toPrefixCharArr.length - 1]++;
+            String toPrefix = new String(toPrefixCharArr);
+            SortedMap<String, IndexAbstraction> subMap = metadata.getIndicesLookup().subMap(fromPrefix, toPrefix);
+            return filterIndicesLookup(context, subMap, null, context.getOptions());
+        }
+
+        private static Map<String, IndexAbstraction> otherWildcard(Context context, Metadata metadata, String expression) {
+            final String pattern = expression;
+            return filterIndicesLookup(
+                context,
+                metadata.getIndicesLookup(),
+                e -> Regex.simpleMatch(pattern, e.getKey()),
+                context.getOptions()
+            );
+        }
+
+        private static Map<String, IndexAbstraction> filterIndicesLookup(
+            Context context,
+            SortedMap<String, IndexAbstraction> indicesLookup,
+            Predicate<? super Map.Entry<String, IndexAbstraction>> filter,
+            IndicesOptions options
+        ) {
+            boolean shouldConsumeStream = false;
+            Stream<Map.Entry<String, IndexAbstraction>> stream = indicesLookup.entrySet().stream();
+            if (options.ignoreAliases()) {
+                shouldConsumeStream = true;
+                stream = stream.filter(e -> e.getValue().getType() != IndexAbstraction.Type.ALIAS);
+            }
+            if (filter != null) {
+                shouldConsumeStream = true;
+                stream = stream.filter(filter);
+            }
+            if (context.includeDataStreams() == false) {
+                shouldConsumeStream = true;
+                stream = stream.filter(e -> e.getValue().getType() != IndexAbstraction.Type.DATA_STREAM);
+            }
+            if (shouldConsumeStream) {
+                return stream.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+            } else {
+                return indicesLookup;
+            }
+        }
+
+        private static Set<String> expand(
+            Context context,
+            IndexMetadata.State excludeState,
+            Map<String, IndexAbstraction> matches,
+            String expression,
+            boolean includeHidden
+        ) {
+            Set<String> expand = new HashSet<>();
+            for (Map.Entry<String, IndexAbstraction> entry : matches.entrySet()) {
+                String aliasOrIndexName = entry.getKey();
+                IndexAbstraction indexAbstraction = entry.getValue();
+
+                if (indexAbstraction.isHidden() == false || includeHidden || implicitHiddenMatch(aliasOrIndexName, expression)) {
+                    if (context.isPreserveAliases() && indexAbstraction.getType() == IndexAbstraction.Type.ALIAS) {
+                        expand.add(aliasOrIndexName);
+                    } else {
+                        for (IndexMetadata meta : indexAbstraction.getIndices()) {
+                            if (excludeState == null || meta.getState() != excludeState) {
+                                expand.add(meta.getIndex().getName());
+                            }
+                        }
+                        if (context.isPreserveDataStreams() && indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM) {
+                            expand.add(indexAbstraction.getName());
+                        }
+                    }
+                }
+            }
+            return expand;
+        }
+
+        private static boolean implicitHiddenMatch(String itemName, String expression) {
+            return itemName.startsWith(".") && expression.startsWith(".") && Regex.isSimpleMatchPattern(expression);
+        }
+
+        private boolean isEmptyOrTrivialWildcard(List<String> expressions) {
+            return expressions.isEmpty()
+                || (expressions.size() == 1 && (Metadata.ALL.equals(expressions.get(0)) || Regex.isMatchAllPattern(expressions.get(0))));
+        }
+
+        private static List<String> resolveEmptyOrTrivialWildcard(IndicesOptions options, Metadata metadata) {
+            if (options.expandWildcardsOpen() && options.expandWildcardsClosed() && options.expandWildcardsHidden()) {
+                return Arrays.asList(metadata.getConcreteAllIndices());
+            } else if (options.expandWildcardsOpen() && options.expandWildcardsClosed()) {
+                return Arrays.asList(metadata.getConcreteVisibleIndices());
+            } else if (options.expandWildcardsOpen() && options.expandWildcardsHidden()) {
+                return Arrays.asList(metadata.getConcreteAllOpenIndices());
+            } else if (options.expandWildcardsOpen()) {
+                return Arrays.asList(metadata.getConcreteVisibleOpenIndices());
+            } else if (options.expandWildcardsClosed() && options.expandWildcardsHidden()) {
+                return Arrays.asList(metadata.getConcreteAllClosedIndices());
+            } else if (options.expandWildcardsClosed()) {
+                return Arrays.asList(metadata.getConcreteVisibleClosedIndices());
+            } else {
+                return Collections.emptyList();
+            }
+        }
+    }
+
+    /**
+     * A date math expression resolver.
+     *
+     * @opensearch.internal
+     */
+    public static final class DateMathExpressionResolver implements ExpressionResolver {
+
+        private static final DateFormatter DEFAULT_DATE_FORMATTER = DateFormatter.forPattern("uuuu.MM.dd");
+        private static final String EXPRESSION_LEFT_BOUND = "<";
+        private static final String EXPRESSION_RIGHT_BOUND = ">";
+        private static final char LEFT_BOUND = '{';
+        private static final char RIGHT_BOUND = '}';
+        private static final char ESCAPE_CHAR = '\\';
+        private static final char TIME_ZONE_BOUND = '|';
+
+        @Override
+        public List<String> resolve(final Context context, List<String> expressions) {
+            List<String> result = new ArrayList<>(expressions.size());
+            for (String expression : expressions) {
+                result.add(resolveExpression(expression, context));
+            }
+            return result;
+        }
+
+        @SuppressWarnings("fallthrough")
+        String resolveExpression(String expression, final Context context) {
+            if (expression.startsWith(EXPRESSION_LEFT_BOUND) == false || expression.endsWith(EXPRESSION_RIGHT_BOUND) == false) {
+                return expression;
+            }
+
+            boolean escape = false;
+            boolean inDateFormat = false;
+            boolean inPlaceHolder = false;
+            final StringBuilder beforePlaceHolderSb = new StringBuilder();
+            StringBuilder inPlaceHolderSb = new StringBuilder();
+            final char[] text = expression.toCharArray();
+            final int from = 1;
+            final int length = text.length - 1;
+            for (int i = from; i < length; i++) {
+                boolean escapedChar = escape;
+                if (escape) {
+                    escape = false;
+                }
+
+                char c = text[i];
+                if (c == ESCAPE_CHAR) {
+                    if (escapedChar) {
+                        beforePlaceHolderSb.append(c);
+                        escape = false;
+                    } else {
+                        escape = true;
+                    }
+                    continue;
+                }
+                if (inPlaceHolder) {
+                    switch (c) {
+                        case LEFT_BOUND:
+                            if (inDateFormat && escapedChar) {
+                                inPlaceHolderSb.append(c);
+                            } else if (!inDateFormat) {
+                                inDateFormat = true;
+                                inPlaceHolderSb.append(c);
+                            } else {
+                                throw new OpenSearchParseException(
+                                    "invalid dynamic name expression [{}]." + " invalid character in placeholder at position [{}]",
+                                    new String(text, from, length),
+                                    i
+                                );
+                            }
+                            break;
+
+                        case RIGHT_BOUND:
+                            if (inDateFormat && escapedChar) {
+                                inPlaceHolderSb.append(c);
+                            } else if (inDateFormat) {
+                                inDateFormat = false;
+                                inPlaceHolderSb.append(c);
+                            } else {
+                                String inPlaceHolderString = inPlaceHolderSb.toString();
+                                int dateTimeFormatLeftBoundIndex = inPlaceHolderString.indexOf(LEFT_BOUND);
+                                String mathExpression;
+                                String dateFormatterPattern;
+                                DateFormatter dateFormatter;
+                                final ZoneId timeZone;
+                                if (dateTimeFormatLeftBoundIndex < 0) {
+                                    mathExpression = inPlaceHolderString;
+                                    dateFormatter = DEFAULT_DATE_FORMATTER;
+                                    timeZone = ZoneOffset.UTC;
+                                } else {
+                                    if (inPlaceHolderString.lastIndexOf(RIGHT_BOUND) != inPlaceHolderString.length() - 1) {
+                                        throw new OpenSearchParseException(
+                                            "invalid dynamic name expression [{}]. missing closing `}`" + " for date math format",
+                                            inPlaceHolderString
+                                        );
+                                    }
+                                    if (dateTimeFormatLeftBoundIndex == inPlaceHolderString.length() - 2) {
+                                        throw new OpenSearchParseException(
+                                            "invalid dynamic name expression [{}]. missing date format",
+                                            inPlaceHolderString
+                                        );
+                                    }
+                                    mathExpression = inPlaceHolderString.substring(0, dateTimeFormatLeftBoundIndex);
+                                    String patternAndTZid = inPlaceHolderString.substring(
+                                        dateTimeFormatLeftBoundIndex + 1,
+                                        inPlaceHolderString.length() - 1
+                                    );
+                                    int formatPatternTimeZoneSeparatorIndex = patternAndTZid.indexOf(TIME_ZONE_BOUND);
+                                    if (formatPatternTimeZoneSeparatorIndex != -1) {
+                                        dateFormatterPattern = patternAndTZid.substring(0, formatPatternTimeZoneSeparatorIndex);
+                                        timeZone = DateUtils.of(patternAndTZid.substring(formatPatternTimeZoneSeparatorIndex + 1));
+                                    } else {
+                                        dateFormatterPattern = patternAndTZid;
+                                        timeZone = ZoneOffset.UTC;
+                                    }
+                                    dateFormatter = DateFormatter.forPattern(dateFormatterPattern);
+                                }
+
+                                DateFormatter formatter = dateFormatter.withZone(timeZone);
+                                DateMathParser dateMathParser = formatter.toDateMathParser();
+                                Instant instant = dateMathParser.parse(mathExpression, context::getStartTime, false, timeZone);
+
+                                String time = formatter.format(instant);
+                                beforePlaceHolderSb.append(time);
+                                inPlaceHolderSb = new StringBuilder();
+                                inPlaceHolder = false;
+                            }
+                            break;
+
+                        default:
+                            inPlaceHolderSb.append(c);
+                    }
+                } else {
+                    switch (c) {
+                        case LEFT_BOUND:
+                            if (escapedChar) {
+                                beforePlaceHolderSb.append(c);
+                            } else {
+                                inPlaceHolder = true;
+                            }
+                            break;
+
+                        case RIGHT_BOUND:
+                            if (!escapedChar) {
+                                throw new OpenSearchParseException(
+                                    "invalid dynamic name expression [{}]."
+                                        + " invalid character at position [{}]. `{` and `}` are reserved characters and"
+                                        + " should be escaped when used as part of the index name using `\\` (e.g. `\\{text\\}`)",
+                                    new String(text, from, length),
+                                    i
+                                );
+                            }
+                        default:
+                            beforePlaceHolderSb.append(c);
+                    }
+                }
+            }
+
+            if (inPlaceHolder) {
+                throw new OpenSearchParseException(
+                    "invalid dynamic name expression [{}]. date math placeholder is open ended",
+                    new String(text, from, length)
+                );
+            }
+            if (beforePlaceHolderSb.length() == 0) {
+                throw new OpenSearchParseException("nothing captured");
+            }
+            return beforePlaceHolderSb.toString();
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java b/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
index c03f5ae619edf..57db883a337e8 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
@@ -44,6 +44,7 @@
 import org.opensearch.cluster.LocalNodeClusterManagerListener;
 import org.opensearch.cluster.LocalNodeMasterListener;
 import org.opensearch.cluster.NodeConnectionsService;
+import org.opensearch.cluster.ProtobufClusterState;
 import org.opensearch.cluster.TimeoutClusterStateListener;
 import org.opensearch.cluster.metadata.ProcessClusterEventTimeoutException;
 import org.opensearch.cluster.node.DiscoveryNodes;
@@ -114,6 +115,7 @@ public class ClusterApplierService extends AbstractLifecycleComponent implements
     private final Map<TimeoutClusterStateListener, NotifyTimeout> timeoutClusterStateListeners = new ConcurrentHashMap<>();
 
     private final AtomicReference<ClusterState> state; // last applied state
+    private final AtomicReference<ProtobufClusterState> protobufState; // last applied state
 
     private final String nodeName;
 
@@ -123,6 +125,7 @@ public ClusterApplierService(String nodeName, Settings settings, ClusterSettings
         this.clusterSettings = clusterSettings;
         this.threadPool = threadPool;
         this.state = new AtomicReference<>();
+        this.protobufState = new AtomicReference<>();
         this.nodeName = nodeName;
 
         this.slowTaskLoggingThreshold = CLUSTER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING.get(settings);
@@ -214,6 +217,17 @@ public ClusterState state() {
         return clusterState;
     }
 
+    /**
+     * The current cluster state.
+     * Should be renamed to appliedClusterState
+     */
+    public ProtobufClusterState protobufState() {
+        assert assertNotCalledFromClusterStateApplier("the applied cluster state is not yet available");
+        ProtobufClusterState clusterState = this.protobufState.get();
+        assert clusterState != null : "initial cluster state not set yet";
+        return clusterState;
+    }
+
     /**
      * Returns true if the appliedClusterState is not null
      */
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterService.java b/server/src/main/java/org/opensearch/cluster/service/ClusterService.java
index e097803d86b48..385d62b1895cc 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterService.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterService.java
@@ -42,6 +42,7 @@
 import org.opensearch.cluster.LocalNodeClusterManagerListener;
 import org.opensearch.cluster.LocalNodeMasterListener;
 import org.opensearch.cluster.NodeConnectionsService;
+import org.opensearch.cluster.ProtobufClusterState;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.routing.OperationRouting;
 import org.opensearch.cluster.routing.RerouteService;
@@ -170,6 +171,14 @@ public ClusterState state() {
         return clusterApplierService.state();
     }
 
+    /**
+     * The currently applied cluster state.
+     * TODO: Should be renamed to appliedState / appliedClusterState
+     */
+    public ProtobufClusterState protobufState() {
+        return clusterApplierService.protobufState();
+    }
+
     /**
      * Adds a high priority applier of updated cluster states.
      */
diff --git a/server/src/main/java/org/opensearch/common/network/NetworkModule.java b/server/src/main/java/org/opensearch/common/network/NetworkModule.java
index c052af41d66d9..c9ed9d59cda05 100644
--- a/server/src/main/java/org/opensearch/common/network/NetworkModule.java
+++ b/server/src/main/java/org/opensearch/common/network/NetworkModule.java
@@ -58,6 +58,9 @@
 import org.opensearch.tasks.RawTaskStatus;
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportInterceptor;
+import org.opensearch.transport.ProtobufTransportRequest;
+import org.opensearch.transport.ProtobufTransportRequestHandler;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportInterceptor;
 import org.opensearch.transport.TransportRequest;
@@ -131,6 +134,7 @@ public final class NetworkModule {
     private final Map<String, Supplier<Transport>> transportFactories = new HashMap<>();
     private final Map<String, Supplier<HttpServerTransport>> transportHttpFactories = new HashMap<>();
     private final List<TransportInterceptor> transportIntercetors = new ArrayList<>();
+    private final List<ProtobufTransportInterceptor> protobufTransportInterceptors = new ArrayList<>();
 
     /**
      * Creates a network module that custom networking classes can be plugged into.
@@ -300,4 +304,48 @@ public AsyncSender interceptSender(AsyncSender sender) {
         }
     }
 
+     /**
+     * Registers a new {@link TransportInterceptor}
+     */
+    private void registerProtobufTransportInterceptor(ProtobufTransportInterceptor interceptor) {
+        this.protobufTransportInterceptors.add(Objects.requireNonNull(interceptor, "interceptor must not be null"));
+    }
+
+    /**
+     * Returns a composite {@link ProtobufTransportInterceptor} containing all registered interceptors
+     * @see #registerProtobufTransportInterceptor(ProtobufTransportInterceptor)
+     */
+    public ProtobufTransportInterceptor getProtobufTransportInterceptor() {
+        return new ProtobufCompositeTransportInterceptor(this.protobufTransportInterceptors);
+    }
+
+    static final class ProtobufCompositeTransportInterceptor implements ProtobufTransportInterceptor {
+        final List<ProtobufTransportInterceptor> transportInterceptors;
+
+        private ProtobufCompositeTransportInterceptor(List<ProtobufTransportInterceptor> transportInterceptors) {
+            this.transportInterceptors = new ArrayList<>(transportInterceptors);
+        }
+
+        @Override
+        public <T extends ProtobufTransportRequest> ProtobufTransportRequestHandler<T> interceptHandler(
+            String action,
+            String executor,
+            boolean forceExecution,
+            ProtobufTransportRequestHandler<T> actualHandler
+        ) {
+            for (ProtobufTransportInterceptor interceptor : this.transportInterceptors) {
+                actualHandler = interceptor.interceptHandler(action, executor, forceExecution, actualHandler);
+            }
+            return actualHandler;
+        }
+
+        @Override
+        public AsyncSender interceptSender(AsyncSender sender) {
+            for (ProtobufTransportInterceptor interceptor : this.transportInterceptors) {
+                sender = interceptor.interceptSender(sender);
+            }
+            return sender;
+        }
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/common/settings/SettingsModule.java b/server/src/main/java/org/opensearch/common/settings/SettingsModule.java
index dd5502054684a..4308e1c3e98fa 100644
--- a/server/src/main/java/org/opensearch/common/settings/SettingsModule.java
+++ b/server/src/main/java/org/opensearch/common/settings/SettingsModule.java
@@ -233,6 +233,7 @@ public boolean registerDynamicSetting(Setting<?> setting) {
      * the setting during startup.
      */
     private void registerSetting(Setting<?> setting) {
+        System.out.println("Registering setting: " + setting.getKey());
         if (setting.isFiltered()) {
             if (settingsFilterPattern.contains(setting.getKey()) == false) {
                 registerSettingsFilter(setting.getKey());
diff --git a/server/src/main/java/org/opensearch/common/unit/ProtobufSizeValue.java b/server/src/main/java/org/opensearch/common/unit/ProtobufSizeValue.java
index 201b74d4a83c3..b17e0606eccd2 100644
--- a/server/src/main/java/org/opensearch/common/unit/ProtobufSizeValue.java
+++ b/server/src/main/java/org/opensearch/common/unit/ProtobufSizeValue.java
@@ -46,6 +46,14 @@ public void writeTo(CodedOutputStream out) throws IOException {
         out.writeInt64NoTag(singles());
     }
 
+    public long getSize() {
+        return size;
+    }
+
+    public SizeUnit getSizeUnit() {
+        return sizeUnit;
+    }
+
     public long singles() {
         return sizeUnit.toSingles(size);
     }
diff --git a/server/src/main/java/org/opensearch/common/unit/SizeValue.java b/server/src/main/java/org/opensearch/common/unit/SizeValue.java
index 766199ebbc8f8..7e499f5860a7f 100644
--- a/server/src/main/java/org/opensearch/common/unit/SizeValue.java
+++ b/server/src/main/java/org/opensearch/common/unit/SizeValue.java
@@ -72,6 +72,14 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeVLong(singles());
     }
 
+    public long getSize() {
+        return size;
+    }
+
+    public SizeUnit getSizeUnit() {
+        return sizeUnit;
+    }
+
     public long singles() {
         return sizeUnit.toSingles(size);
     }
diff --git a/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java b/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java
index 0ba49be01d193..1d967d9fb135a 100644
--- a/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java
+++ b/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java
@@ -368,6 +368,7 @@ void dispatchRequest(final RestRequest restRequest, final RestChannel channel, f
     }
 
     private void handleIncomingRequest(final HttpRequest httpRequest, final HttpChannel httpChannel, final Exception exception) {
+        System.out.println("HttpServerTransport.handleIncomingRequest");
         if (exception == null) {
             HttpResponse earlyResponse = corsHandler.handleInbound(httpRequest);
             if (earlyResponse != null) {
@@ -441,6 +442,7 @@ private void handleIncomingRequest(final HttpRequest httpRequest, final HttpChan
             channel = innerChannel;
         }
 
+        System.out.println("RestRequest " + restRequest);
         dispatchRequest(restRequest, channel, badRequestCause);
     }
 
diff --git a/server/src/main/java/org/opensearch/node/Node.java b/server/src/main/java/org/opensearch/node/Node.java
index d8b51b0184a66..e77e82368bd9b 100644
--- a/server/src/main/java/org/opensearch/node/Node.java
+++ b/server/src/main/java/org/opensearch/node/Node.java
@@ -78,17 +78,22 @@
 import org.opensearch.Version;
 import org.opensearch.action.ActionModule;
 import org.opensearch.action.ActionModule.DynamicActionRegistry;
+import org.opensearch.action.ActionModule.ProtobufDynamicActionRegistry;
 import org.opensearch.action.ActionType;
+import org.opensearch.action.ProtobufActionType;
 import org.opensearch.action.admin.cluster.snapshots.status.TransportNodesSnapshotsStatus;
 import org.opensearch.action.search.SearchExecutionStatsCollector;
 import org.opensearch.action.search.SearchPhaseController;
 import org.opensearch.action.search.SearchTransportService;
+import org.opensearch.action.support.ProtobufTransportAction;
 import org.opensearch.action.support.TransportAction;
 import org.opensearch.action.update.UpdateHelper;
 import org.opensearch.bootstrap.BootstrapCheck;
 import org.opensearch.bootstrap.BootstrapContext;
 import org.opensearch.client.Client;
+import org.opensearch.client.ProtobufClient;
 import org.opensearch.client.node.NodeClient;
+import org.opensearch.client.node.ProtobufNodeClient;
 import org.opensearch.cluster.ClusterInfoService;
 import org.opensearch.cluster.ClusterModule;
 import org.opensearch.cluster.ClusterName;
@@ -107,6 +112,7 @@
 import org.opensearch.cluster.metadata.TemplateUpgradeService;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
 import org.opensearch.cluster.routing.BatchedRerouteService;
 import org.opensearch.cluster.routing.RerouteService;
 import org.opensearch.cluster.routing.allocation.DiskThresholdMonitor;
@@ -134,6 +140,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.settings.SettingsModule;
 import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.common.transport.ProtobufBoundTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.BigArrays;
@@ -195,6 +202,7 @@
 import org.opensearch.plugins.PersistentTaskPlugin;
 import org.opensearch.plugins.Plugin;
 import org.opensearch.plugins.PluginsService;
+import org.opensearch.plugins.ProtobufActionPlugin;
 import org.opensearch.plugins.RepositoryPlugin;
 import org.opensearch.plugins.ScriptPlugin;
 import org.opensearch.plugins.SearchPlugin;
@@ -222,6 +230,8 @@
 import org.opensearch.tasks.TaskResultsService;
 import org.opensearch.threadpool.ExecutorBuilder;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportInterceptor;
+import org.opensearch.transport.ProtobufTransportService;
 import org.opensearch.transport.RemoteClusterService;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportInterceptor;
@@ -376,9 +386,12 @@ public static class DiscoverySettings {
     private final PluginsService pluginsService;
     private final ExtensionsManager extensionsManager;
     private final NodeClient client;
+    private final ProtobufNodeClient protobufClient;
     private final Collection<LifecycleComponent> pluginLifecycleComponents;
     private final LocalNodeFactory localNodeFactory;
+    private final ProtobufLocalNodeFactory protobufLocalNodeFactory;
     private final NodeService nodeService;
+    private final ProtobufNodeService protobufNodeService;
     private final Tracer tracer;
     final NamedWriteableRegistry namedWriteableRegistry;
     private final AtomicReference<RunnableTaskExecutionListener> runnableTaskListener;
@@ -515,6 +528,7 @@ protected Node(
             );
             resourcesToClose.add(nodeEnvironment);
             localNodeFactory = new LocalNodeFactory(settings, nodeEnvironment.nodeId());
+            protobufLocalNodeFactory = new ProtobufLocalNodeFactory(settings, nodeEnvironment.nodeId());
 
             final List<ExecutorBuilder<?>> executorBuilders = pluginsService.getExecutorBuilders(settings);
 
@@ -540,6 +554,19 @@ protected Node(
             }
             client = new NodeClient(settings, threadPool);
 
+            // final ProtobufThreadPool protobufThreadPool = new ProtobufThreadPool(settings, runnableTaskListener, executorBuilders.toArray(new ProtobufExecutorBuilder[0]));
+            // resourcesToClose.add(() -> ProtobufThreadPool.terminate(threadPool, 10, TimeUnit.SECONDS));
+            // final ResourceWatcherService resourceWatcherServiceProtobuf = new ResourceWatcherService(settings, protobufThreadPool);
+            // resourcesToClose.add(resourceWatcherServiceProtobuf);
+            // // adds the context to the DeprecationLogger so that it does not need to be injected everywhere
+            // HeaderWarning.setThreadContext(protobufThreadPool.getThreadContext());
+            // resourcesToClose.add(() -> HeaderWarning.removeThreadContext(protobufThreadPool.getThreadContext()));
+
+            // for (final ProtobufExecutorBuilder<?> builder : protobufThreadPool.builders()) {
+            //     additionalSettings.addAll(builder.getRegisteredSettings());
+            // }
+            protobufClient = new ProtobufNodeClient(settings, threadPool);
+
             final ScriptModule scriptModule = new ScriptModule(settings, pluginsService.filterPlugins(ScriptPlugin.class));
             final ScriptService scriptService = newScriptService(settings, scriptModule.engines, scriptModule.contexts);
             AnalysisModule analysisModule = new AnalysisModule(this.environment, pluginsService.filterPlugins(AnalysisPlugin.class));
@@ -799,24 +826,42 @@ protected Node(
                 )
                 .collect(Collectors.toList());
 
-            ActionModule actionModule = new ActionModule(
+            // ActionModule actionModule = new ActionModule(
+            //     settings,
+            //     clusterModule.getIndexNameExpressionResolver(),
+            //     settingsModule.getIndexScopedSettings(),
+            //     settingsModule.getClusterSettings(),
+            //     settingsModule.getSettingsFilter(),
+            //     threadPool,
+            //     pluginsService.filterPlugins(ActionPlugin.class),
+            //     client,
+            //     circuitBreakerService,
+            //     usageService,
+            //     systemIndices
+            // );
+            // modules.add(actionModule);
+
+            ActionModule protobufActionModule = new ActionModule(
                 settings,
                 clusterModule.getIndexNameExpressionResolver(),
+                clusterModule.getProtobufIndexNameExpressionResolver(),
                 settingsModule.getIndexScopedSettings(),
                 settingsModule.getClusterSettings(),
                 settingsModule.getSettingsFilter(),
                 threadPool,
                 pluginsService.filterPlugins(ActionPlugin.class),
                 client,
+                pluginsService.filterPlugins(ProtobufActionPlugin.class),
+                protobufClient,
                 circuitBreakerService,
                 usageService,
                 systemIndices,
                 identityService,
                 extensionsManager
             );
-            modules.add(actionModule);
+            modules.add(protobufActionModule);
 
-            final RestController restController = actionModule.getRestController();
+            final RestController restController = protobufActionModule.getRestController();
 
             final NetworkModule networkModule = new NetworkModule(
                 settings,
@@ -861,16 +906,27 @@ protected Node(
                 settingsModule.getClusterSettings(),
                 taskHeaders
             );
+            final ProtobufTransportService protobufTransportService = newProtobufTransportService(
+                settings,
+                transport,
+                threadPool,
+                networkModule.getProtobufTransportInterceptor(),
+                protobufLocalNodeFactory,
+                settingsModule.getClusterSettings(),
+                taskHeaders
+            );
             TopNSearchTasksLogger taskConsumer = new TopNSearchTasksLogger(settings, settingsModule.getClusterSettings());
             transportService.getTaskManager().registerTaskResourceConsumer(taskConsumer);
-            this.extensionsManager.initializeServicesAndRestHandler(
-                actionModule,
-                settingsModule,
-                transportService,
-                clusterService,
-                environment.settings(),
-                client
-            );
+            // if (FeatureFlags.isEnabled(FeatureFlags.EXTENSIONS)) {
+            //     this.extensionsManager.initializeServicesAndRestHandler(
+            //         actionModule,
+            //         settingsModule,
+            //         transportService,
+            //         clusterService,
+            //         environment.settings(),
+            //         client
+            //     );
+            // }
             final GatewayMetaState gatewayMetaState = new GatewayMetaState();
             final ResponseCollectorService responseCollectorService = new ResponseCollectorService(clusterService);
             final SearchTransportService searchTransportService = new SearchTransportService(
@@ -919,7 +975,7 @@ protected Node(
                 clusterModule.getIndexNameExpressionResolver(),
                 repositoryService,
                 transportService,
-                actionModule.getActionFilters()
+                protobufActionModule.getActionFilters()
             );
             SnapshotShardsService snapshotShardsService = new SnapshotShardsService(
                 settings,
@@ -933,7 +989,7 @@ protected Node(
                 clusterService,
                 transportService,
                 snapshotShardsService,
-                actionModule.getActionFilters()
+                protobufActionModule.getActionFilters()
             );
             RestoreService restoreService = new RestoreService(
                 clusterService,
@@ -1015,6 +1071,51 @@ protected Node(
                 fileCache,
                 taskCancellationMonitoringService
             );
+            this.protobufNodeService = new ProtobufNodeService(
+                settings,
+                threadPool,
+                monitorService,
+                discoveryModule.getDiscovery(),
+                protobufTransportService,
+                indicesService,
+                pluginsService,
+                circuitBreakerService,
+                scriptService,
+                httpServerTransport,
+                ingestService,
+                clusterService,
+                settingsModule.getSettingsFilter(),
+                responseCollectorService,
+                searchTransportService,
+                indexingPressureService,
+                searchModule.getValuesSourceRegistry().getUsageService(),
+                searchBackpressureService,
+                searchPipelineService,
+                fileCache,
+                taskCancellationMonitoringService
+            );
+            this.protobufNodeService = new ProtobufNodeService(
+                settings,
+                threadPool,
+                monitorService,
+                discoveryModule.getDiscovery(),
+                protobufTransportService,
+                indicesService,
+                pluginsService,
+                circuitBreakerService,
+                scriptService,
+                httpServerTransport,
+                ingestService,
+                clusterService,
+                settingsModule.getSettingsFilter(),
+                responseCollectorService,
+                searchTransportService,
+                indexingPressureService,
+                searchModule.getValuesSourceRegistry().getUsageService(),
+                searchBackpressureService,
+                searchPipelineService,
+                fileCache
+            );
 
             final SearchService searchService = newSearchService(
                 clusterService,
@@ -1068,10 +1169,13 @@ protected Node(
             modules.add(b -> {
                 b.bind(Node.class).toInstance(this);
                 b.bind(NodeService.class).toInstance(nodeService);
+                b.bind(ProtobufNodeService.class).toInstance(protobufNodeService);
                 b.bind(NamedXContentRegistry.class).toInstance(xContentRegistry);
                 b.bind(PluginsService.class).toInstance(pluginsService);
                 b.bind(Client.class).toInstance(client);
                 b.bind(NodeClient.class).toInstance(client);
+                b.bind(ProtobufClient.class).toInstance(protobufClient);
+                b.bind(ProtobufNodeClient.class).toInstance(protobufClient);
                 b.bind(Environment.class).toInstance(this.environment);
                 b.bind(ExtensionsManager.class).toInstance(this.extensionsManager);
                 b.bind(ThreadPool.class).toInstance(threadPool);
@@ -1104,6 +1208,7 @@ protected Node(
                     .toInstance(new SearchPhaseController(namedWriteableRegistry, searchService::aggReduceContextBuilder));
                 b.bind(Transport.class).toInstance(transport);
                 b.bind(TransportService.class).toInstance(transportService);
+                b.bind(ProtobufTransportService.class).toInstance(protobufTransportService);
                 b.bind(NetworkService.class).toInstance(networkService);
                 b.bind(UpdateHelper.class).toInstance(new UpdateHelper(scriptService));
                 b.bind(MetadataIndexUpgradeService.class).toInstance(metadataIndexUpgradeService);
@@ -1167,7 +1272,7 @@ protected Node(
             resourcesToClose.addAll(pluginLifecycleComponents);
             resourcesToClose.add(injector.getInstance(PeerRecoverySourceService.class));
             this.pluginLifecycleComponents = Collections.unmodifiableList(pluginLifecycleComponents);
-            DynamicActionRegistry dynamicActionRegistry = actionModule.getDynamicActionRegistry();
+            DynamicActionRegistry dynamicActionRegistry = protobufActionModule.getDynamicActionRegistry();
             dynamicActionRegistry.registerUnmodifiableActionMap(injector.getInstance(new Key<Map<ActionType, TransportAction>>() {
             }));
             client.initialize(
@@ -1178,8 +1283,19 @@ protected Node(
             );
             this.namedWriteableRegistry = namedWriteableRegistry;
 
+            ProtobufDynamicActionRegistry protobufDynamicActionRegistry = protobufActionModule.getProtobufDynamicActionRegistry();
+            protobufDynamicActionRegistry.registerUnmodifiableActionMap(injector.getInstance(new Key<Map<ProtobufActionType, ProtobufTransportAction>>() {
+            }));
+            protobufClient.initialize(
+                protobufDynamicActionRegistry,
+                () -> clusterService.localNode().getId(),
+                protobufTransportService.getRemoteClusterService(),
+                namedWriteableRegistry
+            );
+
             logger.debug("initializing HTTP handlers ...");
-            actionModule.initRestHandlers(() -> clusterService.state().nodes());
+            protobufActionModule.initRestHandlers(() -> clusterService.state().nodes());
+            protobufActionModule.initProtobufRestHandlers();
             logger.info("initialized");
 
             success = true;
@@ -1204,6 +1320,18 @@ protected TransportService newTransportService(
         return new TransportService(settings, transport, threadPool, interceptor, localNodeFactory, clusterSettings, taskHeaders);
     }
 
+    protected ProtobufTransportService newProtobufTransportService(
+        Settings settings,
+        Transport transport,
+        ThreadPool threadPool,
+        ProtobufTransportInterceptor interceptor,
+        Function<ProtobufBoundTransportAddress, ProtobufDiscoveryNode> localNodeFactory,
+        ClusterSettings clusterSettings,
+        Set<String> taskHeaders
+    ) {
+        return new ProtobufTransportService(settings, transport, threadPool, interceptor, localNodeFactory, clusterSettings, taskHeaders);
+    }
+
     protected void processRecoverySettings(ClusterSettings clusterSettings, RecoverySettings recoverySettings) {
         // Noop in production, overridden by tests
     }
@@ -1721,6 +1849,28 @@ DiscoveryNode getNode() {
         }
     }
 
+    private static class ProtobufLocalNodeFactory implements Function<ProtobufBoundTransportAddress, ProtobufDiscoveryNode> {
+        private final SetOnce<ProtobufDiscoveryNode> localNode = new SetOnce<>();
+        private final String persistentNodeId;
+        private final Settings settings;
+
+        private ProtobufLocalNodeFactory(Settings settings, String persistentNodeId) {
+            this.persistentNodeId = persistentNodeId;
+            this.settings = settings;
+        }
+
+        @Override
+        public ProtobufDiscoveryNode apply(ProtobufBoundTransportAddress boundTransportAddress) {
+            localNode.set(ProtobufDiscoveryNode.createLocal(settings, boundTransportAddress.publishAddress(), persistentNodeId));
+            return localNode.get();
+        }
+
+        ProtobufDiscoveryNode getNode() {
+            assert localNode.get() != null;
+            return localNode.get();
+        }
+    }
+
     /**
      * Initializes the search cache with a defined capacity.
      * The capacity of the cache is based on user configuration for {@link Node#NODE_SEARCH_CACHE_SIZE_SETTING}.
diff --git a/server/src/main/java/org/opensearch/node/ProtobufNodeService.java b/server/src/main/java/org/opensearch/node/ProtobufNodeService.java
new file mode 100644
index 0000000000000..b774178bb8122
--- /dev/null
+++ b/server/src/main/java/org/opensearch/node/ProtobufNodeService.java
@@ -0,0 +1,238 @@
+/*
+* 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.
+*/
+
+package org.opensearch.node;
+
+import org.opensearch.cluster.routing.WeightedRoutingStats;
+import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.Build;
+import org.opensearch.Version;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodeInfo;
+import org.opensearch.action.admin.cluster.node.stats.ProtobufNodeStats;
+import org.opensearch.action.admin.indices.stats.ProtobufCommonStatsFlags;
+import org.opensearch.action.search.SearchTransportService;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.settings.SettingsFilter;
+import org.opensearch.discovery.Discovery;
+import org.opensearch.http.HttpServerTransport;
+import org.opensearch.index.IndexingPressureService;
+import org.opensearch.index.store.remote.filecache.FileCache;
+import org.opensearch.indices.IndicesService;
+import org.opensearch.indices.breaker.CircuitBreakerService;
+import org.opensearch.ingest.IngestService;
+import org.opensearch.monitor.MonitorService;
+import org.opensearch.plugins.PluginsService;
+import org.opensearch.script.ScriptService;
+import org.opensearch.search.aggregations.support.AggregationUsageService;
+import org.opensearch.search.backpressure.SearchBackpressureService;
+import org.opensearch.search.pipeline.SearchPipelineService;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportService;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Services exposed to nodes
+*
+* @opensearch.internal
+*/
+public class ProtobufNodeService implements Closeable {
+    private final Settings settings;
+    private final ThreadPool threadPool;
+    private final MonitorService monitorService;
+    private final ProtobufTransportService transportService;
+    private final IndicesService indicesService;
+    private final PluginsService pluginService;
+    private final CircuitBreakerService circuitBreakerService;
+    private final IngestService ingestService;
+    private final SettingsFilter settingsFilter;
+    private final ScriptService scriptService;
+    private final HttpServerTransport httpServerTransport;
+    private final ResponseCollectorService responseCollectorService;
+    private final SearchTransportService searchTransportService;
+    private final IndexingPressureService indexingPressureService;
+    private final AggregationUsageService aggregationUsageService;
+    private final SearchBackpressureService searchBackpressureService;
+    private final SearchPipelineService searchPipelineService;
+    private final ClusterService clusterService;
+    private final Discovery discovery;
+    private final FileCache fileCache;
+
+    ProtobufNodeService(
+        Settings settings,
+        ThreadPool threadPool,
+        MonitorService monitorService,
+        Discovery discovery,
+        ProtobufTransportService transportService,
+        IndicesService indicesService,
+        PluginsService pluginService,
+        CircuitBreakerService circuitBreakerService,
+        ScriptService scriptService,
+        @Nullable HttpServerTransport httpServerTransport,
+        IngestService ingestService,
+        ClusterService clusterService,
+        SettingsFilter settingsFilter,
+        ResponseCollectorService responseCollectorService,
+        SearchTransportService searchTransportService,
+        IndexingPressureService indexingPressureService,
+        AggregationUsageService aggregationUsageService,
+        SearchBackpressureService searchBackpressureService,
+        SearchPipelineService searchPipelineService,
+        FileCache fileCache
+    ) {
+        this.settings = settings;
+        this.threadPool = threadPool;
+        this.monitorService = monitorService;
+        this.transportService = transportService;
+        this.indicesService = indicesService;
+        this.discovery = discovery;
+        this.pluginService = pluginService;
+        this.circuitBreakerService = circuitBreakerService;
+        this.httpServerTransport = httpServerTransport;
+        this.ingestService = ingestService;
+        this.settingsFilter = settingsFilter;
+        this.scriptService = scriptService;
+        this.responseCollectorService = responseCollectorService;
+        this.searchTransportService = searchTransportService;
+        this.indexingPressureService = indexingPressureService;
+        this.aggregationUsageService = aggregationUsageService;
+        this.searchBackpressureService = searchBackpressureService;
+        this.searchPipelineService = searchPipelineService;
+        this.clusterService = clusterService;
+        this.fileCache = fileCache;
+        clusterService.addStateApplier(ingestService);
+        clusterService.addStateApplier(searchPipelineService);
+    }
+
+    public ProtobufNodeInfo info(
+        boolean settings,
+        boolean os,
+        boolean process,
+        boolean jvm,
+        boolean threadPool,
+        boolean transport,
+        boolean http,
+        boolean plugin,
+        boolean ingest,
+        boolean aggs,
+        boolean indices,
+        boolean searchPipeline
+    ) {
+        ProtobufNodeInfo.Builder builder = ProtobufNodeInfo.builder(Version.CURRENT, Build.CURRENT, transportService.getLocalNode());
+        if (settings) {
+            builder.setSettings(settingsFilter.filter(this.settings));
+        }
+        // if (os) {
+        //     builder.setOs(monitorService.osService().info());
+        // }
+        // if (process) {
+        //     builder.setProcess(monitorService.processService().info());
+        // }
+        // if (jvm) {
+        //     builder.setJvm(monitorService.jvmService().info());
+        // }
+        if (threadPool) {
+            builder.setThreadPool(this.threadPool.protobufInfo());
+        }
+        if (transport) {
+            builder.setTransport(transportService.protobufInfo());
+        }
+        // if (http && httpServerTransport != null) {
+        //     builder.setHttp(httpServerTransport.info());
+        // }
+        // if (plugin && pluginService != null) {
+        //     builder.setPlugins(pluginService.info());
+        // }
+        // if (ingest && ingestService != null) {
+        //     builder.setIngest(ingestService.info());
+        // }
+        // if (aggs && aggregationUsageService != null) {
+        //     builder.setAggsInfo(aggregationUsageService.info());
+        // }
+        if (indices) {
+            builder.setTotalIndexingBuffer(indicesService.getTotalIndexingBufferBytes());
+        }
+        // if (searchPipeline && searchPipelineService != null) {
+        //     builder.setSearchPipelineInfo(searchPipelineService.info());
+        // }
+        return builder.build();
+    }
+
+    public ProtobufNodeStats stats(
+        ProtobufCommonStatsFlags indices,
+        boolean os,
+        boolean process,
+        boolean jvm,
+        boolean threadPool,
+        boolean fs,
+        boolean transport,
+        boolean http,
+        boolean circuitBreaker,
+        boolean script,
+        boolean discoveryStats,
+        boolean ingest,
+        boolean adaptiveSelection,
+        boolean scriptCache,
+        boolean indexingPressure,
+        boolean shardIndexingPressure,
+        boolean searchBackpressure,
+        boolean clusterManagerThrottling,
+        boolean weightedRoutingStats,
+        boolean fileCacheStats
+    ) {
+        // for indices stats we want to include previous allocated shards stats as well (it will
+        // only be applied to the sensible ones to use, like refresh/merge/flush/indexing stats)
+        return new ProtobufNodeStats(
+            transportService.getLocalNode(),
+            System.currentTimeMillis(),
+            null,
+            null,
+            null,
+            null,
+            threadPool ? this.threadPool.protobufStats() : null,
+            null,
+            transport ? transportService.stats() : null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null
+        );
+    }
+
+    public IngestService getIngestService() {
+        return ingestService;
+    }
+
+    public MonitorService getMonitorService() {
+        return monitorService;
+    }
+
+    public SearchBackpressureService getSearchBackpressureService() {
+        return searchBackpressureService;
+    }
+
+    @Override
+    public void close() throws IOException {
+        IOUtils.close(indicesService);
+    }
+
+    /**
+     * Wait for the node to be effectively closed.
+    * @see IndicesService#awaitClose(long, TimeUnit)
+    */
+    public boolean awaitClose(long timeout, TimeUnit timeUnit) throws InterruptedException {
+        return indicesService.awaitClose(timeout, timeUnit);
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/node/ProtobufReportingService.java b/server/src/main/java/org/opensearch/node/ProtobufReportingService.java
index 9d9f507ce8cb3..d6e54f245ea95 100644
--- a/server/src/main/java/org/opensearch/node/ProtobufReportingService.java
+++ b/server/src/main/java/org/opensearch/node/ProtobufReportingService.java
@@ -16,7 +16,7 @@
 * @opensearch.internal
 */
 public interface ProtobufReportingService<I extends ProtobufReportingService.ProtobufInfo> {
-    I info();
+    I protobufInfo();
 
     /**
      * Information interface.
diff --git a/server/src/main/java/org/opensearch/plugins/ProtobufActionPlugin.java b/server/src/main/java/org/opensearch/plugins/ProtobufActionPlugin.java
new file mode 100644
index 0000000000000..caed963482a31
--- /dev/null
+++ b/server/src/main/java/org/opensearch/plugins/ProtobufActionPlugin.java
@@ -0,0 +1,205 @@
+/*
+* 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.
+*/
+
+package org.opensearch.plugins;
+
+import org.opensearch.action.ProtobufActionType;
+import org.opensearch.action.ProtobufActionRequest;
+import org.opensearch.action.ProtobufActionResponse;
+import org.opensearch.action.RequestValidators;
+import org.opensearch.action.admin.indices.alias.IndicesAliasesRequest;
+import org.opensearch.action.admin.indices.mapping.put.PutMappingRequest;
+import org.opensearch.action.support.ProtobufActionFilter;
+import org.opensearch.action.support.ProtobufTransportAction;
+import org.opensearch.action.support.TransportActions;
+import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.common.Strings;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.IndexScopedSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.settings.SettingsFilter;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.rest.RestController;
+import org.opensearch.rest.ProtobufRestHandler;
+import org.opensearch.rest.RestHeaderDefinition;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+import java.util.stream.Collectors;
+
+/**
+ * An additional extension point for {@link Plugin}s that extends OpenSearch's scripting functionality. Implement it like this:
+* <pre>{@code
+*   {@literal @}Override
+*   public List<ActionHandler<?, ?>> getActions() {
+*       return Arrays.asList(new ActionHandler<>(ReindexAction.INSTANCE, TransportReindexAction.class),
+*               new ActionHandler<>(UpdateByQueryAction.INSTANCE, TransportUpdateByQueryAction.class),
+*               new ActionHandler<>(DeleteByQueryAction.INSTANCE, TransportDeleteByQueryAction.class),
+*               new ActionHandler<>(RethrottleAction.INSTANCE, TransportRethrottleAction.class));
+*   }
+* }</pre>
+*
+* @opensearch.api
+*/
+public interface ProtobufActionPlugin {
+    /**
+     * Actions added by this plugin.
+    */
+    default List<ActionHandler<? extends ProtobufActionRequest, ? extends ProtobufActionResponse>> getActions() {
+        return Collections.emptyList();
+    }
+
+    /**
+     * Client actions added by this plugin. This defaults to all of the {@linkplain ProtobufActionType} in
+    * {@linkplain ProtobufActionPlugin#getActions()}.
+    */
+    default List<ProtobufActionType<? extends ProtobufActionResponse>> getClientActions() {
+        return getActions().stream().map(a -> a.action).collect(Collectors.toList());
+    }
+
+    /**
+     * ProtobufActionType filters added by this plugin.
+    */
+    default List<ProtobufActionFilter> getActionFilters() {
+        return Collections.emptyList();
+    }
+
+    /**
+     * Rest handlers added by this plugin.
+    */
+    default List<ProtobufRestHandler> getRestHandlers(
+        Settings settings,
+        RestController restController,
+        ClusterSettings clusterSettings,
+        IndexScopedSettings indexScopedSettings,
+        SettingsFilter settingsFilter,
+        IndexNameExpressionResolver indexNameExpressionResolver,
+        Supplier<DiscoveryNodes> nodesInCluster
+    ) {
+        return Collections.emptyList();
+    }
+
+    /**
+     * Returns headers which should be copied through rest requests on to internal requests.
+    */
+    default Collection<RestHeaderDefinition> getRestHeaders() {
+        return Collections.emptyList();
+    }
+
+    /**
+     * Returns headers which should be copied from internal requests into tasks.
+    */
+    default Collection<String> getTaskHeaders() {
+        return Collections.emptyList();
+    }
+
+    /**
+     * Returns a function used to wrap each rest request before handling the request.
+    * The returned {@link UnaryOperator} is called for every incoming rest request and receives
+    * the original rest handler as it's input. This allows adding arbitrary functionality around
+    * rest request handlers to do for instance logging or authentication.
+    * A simple example of how to only allow GET request is here:
+    * <pre>
+    * {@code
+    *    UnaryOperator<ProtobufRestHandler> getRestHandlerWrapper(ThreadContext threadContext) {
+    *      return originalHandler -> (ProtobufRestHandler) (request, channel, client) -> {
+    *        if (request.method() != Method.GET) {
+    *          throw new IllegalStateException("only GET requests are allowed");
+    *        }
+    *        originalHandler.handleRequest(request, channel, client);
+    *      };
+    *    }
+    * }
+    * </pre>
+    *
+    * Note: Only one installed plugin may implement a rest wrapper.
+    */
+    default UnaryOperator<ProtobufRestHandler> getRestHandlerWrapper(ThreadContext threadContext) {
+        return null;
+    }
+
+    /**
+     *  Class responsible for handing Transport Actions
+    *
+    * @opensearch.internal
+    */
+    final class ActionHandler<Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> {
+        private final ProtobufActionType<Response> action;
+        private final Class<? extends ProtobufTransportAction<Request, Response>> transportAction;
+        private final Class<?>[] supportTransportActions;
+
+        /**
+         * Create a record of an action, the {@linkplain ProtobufTransportAction} that handles it, and any supporting {@linkplain TransportActions}
+        * that are needed by that {@linkplain ProtobufTransportAction}.
+        */
+        public ActionHandler(
+            ProtobufActionType<Response> action,
+            Class<? extends ProtobufTransportAction<Request, Response>> transportAction,
+            Class<?>... supportTransportActions
+        ) {
+            this.action = action;
+            this.transportAction = transportAction;
+            this.supportTransportActions = supportTransportActions;
+        }
+
+        public ProtobufActionType<Response> getAction() {
+            return action;
+        }
+
+        public Class<? extends ProtobufTransportAction<Request, Response>> getTransportAction() {
+            return transportAction;
+        }
+
+        public Class<?>[] getSupportTransportActions() {
+            return supportTransportActions;
+        }
+
+        @Override
+        public String toString() {
+            StringBuilder b = new StringBuilder().append(action.name()).append(" is handled by ").append(transportAction.getName());
+            if (supportTransportActions.length > 0) {
+                b.append('[').append(Strings.arrayToCommaDelimitedString(supportTransportActions)).append(']');
+            }
+            return b.toString();
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj == null || obj.getClass() != ActionHandler.class) {
+                return false;
+            }
+            ActionHandler<?, ?> other = (ActionHandler<?, ?>) obj;
+            return Objects.equals(action, other.action)
+                && Objects.equals(transportAction, other.transportAction)
+                && Objects.deepEquals(supportTransportActions, other.supportTransportActions);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(action, transportAction, supportTransportActions);
+        }
+    }
+
+    /**
+     * Returns a collection of validators that are used by {@link RequestValidators} to validate a
+    * {@link org.opensearch.action.admin.indices.mapping.put.PutMappingRequest} before the executing it.
+    */
+    default Collection<RequestValidators.RequestValidator<PutMappingRequest>> mappingRequestValidators() {
+        return Collections.emptyList();
+    }
+
+    default Collection<RequestValidators.RequestValidator<IndicesAliasesRequest>> indicesAliasesRequestValidators() {
+        return Collections.emptyList();
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/rest/MethodHandlers.java b/server/src/main/java/org/opensearch/rest/MethodHandlers.java
index 8c29bf2e66036..7907b5fc3b041 100644
--- a/server/src/main/java/org/opensearch/rest/MethodHandlers.java
+++ b/server/src/main/java/org/opensearch/rest/MethodHandlers.java
@@ -47,15 +47,26 @@ final class MethodHandlers {
 
     private final String path;
     private final Map<RestRequest.Method, RestHandler> methodHandlers;
+    private final Map<RestRequest.Method, ProtobufRestHandler> protobufMethodHandlers;
 
     MethodHandlers(String path, RestHandler handler, RestRequest.Method... methods) {
         this.path = path;
         this.methodHandlers = new HashMap<>(methods.length);
+        this.protobufMethodHandlers = new HashMap<>(methods.length);
         for (RestRequest.Method method : methods) {
             methodHandlers.put(method, handler);
         }
     }
 
+    MethodHandlers(String path, ProtobufRestHandler handler, RestRequest.Method... methods) {
+        this.path = path;
+        this.methodHandlers = new HashMap<>(methods.length);
+        this.protobufMethodHandlers = new HashMap<>(methods.length);
+        for (RestRequest.Method method : methods) {
+            protobufMethodHandlers.put(method, handler);
+        }
+    }
+
     /**
      * Add a handler for an additional array of methods. Note that {@code MethodHandlers}
      * does not allow replacing the handler for an already existing method.
@@ -70,6 +81,20 @@ MethodHandlers addMethods(RestHandler handler, RestRequest.Method... methods) {
         return this;
     }
 
+    /**
+     * Add a handler for an additional array of methods. Note that {@code MethodHandlers}
+     * does not allow replacing the handler for an already existing method.
+     */
+    MethodHandlers addProtobufMethods(ProtobufRestHandler handler, RestRequest.Method... methods) {
+        for (RestRequest.Method method : methods) {
+            ProtobufRestHandler existing = protobufMethodHandlers.putIfAbsent(method, handler);
+            if (existing != null) {
+                throw new IllegalArgumentException("Cannot replace existing handler for [" + path + "] for method: " + method);
+            }
+        }
+        return this;
+    }
+
     /**
      * Returns the handler for the given method or {@code null} if none exists.
      */
@@ -78,6 +103,14 @@ RestHandler getHandler(RestRequest.Method method) {
         return methodHandlers.get(method);
     }
 
+    /**
+     * Returns the handler for the given method or {@code null} if none exists.
+     */
+    @Nullable
+    ProtobufRestHandler getProtobufHandler(RestRequest.Method method) {
+        return protobufMethodHandlers.get(method);
+    }
+
     /**
      * Return a set of all valid HTTP methods for the particular path
      */
diff --git a/server/src/main/java/org/opensearch/rest/ProtobufRestHandler.java b/server/src/main/java/org/opensearch/rest/ProtobufRestHandler.java
index 7224847832d5b..c585dd52b7c03 100644
--- a/server/src/main/java/org/opensearch/rest/ProtobufRestHandler.java
+++ b/server/src/main/java/org/opensearch/rest/ProtobufRestHandler.java
@@ -23,7 +23,7 @@
 * @opensearch.api
 */
 @FunctionalInterface
-public interface ProtobufRestHandler extends ClientAgnosticRestHandler<ProtobufNodeClient> {
+public interface ProtobufRestHandler {
 
     /**
      * Handles a rest request.
diff --git a/server/src/main/java/org/opensearch/rest/RestBaseHandler.java b/server/src/main/java/org/opensearch/rest/RestBaseHandler.java
new file mode 100644
index 0000000000000..ba51a918e2427
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/RestBaseHandler.java
@@ -0,0 +1,189 @@
+/*
+* 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.
+*/
+
+package org.opensearch.rest;
+
+import org.opensearch.client.node.ProtobufNodeClient;
+import org.opensearch.core.xcontent.XContent;
+import org.opensearch.rest.RestRequest.Method;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * Handler for REST requests
+*
+* @opensearch.api
+*/
+@FunctionalInterface
+public interface RestBaseHandler<T> {
+
+    /**
+     * Handles a rest request.
+    * @param request The request to handle
+    * @param channel The channel to write the request response to
+    * @param client A client to use to make internal requests on behalf of the original request
+    */
+    void handleRequest(RestRequest request, RestChannel channel, T client) throws Exception;
+
+    default boolean canTripCircuitBreaker() {
+        return true;
+    }
+
+    /**
+     * Indicates if the RestHandler supports content as a stream. A stream would be multiple objects delineated by
+     * {@link XContent#streamSeparator()}. If a handler returns true this will affect the types of content that can be sent to
+     * this endpoint.
+     */
+    default boolean supportsContentStream() {
+        return false;
+    }
+
+    /**
+     * Indicates if the RestHandler supports working with pooled buffers. If the request handler will not escape the return
+     * {@link RestRequest#content()} or any buffers extracted from it then there is no need to make a copies of any pooled buffers in the
+     * {@link RestRequest} instance before passing a request to this handler. If this instance does not support pooled/unsafe buffers
+     * {@link RestRequest#ensureSafeBuffers()} should be called on any request before passing it to {@link #handleRequest}.
+     *
+     * @return true iff the handler supports requests that make use of pooled buffers
+     */
+    default boolean allowsUnsafeBuffers() {
+        return false;
+    }
+
+    // /**
+    //  * The list of {@link Route}s that this RestHandler is responsible for handling.
+    //  */
+    // default List<Route> routes() {
+    //     return Collections.emptyList();
+    // }
+
+    /**
+     * A list of routes handled by this RestHandler that are deprecated and do not have a direct
+     * replacement. If changing the {@code path} or {@code method} of a route,
+     * use {@link #replacedRoutes()}.
+     */
+    default List<DeprecatedRoute> deprecatedRoutes() {
+        return Collections.emptyList();
+    }
+
+    /**
+     * A list of routes handled by this RestHandler that have had their {@code path} and/or
+     * {@code method} changed. The pre-existing {@code route} will be registered
+     * as deprecated alongside the updated {@code route}.
+     */
+    default List<ReplacedRoute> replacedRoutes() {
+        return Collections.emptyList();
+    }
+
+    /**
+     * Route for the request.
+    *
+    * @opensearch.internal
+    */
+    class Route {
+
+        private final String path;
+        private final Method method;
+
+        public Route(Method method, String path) {
+            this.path = path;
+            this.method = method;
+        }
+
+        public String getPath() {
+            return path;
+        }
+
+        public Method getMethod() {
+            return method;
+        }
+    }
+
+    /**
+     * Represents an API that has been deprecated and is slated for removal.
+    */
+    class DeprecatedRoute extends Route {
+
+        private final String deprecationMessage;
+
+        public DeprecatedRoute(Method method, String path, String deprecationMessage) {
+            super(method, path);
+            this.deprecationMessage = deprecationMessage;
+        }
+
+        public String getDeprecationMessage() {
+            return deprecationMessage;
+        }
+    }
+
+    /**
+     * Represents an API that has had its {@code path} or {@code method} changed. Holds both the
+    * new and previous {@code path} and {@code method} combination.
+    */
+    class ReplacedRoute extends Route {
+
+        private final String deprecatedPath;
+        private final Method deprecatedMethod;
+
+        /**
+         * Construct replaced routes using new and deprocated methods and new and deprecated paths
+        * @param method route method
+        * @param path new route path
+        * @param deprecatedMethod deprecated method
+        * @param deprecatedPath deprecated path
+        */
+        public ReplacedRoute(Method method, String path, Method deprecatedMethod, String deprecatedPath) {
+            super(method, path);
+            this.deprecatedMethod = deprecatedMethod;
+            this.deprecatedPath = deprecatedPath;
+        }
+
+        /**
+         * Construct replaced routes using route method, new and deprecated paths
+        * This constructor can be used when both new and deprecated paths use the same method
+        * @param method route method
+        * @param path new route path
+        * @param deprecatedPath deprecated path
+        */
+        public ReplacedRoute(Method method, String path, String deprecatedPath) {
+            this(method, path, method, deprecatedPath);
+        }
+
+        /**
+         * Construct replaced routes using route, new and deprecated prefixes
+        * @param route route
+        * @param prefix new route prefix
+        * @param deprecatedPrefix deprecated prefix
+        */
+        public ReplacedRoute(Route route, String prefix, String deprecatedPrefix) {
+            this(route.getMethod(), prefix + route.getPath(), deprecatedPrefix + route.getPath());
+        }
+
+        public String getDeprecatedPath() {
+            return deprecatedPath;
+        }
+
+        public Method getDeprecatedMethod() {
+            return deprecatedMethod;
+        }
+    }
+
+    /**
+     * Construct replaced routes using routes template and prefixes for new and deprecated paths
+    * @param routes routes
+    * @param prefix new prefix
+    * @param deprecatedPrefix deprecated prefix
+    * @return new list of API routes prefixed with the prefix string
+    */
+    static List<ReplacedRoute> replaceRoutes(List<Route> routes, final String prefix, final String deprecatedPrefix) {
+        return routes.stream().map(route -> new ReplacedRoute(route, prefix, deprecatedPrefix)).collect(Collectors.toList());
+    }
+}
diff --git a/server/src/main/java/org/opensearch/rest/RestController.java b/server/src/main/java/org/opensearch/rest/RestController.java
index 1a8bddc094d26..9710ab5497c36 100644
--- a/server/src/main/java/org/opensearch/rest/RestController.java
+++ b/server/src/main/java/org/opensearch/rest/RestController.java
@@ -37,6 +37,7 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.OpenSearchException;
 import org.opensearch.client.node.NodeClient;
+import org.opensearch.client.node.ProtobufNodeClient;
 import org.opensearch.common.Nullable;
 import org.opensearch.core.common.breaker.CircuitBreaker;
 import org.opensearch.core.common.bytes.BytesArray;
@@ -110,8 +111,12 @@ public class RestController implements HttpServerTransport.Dispatcher {
 
     private final UnaryOperator<RestHandler> handlerWrapper;
 
+    private final UnaryOperator<ProtobufRestHandler> handlerProtobufWrapper;
+
     private final NodeClient client;
 
+    private final ProtobufNodeClient protobufClient;
+
     private final CircuitBreakerService circuitBreakerService;
 
     /** Rest headers that are copied to internal requests made during a rest request. */
@@ -133,7 +138,9 @@ public RestController(
             handlerWrapper = h -> h; // passthrough if no wrapper set
         }
         this.handlerWrapper = handlerWrapper;
+        this.handlerProtobufWrapper = null;
         this.client = client;
+        this.protobufClient = null;
         this.circuitBreakerService = circuitBreakerService;
         this.identityService = identityService;
         registerHandlerNoWrap(
@@ -143,6 +150,35 @@ public RestController(
         );
     }
 
+    public RestController(
+        Set<RestHeaderDefinition> headersToCopy,
+        UnaryOperator<RestHandler> handlerWrapper,
+        NodeClient client,
+        UnaryOperator<ProtobufRestHandler> handlerProtobufWrapper,
+        ProtobufNodeClient protobufNodeClient,
+        CircuitBreakerService circuitBreakerService,
+        UsageService usageService
+    ) {
+        this.headersToCopy = headersToCopy;
+        this.usageService = usageService;
+        if (handlerProtobufWrapper == null) {
+            handlerProtobufWrapper = h -> h; // passthrough if no wrapper set
+        }
+        if (handlerWrapper == null) {
+            handlerWrapper = h -> h; // passthrough if no wrapper set
+        }
+        this.handlerProtobufWrapper = handlerProtobufWrapper;
+        this.protobufClient = protobufNodeClient;
+        this.client = client;
+        this.handlerWrapper = handlerWrapper;
+        this.circuitBreakerService = circuitBreakerService;
+        registerProtobufHandlerNoWrap(
+            RestRequest.Method.GET,
+            "/favicon.ico",
+            (request, channel, clnt) -> channel.sendResponse(new BytesRestResponse(RestStatus.OK, "image/x-icon", FAVICON_RESPONSE))
+        );
+    }
+
     /**
      * Registers a REST handler to be executed when the provided {@code method} and {@code path} match the request.
      *
@@ -217,6 +253,13 @@ protected void registerHandler(RestRequest.Method method, String path, RestHandl
         registerHandlerNoWrap(method, path, handlerWrapper.apply(handler));
     }
 
+    protected void registerProtobufHandler(RestRequest.Method method, String path, ProtobufRestHandler handler) {
+        if (handler instanceof ProtobufBaseRestHandler) {
+            usageService.addProtobufRestHandler((ProtobufBaseRestHandler) handler);
+        }
+        registerProtobufHandlerNoWrap(method, path, handlerProtobufWrapper.apply(handler));
+    }
+
     private void registerHandlerNoWrap(RestRequest.Method method, String path, RestHandler maybeWrappedHandler) {
         handlers.insertOrUpdate(
             path,
@@ -225,11 +268,19 @@ private void registerHandlerNoWrap(RestRequest.Method method, String path, RestH
         );
     }
 
+    private void registerProtobufHandlerNoWrap(RestRequest.Method method, String path, ProtobufRestHandler maybeWrappedHandler) {
+        handlers.insertOrUpdate(
+            path,
+            new MethodHandlers(path, maybeWrappedHandler, method),
+            (mHandlers, newMHandler) -> mHandlers.addProtobufMethods(maybeWrappedHandler, method)
+        );
+    }
+
     /**
      * Registers a REST handler with the controller. The REST handler declares the {@code method}
      * and {@code path} combinations.
      */
-    public void registerHandler(final RestHandler restHandler) {
+    public void registerHandler(final RestHandler restHandler) {    
         restHandler.routes().forEach(route -> registerHandler(route.getMethod(), route.getPath(), restHandler));
         restHandler.deprecatedRoutes()
             .forEach(route -> registerAsDeprecatedHandler(route.getMethod(), route.getPath(), restHandler, route.getDeprecationMessage()));
@@ -245,8 +296,31 @@ public void registerHandler(final RestHandler restHandler) {
             );
     }
 
+    /**
+     * Registers a REST handler with the controller. The REST handler declares the {@code method}
+     * and {@code path} combinations.
+     */
+    public void registerProtobufHandler(final ProtobufRestHandler restHandler) {    
+        System.out.println("Registering route");
+        restHandler.routes().forEach(route -> System.out.println(route.getMethod() + " " + route.getPath()));
+        restHandler.routes().forEach(route -> registerProtobufHandler(route.getMethod(), route.getPath(), restHandler));
+        // restHandler.deprecatedRoutes()
+        //     .forEach(route -> registerAsDeprecatedHandler(route.getMethod(), route.getPath(), restHandler, route.getDeprecationMessage()));
+        // restHandler.replacedRoutes()
+        //     .forEach(
+        //         route -> registerWithDeprecatedHandler(
+        //             route.getMethod(),
+        //             route.getPath(),
+        //             restHandler,
+        //             route.getDeprecatedMethod(),
+        //             route.getDeprecatedPath()
+        //         )
+        //     );
+    }
+
     @Override
     public void dispatchRequest(RestRequest request, RestChannel channel, ThreadContext threadContext) {
+        System.out.println("Dispatching request");
         try {
             tryAllHandlers(request, channel, threadContext);
         } catch (Exception e) {
@@ -325,6 +399,98 @@ private void dispatchRequest(RestRequest request, RestChannel channel, RestHandl
         }
     }
 
+    private void dispatchProtobufRequest(RestRequest request, RestChannel channel, ProtobufRestHandler handler) throws Exception {
+        System.out.println("Dispatching protobuf request");
+        final int contentLength = request.content().length();
+        if (contentLength > 0) {
+            final MediaType mediaType = request.getMediaType();
+            if (mediaType == null) {
+                sendContentTypeErrorMessage(request.getAllHeaderValues("Content-Type"), channel);
+                return;
+            }
+            if (handler.supportsContentStream() && mediaType != XContentType.JSON && mediaType != XContentType.SMILE) {
+                channel.sendResponse(
+                    BytesRestResponse.createSimpleErrorResponse(
+                        channel,
+                        RestStatus.NOT_ACCEPTABLE,
+                        "Content-Type [" + mediaType + "] does not support stream parsing. Use JSON or SMILE instead"
+                    )
+                );
+                return;
+            }
+        }
+        RestChannel responseChannel = channel;
+        try {
+            if (handler.canTripCircuitBreaker()) {
+                inFlightRequestsBreaker(circuitBreakerService).addEstimateBytesAndMaybeBreak(contentLength, "<http_request>");
+            } else {
+                inFlightRequestsBreaker(circuitBreakerService).addWithoutBreaking(contentLength);
+            }
+            // iff we could reserve bytes for the request we need to send the response also over this channel
+            responseChannel = new ResourceHandlingHttpChannel(channel, circuitBreakerService, contentLength);
+            // TODO: Count requests double in the circuit breaker if they need copying?
+            if (handler.allowsUnsafeBuffers() == false) {
+                request.ensureSafeBuffers();
+            }
+            if (handler.allowSystemIndexAccessByDefault() == false && request.header(OPENSEARCH_PRODUCT_ORIGIN_HTTP_HEADER) == null) {
+                // The OPENSEARCH_PRODUCT_ORIGIN_HTTP_HEADER indicates that the request is coming from an OpenSearch product with a plan
+                // to move away from direct access to system indices, and thus deprecation warnings should not be emitted.
+                // This header is intended for internal use only.
+                protobufClient.threadPool().getThreadContext().putHeader(SYSTEM_INDEX_ACCESS_CONTROL_HEADER_KEY, Boolean.FALSE.toString());
+            }
+
+            handler.handleRequest(request, responseChannel, protobufClient);
+        } catch (Exception e) {
+            responseChannel.sendResponse(new BytesRestResponse(responseChannel, e));
+        }
+    }
+
+    private void dispatchProtobufRequest(RestRequest request, RestChannel channel, ProtobufRestHandler handler) throws Exception {
+        System.out.println("Dispatching protobuf request");
+        final int contentLength = request.content().length();
+        if (contentLength > 0) {
+            final XContentType xContentType = request.getXContentType();
+            if (xContentType == null) {
+                sendContentTypeErrorMessage(request.getAllHeaderValues("Content-Type"), channel);
+                return;
+            }
+            if (handler.supportsContentStream() && xContentType != XContentType.JSON && xContentType != XContentType.SMILE) {
+                channel.sendResponse(
+                    BytesRestResponse.createSimpleErrorResponse(
+                        channel,
+                        RestStatus.NOT_ACCEPTABLE,
+                        "Content-Type [" + xContentType + "] does not support stream parsing. Use JSON or SMILE instead"
+                    )
+                );
+                return;
+            }
+        }
+        RestChannel responseChannel = channel;
+        try {
+            if (handler.canTripCircuitBreaker()) {
+                inFlightRequestsBreaker(circuitBreakerService).addEstimateBytesAndMaybeBreak(contentLength, "<http_request>");
+            } else {
+                inFlightRequestsBreaker(circuitBreakerService).addWithoutBreaking(contentLength);
+            }
+            // iff we could reserve bytes for the request we need to send the response also over this channel
+            responseChannel = new ResourceHandlingHttpChannel(channel, circuitBreakerService, contentLength);
+            // TODO: Count requests double in the circuit breaker if they need copying?
+            if (handler.allowsUnsafeBuffers() == false) {
+                request.ensureSafeBuffers();
+            }
+            if (handler.allowSystemIndexAccessByDefault() == false && request.header(OPENSEARCH_PRODUCT_ORIGIN_HTTP_HEADER) == null) {
+                // The OPENSEARCH_PRODUCT_ORIGIN_HTTP_HEADER indicates that the request is coming from an OpenSearch product with a plan
+                // to move away from direct access to system indices, and thus deprecation warnings should not be emitted.
+                // This header is intended for internal use only.
+                protobufClient.threadPool().getThreadContext().putHeader(SYSTEM_INDEX_ACCESS_CONTROL_HEADER_KEY, Boolean.FALSE.toString());
+            }
+
+            handler.handleRequest(request, responseChannel, protobufClient);
+        } catch (Exception e) {
+            responseChannel.sendResponse(new BytesRestResponse(responseChannel, e));
+        }
+    }
+
     private boolean handleNoHandlerFound(String rawPath, RestRequest.Method method, String uri, RestChannel channel) {
         // Get the map of matching handlers for a request, for the full set of HTTP methods.
         final Set<RestRequest.Method> validMethodSet = getValidHandlerMethodSet(rawPath);
@@ -356,6 +522,8 @@ private void sendContentTypeErrorMessage(@Nullable List<String> contentTypeHeade
     }
 
     private void tryAllHandlers(final RestRequest request, final RestChannel channel, final ThreadContext threadContext) throws Exception {
+        System.out.println("Trying all handlers");
+        System.out.println("Request: " + request.toString());
         for (final RestHeaderDefinition restHeader : headersToCopy) {
             final String name = restHeader.getName();
             final List<String> headerValues = request.getAllHeaderValues(name);
@@ -387,6 +555,9 @@ private void tryAllHandlers(final RestRequest request, final RestChannel channel
         final String rawPath = request.rawPath();
         final String uri = request.uri();
         final RestRequest.Method requestMethod;
+        System.out.println("raw path: " + rawPath);
+        System.out.println("uri: " + uri);
+        System.out.println("request method: " + request.method().toString());
         try {
             // Resolves the HTTP method and fails if the method is invalid
             requestMethod = request.method();
@@ -394,23 +565,40 @@ private void tryAllHandlers(final RestRequest request, final RestChannel channel
             Iterator<MethodHandlers> allHandlers = getAllHandlers(request.params(), rawPath);
             while (allHandlers.hasNext()) {
                 final RestHandler handler;
+                final ProtobufRestHandler protobufHandler;
+                System.out.println("All handlers has next");
                 final MethodHandlers handlers = allHandlers.next();
+                System.out.println("Handlers: " + handlers);
                 if (handlers == null) {
+                    System.out.println("Handlers is null");
                     handler = null;
+                    protobufHandler = null;
                 } else {
-                    handler = handlers.getHandler(requestMethod);
+                    if (rawPath.contains("protobuf")) {
+                        handler = null;
+                        protobufHandler = handlers.getProtobufHandler(requestMethod);
+                        System.out.println("Protobuf handler: " + protobufHandler);
+                    } else {
+                        protobufHandler = null;
+                        handler = handlers.getHandler(requestMethod);
+                        System.out.println("Handler: " + handler);
+                    }
                 }
-                if (handler == null) {
+                if (handler == null && protobufHandler == null) {
                     if (handleNoHandlerFound(rawPath, requestMethod, uri, channel)) {
                         return;
                     }
                 } else {
+                    if (rawPath.contains("protobuf")) {
+                        dispatchProtobufRequest(request, channel, protobufHandler);
+                    } else {
                     if (FeatureFlags.isEnabled(FeatureFlags.IDENTITY)) {
                         if (!handleAuthenticateUser(request, channel)) {
                             return;
                         }
                     }
-                    dispatchRequest(request, channel, handler);
+                        dispatchRequest(request, channel, handler);
+                    }
                     return;
                 }
             }
@@ -423,6 +611,9 @@ private void tryAllHandlers(final RestRequest request, final RestChannel channel
     }
 
     Iterator<MethodHandlers> getAllHandlers(@Nullable Map<String, String> requestParamsRef, String rawPath) {
+        System.out.println("Getting all handlers");
+        System.out.println("Request params: " + requestParamsRef);
+        System.out.println("Raw path: " + rawPath);
         final Supplier<Map<String, String>> paramsSupplier;
         if (requestParamsRef == null) {
             paramsSupplier = () -> null;
diff --git a/server/src/main/java/org/opensearch/rest/RestHandler.java b/server/src/main/java/org/opensearch/rest/RestHandler.java
index 5b1583f260da0..7832649e8ad32 100644
--- a/server/src/main/java/org/opensearch/rest/RestHandler.java
+++ b/server/src/main/java/org/opensearch/rest/RestHandler.java
@@ -47,7 +47,7 @@
  * @opensearch.api
  */
 @FunctionalInterface
-public interface RestHandler extends ClientAgnosticRestHandler<NodeClient> {
+public interface RestHandler {
 
     /**
      * Handles a rest request.
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestCatAction.java b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestCatAction.java
new file mode 100644
index 0000000000000..ec432fe6e64e1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestCatAction.java
@@ -0,0 +1,58 @@
+/*
+* 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.
+*/
+
+package org.opensearch.rest.action.cat;
+
+import org.opensearch.client.node.ProtobufNodeClient;
+import org.opensearch.rest.ProtobufBaseRestHandler;
+import org.opensearch.rest.BytesRestResponse;
+import org.opensearch.rest.RestRequest;
+import org.opensearch.rest.RestStatus;
+
+import java.io.IOException;
+import java.util.List;
+
+import static java.util.Collections.singletonList;
+import static org.opensearch.rest.RestRequest.Method.GET;
+
+/**
+ * Base _cat API endpoint
+*
+* @opensearch.api
+*/
+public class ProtobufRestCatAction extends ProtobufBaseRestHandler {
+
+    private static final String CAT = "=^.^=";
+    private static final String CAT_NL = CAT + "\n";
+    private final String HELP;
+
+    public ProtobufRestCatAction(List<ProtobufAbstractCatAction> catActions) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(CAT_NL);
+        for (ProtobufAbstractCatAction catAction : catActions) {
+            catAction.documentation(sb);
+        }
+        HELP = sb.toString();
+    }
+
+    @Override
+    public List<Route> routes() {
+        return singletonList(new Route(GET, "/_cat"));
+    }
+
+    @Override
+    public String getName() {
+        return "cat_action";
+    }
+
+    @Override
+    public RestChannelConsumer prepareRequest(final RestRequest request, final ProtobufNodeClient client) throws IOException {
+        return channel -> channel.sendResponse(new BytesRestResponse(RestStatus.OK, HELP));
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
index ae0924641a16a..93db24d9ee7d6 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
@@ -70,17 +70,17 @@ public class ProtobufRestNodesAction extends ProtobufAbstractCatAction {
 
     @Override
     public List<Route> routes() {
-        return singletonList(new Route(GET, "/_cat/nodes"));
+        return singletonList(new Route(GET, "/_cat/nodes_protobuf"));
     }
 
     @Override
     public String getName() {
-        return "cat_nodes_action";
+        return "cat_nodes_protobuf_action";
     }
 
     @Override
     protected void documentation(StringBuilder sb) {
-        sb.append("/_cat/nodes\n");
+        sb.append("/_cat/nodes_protobuf\n");
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
index 61e80ad7f242c..5a716bf2a4032 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
@@ -19,7 +19,7 @@
 import org.opensearch.action.support.ProtobufChannelActionListener;
 import org.opensearch.action.support.GroupedActionListener;
 import org.opensearch.cluster.node.ProtobufDiscoveryNode;
-import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ProtobufEmptyTransportResponseHandler;
 import org.opensearch.transport.ProtobufTransportChannel;
 import org.opensearch.transport.ProtobufTransportException;
@@ -41,14 +41,14 @@ public class ProtobufTaskCancellationService {
     public static final String BAN_PARENT_ACTION_NAME = "internal:admin/tasks/ban";
     private static final Logger logger = LogManager.getLogger(ProtobufTaskCancellationService.class);
     private final ProtobufTransportService transportService;
-    private final ProtobufTaskManager taskManager;
+    private final TaskManager taskManager;
 
     public ProtobufTaskCancellationService(ProtobufTransportService transportService) {
         this.transportService = transportService;
         this.taskManager = transportService.getTaskManager();
         transportService.registerRequestHandler(
             BAN_PARENT_ACTION_NAME,
-            ProtobufThreadPool.Names.SAME,
+            ThreadPool.Names.SAME,
             BanParentTaskRequest::new,
             new BanParentRequestHandler()
         );
@@ -64,11 +64,11 @@ void cancelTaskAndDescendants(ProtobufCancellableTask task, String reason, boole
             logger.trace("cancelling task [{}] and its descendants", taskId);
             StepListener<Void> completedListener = new StepListener<>();
             GroupedActionListener<Void> groupedListener = new GroupedActionListener<>(ActionListener.map(completedListener, r -> null), 3);
-            Collection<ProtobufDiscoveryNode> childrenNodes = taskManager.startBanOnChildrenNodes(task.getId(), () -> {
+            Collection<ProtobufDiscoveryNode> childrenNodes = taskManager.startBanOnChildrenNodesProtobuf(task.getId(), () -> {
                 logger.trace("child tasks of parent [{}] are completed", taskId);
                 groupedListener.onResponse(null);
             });
-            taskManager.cancel(task, reason, () -> {
+            taskManager.cancelProtobufTask(task, reason, () -> {
                 logger.trace("task [{}] is cancelled", taskId);
                 groupedListener.onResponse(null);
             });
@@ -92,9 +92,9 @@ void cancelTaskAndDescendants(ProtobufCancellableTask task, String reason, boole
         } else {
             logger.trace("task [{}] doesn't have any children that should be cancelled", taskId);
             if (waitForCompletion) {
-                taskManager.cancel(task, reason, () -> listener.onResponse(null));
+                taskManager.cancelProtobufTask(task, reason, () -> listener.onResponse(null));
             } else {
-                taskManager.cancel(task, reason, () -> {});
+                taskManager.cancelProtobufTask(task, reason, () -> {});
                 listener.onResponse(null);
             }
         }
@@ -123,7 +123,7 @@ private void setBanOnNodes(
                 node,
                 BAN_PARENT_ACTION_NAME,
                 banRequest,
-                new ProtobufEmptyTransportResponseHandler(ProtobufThreadPool.Names.SAME) {
+                new ProtobufEmptyTransportResponseHandler(ThreadPool.Names.SAME) {
                     @Override
                     public void handleResponse(ProtobufTransportResponse.Empty response) {
                         logger.trace("sent ban for tasks with the parent [{}] to the node [{}]", taskId, node);
@@ -151,7 +151,7 @@ private void removeBanOnNodes(ProtobufCancellableTask task, Collection<ProtobufD
                 node,
                 BAN_PARENT_ACTION_NAME,
                 request,
-                new ProtobufEmptyTransportResponseHandler(ProtobufThreadPool.Names.SAME) {
+                new ProtobufEmptyTransportResponseHandler(ThreadPool.Names.SAME) {
                     @Override
                     public void handleException(ProtobufTransportException exp) {
                         assert ExceptionsHelper.unwrapCause(exp) instanceof OpenSearchSecurityException == false;
@@ -222,7 +222,7 @@ public void messageReceived(final BanParentTaskRequest request, final ProtobufTr
                     localNodeId(),
                     request.reason
                 );
-                final List<ProtobufCancellableTask> childTasks = taskManager.setBan(request.parentTaskId, request.reason);
+                final List<ProtobufCancellableTask> childTasks = taskManager.setBanProtobuf(request.parentTaskId, request.reason);
                 final GroupedActionListener<Void> listener = new GroupedActionListener<>(
                     ActionListener.map(
                         new ProtobufChannelActionListener<>(channel, BAN_PARENT_ACTION_NAME, request),
@@ -236,7 +236,7 @@ public void messageReceived(final BanParentTaskRequest request, final ProtobufTr
                 listener.onResponse(null);
             } else {
                 logger.debug("Removing ban for the parent [{}] on the node [{}]", request.parentTaskId, localNodeId());
-                taskManager.removeBan(request.parentTaskId);
+                taskManager.removeBanProtobuf(request.parentTaskId);
                 channel.sendResponse(ProtobufTransportResponse.Empty.INSTANCE);
             }
         }
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskManager.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskManager.java
index a6e53ebabdd9e..b53958eb290d3 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskManager.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskManager.java
@@ -36,7 +36,7 @@
 import org.opensearch.common.util.concurrent.ConcurrentCollections;
 import org.opensearch.common.util.concurrent.ConcurrentMapLong;
 import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TcpChannel;
 
 import java.io.IOException;
@@ -85,7 +85,7 @@ public class ProtobufTaskManager implements ProtobufClusterStateApplier {
      * Rest headers that are copied to the task
     */
     private final List<String> taskHeaders;
-    private final ProtobufThreadPool threadPool;
+    private final ThreadPool threadPool;
 
     private final ConcurrentMapLong<ProtobufTask> tasks = ConcurrentCollections.newConcurrentMapLongWithAggressiveConcurrency();
 
@@ -111,7 +111,7 @@ public class ProtobufTaskManager implements ProtobufClusterStateApplier {
     public static ProtobufTaskManager createTaskManagerWithClusterSettings(
         Settings settings,
         ClusterSettings clusterSettings,
-        ProtobufThreadPool threadPool,
+        ThreadPool threadPool,
         Set<String> taskHeaders
     ) {
         final ProtobufTaskManager taskManager = new ProtobufTaskManager(settings, threadPool, taskHeaders);
@@ -119,7 +119,7 @@ public static ProtobufTaskManager createTaskManagerWithClusterSettings(
         return taskManager;
     }
 
-    public ProtobufTaskManager(Settings settings, ProtobufThreadPool threadPool, Set<String> taskHeaders) {
+    public ProtobufTaskManager(Settings settings, ThreadPool threadPool, Set<String> taskHeaders) {
         this.threadPool = threadPool;
         this.taskHeaders = new ArrayList<>(taskHeaders);
         this.maxHeaderSize = SETTING_HTTP_MAX_HEADER_SIZE.get(settings);
@@ -479,7 +479,7 @@ public Collection<ProtobufDiscoveryNode> startBanOnChildrenNodes(long taskId, Ru
     }
 
     @Override
-    public void applyClusterState(ProtobufClusterChangedEvent event) {
+    public void applyProtobufClusterState(ProtobufClusterChangedEvent event) {
         lastDiscoveryNodes = event.state().getNodes();
         if (event.nodesRemoved()) {
             synchronized (banedParents) {
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceTrackingService.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceTrackingService.java
index 8c165e9237047..3e97e5c6c678e 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceTrackingService.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceTrackingService.java
@@ -22,7 +22,7 @@
 import org.opensearch.common.util.concurrent.ConcurrentMapLong;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.threadpool.RunnableTaskExecutionListener;
-import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.threadpool.ThreadPool;
 
 import java.lang.management.ManagementFactory;
 import java.util.ArrayList;
@@ -53,11 +53,11 @@ public class ProtobufTaskResourceTrackingService implements RunnableTaskExecutio
     private final ConcurrentMapLong<ProtobufTask> resourceAwareTasks = ConcurrentCollections
         .newConcurrentMapLongWithAggressiveConcurrency();
     private final List<TaskCompletionListener> taskCompletionListeners = new ArrayList<>();
-    private final ProtobufThreadPool threadPool;
+    private final ThreadPool threadPool;
     private volatile boolean taskResourceTrackingEnabled;
 
     @Inject
-    public ProtobufTaskResourceTrackingService(Settings settings, ClusterSettings clusterSettings, ProtobufThreadPool threadPool) {
+    public ProtobufTaskResourceTrackingService(Settings settings, ClusterSettings clusterSettings, ThreadPool threadPool) {
         this.taskResourceTrackingEnabled = TASK_RESOURCE_TRACKING_ENABLED.get(settings);
         this.threadPool = threadPool;
         clusterSettings.addSettingsUpdateConsumer(TASK_RESOURCE_TRACKING_ENABLED, this::setTaskResourceTrackingEnabled);
diff --git a/server/src/main/java/org/opensearch/tasks/TaskManager.java b/server/src/main/java/org/opensearch/tasks/TaskManager.java
index ec59a13dd1999..484ca84501be9 100644
--- a/server/src/main/java/org/opensearch/tasks/TaskManager.java
+++ b/server/src/main/java/org/opensearch/tasks/TaskManager.java
@@ -42,10 +42,15 @@
 import org.opensearch.action.ActionListener;
 import org.opensearch.action.ActionResponse;
 import org.opensearch.action.NotifyOnceListener;
+import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.cluster.ClusterChangedEvent;
 import org.opensearch.cluster.ClusterStateApplier;
+import org.opensearch.cluster.ProtobufClusterChangedEvent;
+import org.opensearch.cluster.ProtobufClusterStateApplier;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
 import org.opensearch.common.SetOnce;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
@@ -61,6 +66,9 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TcpChannel;
 
+import com.carrotsearch.hppc.ObjectIntHashMap;
+import com.carrotsearch.hppc.ObjectIntMap;
+
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -78,6 +86,7 @@
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
 
 import static org.opensearch.common.unit.TimeValue.timeValueMillis;
 import static org.opensearch.http.HttpTransportSettings.SETTING_HTTP_MAX_HEADER_SIZE;
@@ -87,7 +96,7 @@
  *
  * @opensearch.internal
  */
-public class TaskManager implements ClusterStateApplier {
+public class TaskManager implements ClusterStateApplier, ProtobufClusterStateApplier {
 
     private static final Logger logger = LogManager.getLogger(TaskManager.class);
 
@@ -109,25 +118,34 @@ public class TaskManager implements ClusterStateApplier {
     private final ThreadPool threadPool;
 
     private final ConcurrentMapLong<Task> tasks = ConcurrentCollections.newConcurrentMapLongWithAggressiveConcurrency();
+    private final ConcurrentMapLong<ProtobufTask> protobufTasks = ConcurrentCollections.newConcurrentMapLongWithAggressiveConcurrency();
 
     private final ConcurrentMapLong<CancellableTaskHolder> cancellableTasks = ConcurrentCollections
         .newConcurrentMapLongWithAggressiveConcurrency();
+    private final ConcurrentMapLong<ProtobufCancellableTaskHolder> protobufCancellableTasks = ConcurrentCollections
+        .newConcurrentMapLongWithAggressiveConcurrency();
 
     private final AtomicLong taskIdGenerator = new AtomicLong();
 
     private final Map<TaskId, String> banedParents = new ConcurrentHashMap<>();
+    private final Map<ProtobufTaskId, String> banedParentsProtobuf = new ConcurrentHashMap<>();
 
     private TaskResultsService taskResultsService;
     private final SetOnce<TaskResourceTrackingService> taskResourceTrackingService = new SetOnce<>();
+    private final SetOnce<ProtobufTaskResourceTrackingService> protobufTaskResourceTrackingService = new SetOnce<>();
 
     private volatile DiscoveryNodes lastDiscoveryNodes = DiscoveryNodes.EMPTY_NODES;
+    private volatile ProtobufDiscoveryNodes lastDiscoveryNodesProtobuf = ProtobufDiscoveryNodes.EMPTY_NODES;
 
     private final ByteSizeValue maxHeaderSize;
     private final Map<TcpChannel, ChannelPendingTaskTracker> channelPendingTaskTrackers = ConcurrentCollections.newConcurrentMap();
+    private final Map<TcpChannel, ProtobufChannelPendingTaskTracker> protobufChannelPendingTaskTrackers = ConcurrentCollections.newConcurrentMap();
     private final SetOnce<TaskCancellationService> cancellationService = new SetOnce<>();
+    private final SetOnce<ProtobufTaskCancellationService> protobufCancellationService = new SetOnce<>();
 
     private volatile boolean taskResourceConsumersEnabled;
     private final Set<Consumer<Task>> taskResourceConsumer;
+    private final Set<Consumer<ProtobufTask>> protobufTaskResourceConsumer;
     private final List<TaskEventListeners> taskEventListeners = new ArrayList<>();
 
     public static TaskManager createTaskManagerWithClusterSettings(
@@ -147,6 +165,7 @@ public TaskManager(Settings settings, ThreadPool threadPool, Set<String> taskHea
         this.maxHeaderSize = SETTING_HTTP_MAX_HEADER_SIZE.get(settings);
         this.taskResourceConsumersEnabled = TASK_RESOURCE_CONSUMERS_ENABLED.get(settings);
         taskResourceConsumer = new HashSet<>();
+        protobufTaskResourceConsumer = new HashSet<>();
     }
 
     /**
@@ -166,6 +185,10 @@ public void registerTaskResourceConsumer(Consumer<Task> consumer) {
         taskResourceConsumer.add(consumer);
     }
 
+    public void registerProtobufTaskResourceConsumer(Consumer<ProtobufTask> consumer) {
+        protobufTaskResourceConsumer.add(consumer);
+    }
+
     public void setTaskResultsService(TaskResultsService taskResultsService) {
         assert this.taskResultsService == null;
         this.taskResultsService = taskResultsService;
@@ -179,6 +202,14 @@ public void setTaskResourceTrackingService(TaskResourceTrackingService taskResou
         this.taskResourceTrackingService.set(taskResourceTrackingService);
     }
 
+    public void setTaskCancellationService(ProtobufTaskCancellationService taskCancellationService) {
+        this.protobufCancellationService.set(taskCancellationService);
+    }
+
+    public void setTaskResourceTrackingService(ProtobufTaskResourceTrackingService taskResourceTrackingService) {
+        this.protobufTaskResourceTrackingService.set(taskResourceTrackingService);
+    }
+
     public void setTaskResourceConsumersEnabled(boolean taskResourceConsumersEnabled) {
         this.taskResourceConsumersEnabled = taskResourceConsumersEnabled;
     }
@@ -262,6 +293,85 @@ private void registerCancellableTask(Task task) {
         }
     }
 
+    /**
+     * Registers a task without parent task
+    */
+    public ProtobufTask registerProtobuf(String type, String action, ProtobufTaskAwareRequest request) {
+        Map<String, String> headers = new HashMap<>();
+        long headerSize = 0;
+        long maxSize = maxHeaderSize.getBytes();
+        ThreadContext threadContext = threadPool.getThreadContext();
+        for (String key : taskHeaders) {
+            String httpHeader = threadContext.getHeader(key);
+            if (httpHeader != null) {
+                headerSize += key.length() * 2 + httpHeader.length() * 2;
+                if (headerSize > maxSize) {
+                    throw new IllegalArgumentException("Request exceeded the maximum size of task headers " + maxHeaderSize);
+                }
+                headers.put(key, httpHeader);
+            }
+        }
+        ProtobufTask task = request.createTask(taskIdGenerator.incrementAndGet(), type, action, request.getParentTask(), headers);
+        Objects.requireNonNull(task);
+        assert task.getParentTaskId().equals(request.getParentTask()) : "Request [ " + request + "] didn't preserve it parentTaskId";
+        if (logger.isTraceEnabled()) {
+            logger.trace("register {} [{}] [{}] [{}]", task.getId(), type, action, task.getDescription());
+        }
+
+        if (task.supportsResourceTracking()) {
+            boolean success = task.addResourceTrackingCompletionListener(new NotifyOnceListener<>() {
+                @Override
+                protected void innerOnResponse(ProtobufTask task) {
+                    // Stop tracking the task once the last thread has been marked inactive.
+                    if (protobufTaskResourceTrackingService.get() != null && task.supportsResourceTracking()) {
+                        protobufTaskResourceTrackingService.get().stopTracking(task);
+                    }
+                }
+
+                @Override
+                protected void innerOnFailure(Exception e) {
+                    ExceptionsHelper.reThrowIfNotNull(e);
+                }
+            });
+
+            if (success == false) {
+                logger.debug(
+                    "failed to register a completion listener as task resource tracking has already completed [taskId={}]",
+                    task.getId()
+                );
+            }
+        }
+
+        if (task instanceof ProtobufCancellableTask) {
+            registerProtobufCancellableTask(task);
+        } else {
+            ProtobufTask previousTask = protobufTasks.put(task.getId(), task);
+            assert previousTask == null;
+        }
+        return task;
+    }
+
+    private void registerProtobufCancellableTask(ProtobufTask task) {
+        ProtobufCancellableTask cancellableTask = (ProtobufCancellableTask) task;
+        ProtobufCancellableTaskHolder holder = new ProtobufCancellableTaskHolder(cancellableTask);
+        ProtobufCancellableTaskHolder oldHolder = protobufCancellableTasks.put(task.getId(), holder);
+        assert oldHolder == null;
+        // Check if this task was banned before we start it. The empty check is used to avoid
+        // computing the hash code of the parent taskId as most of the time banedParents is empty.
+        if (task.getParentTaskId().isSet() && banedParents.isEmpty() == false) {
+            String reason = banedParents.get(task.getParentTaskId());
+            if (reason != null) {
+                try {
+                    holder.cancel(reason);
+                    throw new TaskCancelledException("ProtobufTask cancelled before it started: " + reason);
+                } finally {
+                    // let's clean up the registration
+                    unregisterProtobufTask(task);
+                }
+            }
+        }
+    }
+
     /**
      * Cancels a task
      * <p>
@@ -290,6 +400,51 @@ public void cancel(CancellableTask task, String reason, Runnable listener) {
         }
     }
 
+    /**
+     * Cancels a task
+    * <p>
+    * After starting cancellation on the parent task, the task manager tries to cancel all children tasks
+    * of the current task. Once cancellation of the children tasks is done, the listener is triggered.
+    * If the task is completed or unregistered from ProtobufTaskManager, then the listener is called immediately.
+    */
+    public void cancelProtobufTask(ProtobufCancellableTask task, String reason, Runnable listener) {
+        CancellableTaskHolder holder = cancellableTasks.get(task.getId());
+        List<Exception> exceptions = new ArrayList<>();
+        for (TaskEventListeners taskEventListener : taskEventListeners) {
+            try {
+                taskEventListener.onTaskCancelled(task);
+            } catch (Exception e) {
+                exceptions.add(e);
+            }
+        }
+        // Throwing exception in case any of the cancellation listener results into exception.
+        // Should we just swallow such exceptions?
+        ExceptionsHelper.maybeThrowRuntimeAndSuppress(exceptions);
+        if (holder != null) {
+            logger.trace("cancelling task with id {}", task.getId());
+            holder.cancel(reason, listener);
+        } else {
+            listener.run();
+        }
+    }
+
+    /**
+     * Cancels a task
+    * <p>
+    * After starting cancellation on the parent task, the task manager tries to cancel all children tasks
+    * of the current task. Once cancellation of the children tasks is done, the listener is triggered.
+    * If the task is completed or unregistered from ProtobufTaskManager, then the listener is called immediately.
+    */
+    public void cancelProtobufTask(ProtobufCancellableTask task, String reason, Runnable listener) {
+        CancellableTaskHolder holder = cancellableTasks.get(task.getId());
+        if (holder != null) {
+            logger.trace("cancelling task with id {}", task.getId());
+            holder.cancel(reason, listener);
+        } else {
+            listener.run();
+        }
+    }
+
     /**
      * Unregister the task
      */
@@ -331,6 +486,38 @@ public Task unregister(Task task) {
         }
     }
 
+    /**
+     * Unregister the task
+    */
+    public ProtobufTask unregisterProtobufTask(ProtobufTask task) {
+        logger.trace("unregister task for id: {}", task.getId());
+
+        // Decrement the task's self-thread as part of unregistration.
+        task.decrementResourceTrackingThreads();
+
+        if (taskResourceConsumersEnabled) {
+            for (Consumer<ProtobufTask> taskConsumer : protobufTaskResourceConsumer) {
+                try {
+                    taskConsumer.accept(task);
+                } catch (Exception e) {
+                    logger.error("error encountered when updating the consumer", e);
+                }
+            }
+        }
+
+        if (task instanceof ProtobufCancellableTask) {
+            ProtobufCancellableTaskHolder holder = protobufCancellableTasks.remove(task.getId());
+            if (holder != null) {
+                holder.finish();
+                return holder.getTask();
+            } else {
+                return null;
+            }
+        } else {
+            return protobufTasks.remove(task.getId());
+        }
+    }
+
     /**
      * Register a node on which a child task will execute. The returned {@link Releasable} must be called
      * to unregister the child node once the child task is completed or failed.
@@ -352,6 +539,27 @@ public DiscoveryNode localNode() {
         return lastDiscoveryNodes.getLocalNode();
     }
 
+    /**
+     * Register a node on which a child task will execute. The returned {@link Releasable} must be called
+    * to unregister the child node once the child task is completed or failed.
+    */
+    public Releasable registerProtobufChildNode(long taskId, ProtobufDiscoveryNode node) {
+        final ProtobufCancellableTaskHolder holder = protobufCancellableTasks.get(taskId);
+        if (holder != null) {
+            logger.trace("register child node [{}] task [{}]", node, taskId);
+            holder.registerChildNode(node);
+            return Releasables.releaseOnce(() -> {
+                logger.trace("unregister child node [{}] task [{}]", node, taskId);
+                holder.unregisterChildNode(node);
+            });
+        }
+        return () -> {};
+    }
+
+    public ProtobufDiscoveryNode localProtobufNode() {
+        return lastDiscoveryNodesProtobuf.getLocalNode();
+    }
+
     /**
      * Stores the task failure
      */
@@ -384,6 +592,42 @@ public void onFailure(Exception e) {
         });
     }
 
+    /**
+     * Stores the task failure
+    */
+    public <Response extends ProtobufActionResponse> void storeResultProtobuf(
+        ProtobufTask task,
+        Exception error,
+        ActionListener<Response> listener
+    ) {
+        ProtobufDiscoveryNode localNode = lastDiscoveryNodesProtobuf.getLocalNode();
+        if (localNode == null) {
+            // too early to store anything, shouldn't really be here - just pass the error along
+            listener.onFailure(error);
+            return;
+        }
+        final ProtobufTaskResult taskResult;
+        try {
+            taskResult = task.result(localNode, error);
+        } catch (IOException ex) {
+            logger.warn(() -> new ParameterizedMessage("couldn't store error {}", ExceptionsHelper.detailedMessage(error)), ex);
+            listener.onFailure(ex);
+            return;
+        }
+        taskResultsService.storeResult(taskResult, new ActionListener<Void>() {
+            @Override
+            public void onResponse(Void aVoid) {
+                listener.onFailure(error);
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                logger.warn(() -> new ParameterizedMessage("couldn't store error {}", ExceptionsHelper.detailedMessage(error)), e);
+                listener.onFailure(e);
+            }
+        });
+    }
+
     /**
      * Stores the task result
      */
@@ -418,6 +662,44 @@ public void onFailure(Exception e) {
         });
     }
 
+    /**
+     * Stores the task result
+    */
+    public <Response extends ProtobufActionResponse> void storeResultProtobuf(
+        ProtobufTask task,
+        Response response,
+        ActionListener<Response> listener
+    ) {
+        ProtobufDiscoveryNode localNode = lastDiscoveryNodesProtobuf.getLocalNode();
+        if (localNode == null) {
+            // too early to store anything, shouldn't really be here - just pass the response along
+            logger.warn("couldn't store response {}, the node didn't join the cluster yet", response);
+            listener.onResponse(response);
+            return;
+        }
+        final ProtobufTaskResult taskResult;
+        try {
+            taskResult = task.result(localNode, response);
+        } catch (IOException ex) {
+            logger.warn(() -> new ParameterizedMessage("couldn't store response {}", response), ex);
+            listener.onFailure(ex);
+            return;
+        }
+
+        taskResultsService.storeResult(taskResult, new ActionListener<Void>() {
+            @Override
+            public void onResponse(Void aVoid) {
+                listener.onResponse(response);
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                logger.warn(() -> new ParameterizedMessage("couldn't store response {}", response), e);
+                listener.onFailure(e);
+            }
+        });
+    }
+
     /**
      * Returns the list of currently running tasks on the node
      */
@@ -429,6 +711,17 @@ public Map<Long, Task> getTasks() {
         return Collections.unmodifiableMap(taskHashMap);
     }
 
+    /**
+     * Returns the list of currently running tasks on the node
+    */
+    public Map<Long, ProtobufTask> getProtobufTasks() {
+        HashMap<Long, ProtobufTask> taskHashMap = new HashMap<>(this.protobufTasks);
+        for (ProtobufCancellableTaskHolder holder : protobufCancellableTasks.values()) {
+            taskHashMap.put(holder.getTask().getId(), holder.getTask());
+        }
+        return Collections.unmodifiableMap(taskHashMap);
+    }
+
     /**
      * Returns the list of currently running tasks on the node that can be cancelled
      */
@@ -440,6 +733,17 @@ public Map<Long, CancellableTask> getCancellableTasks() {
         return Collections.unmodifiableMap(taskHashMap);
     }
 
+    /**
+     * Returns the list of currently running tasks on the node that can be cancelled
+    */
+    public Map<Long, ProtobufCancellableTask> getProtobufCancellableTasks() {
+        HashMap<Long, ProtobufCancellableTask> taskHashMap = new HashMap<>();
+        for (ProtobufCancellableTaskHolder holder : protobufCancellableTasks.values()) {
+            taskHashMap.put(holder.getTask().getId(), holder.getTask());
+        }
+        return Collections.unmodifiableMap(taskHashMap);
+    }
+
     /**
      * Returns a task with given id, or null if the task is not found.
      */
@@ -452,6 +756,18 @@ public Task getTask(long id) {
         }
     }
 
+    /**
+     * Returns a task with given id, or null if the task is not found.
+    */
+    public ProtobufTask getProtobufTask(long id) {
+        ProtobufTask task = protobufTasks.get(id);
+        if (task != null) {
+            return task;
+        } else {
+            return getProtobufCancellableTask(id);
+        }
+    }
+
     /**
      * Returns a cancellable task with given id, or null if the task is not found.
      */
@@ -464,6 +780,18 @@ public CancellableTask getCancellableTask(long id) {
         }
     }
 
+    /**
+     * Returns a cancellable task with given id, or null if the task is not found.
+    */
+    public ProtobufCancellableTask getProtobufCancellableTask(long id) {
+        ProtobufCancellableTaskHolder holder = protobufCancellableTasks.get(id);
+        if (holder != null) {
+            return holder.getTask();
+        } else {
+            return null;
+        }
+    }
+
     /**
      * Returns the number of currently banned tasks.
      * <p>
@@ -525,25 +853,109 @@ public Collection<DiscoveryNode> startBanOnChildrenNodes(long taskId, Runnable o
         }
     }
 
-    @Override
-    public void applyClusterState(ClusterChangedEvent event) {
-        lastDiscoveryNodes = event.state().getNodes();
-        if (event.nodesRemoved()) {
-            synchronized (banedParents) {
-                lastDiscoveryNodes = event.state().getNodes();
-                // Remove all bans that were registered by nodes that are no longer in the cluster state
-                Iterator<TaskId> banIterator = banedParents.keySet().iterator();
-                while (banIterator.hasNext()) {
-                    TaskId taskId = banIterator.next();
-                    if (lastDiscoveryNodes.nodeExists(taskId.getNodeId()) == false) {
-                        logger.debug(
-                            "Removing ban for the parent [{}] on the node [{}], reason: the parent node is gone",
-                            taskId,
-                            event.state().getNodes().getLocalNode()
-                        );
-                        banIterator.remove();
-                    }
-                }
+        /**
+     * Returns the number of currently banned tasks.
+     * <p>
+     * Will be used in task manager stats and for debugging.
+     */
+    public int getBanCountProtobuf() {
+        return banedParentsProtobuf.size();
+    }
+
+    /**
+     * Bans all tasks with the specified parent task from execution, cancels all tasks that are currently executing.
+     * <p>
+     * This method is called when a parent task that has children is cancelled.
+     *
+     * @return a list of pending cancellable child tasks
+     */
+    public List<ProtobufCancellableTask> setBanProtobuf(ProtobufTaskId parentTaskId, String reason) {
+        logger.trace("setting ban for the parent task {} {}", parentTaskId, reason);
+
+        // Set the ban first, so the newly created tasks cannot be registered
+        synchronized (banedParentsProtobuf) {
+            if (lastDiscoveryNodesProtobuf.nodeExists(parentTaskId.getNodeId())) {
+                // Only set the ban if the node is the part of the cluster
+                banedParentsProtobuf.put(parentTaskId, reason);
+            }
+        }
+        return protobufCancellableTasks.values().stream().filter(t -> t.hasParent(parentTaskId)).map(t -> t.task).collect(Collectors.toList());
+    }
+
+    /**
+     * Removes the ban for the specified parent task.
+     * <p>
+     * This method is called when a previously banned task finally cancelled
+     */
+    public void removeBanProtobuf(ProtobufTaskId parentTaskId) {
+        logger.trace("removing ban for the parent task {}", parentTaskId);
+        banedParentsProtobuf.remove(parentTaskId);
+    }
+
+    // for testing
+    public Set<ProtobufTaskId> getBannedTaskIdsProtobuf() {
+        return Collections.unmodifiableSet(banedParentsProtobuf.keySet());
+    }
+
+    /**
+     * Start rejecting new child requests as the parent task was cancelled.
+     *
+     * @param taskId                the parent task id
+     * @param onChildTasksCompleted called when all child tasks are completed or failed
+     * @return the set of current nodes that have outstanding child tasks
+     */
+    public Collection<ProtobufDiscoveryNode> startBanOnChildrenNodesProtobuf(long taskId, Runnable onChildTasksCompleted) {
+        final ProtobufCancellableTaskHolder holder = protobufCancellableTasks.get(taskId);
+        if (holder != null) {
+            return holder.startBan(onChildTasksCompleted);
+        } else {
+            onChildTasksCompleted.run();
+            return Collections.emptySet();
+        }
+    }
+
+    @Override
+    public void applyClusterState(ClusterChangedEvent event) {
+        lastDiscoveryNodes = event.state().getNodes();
+        if (event.nodesRemoved()) {
+            synchronized (banedParents) {
+                lastDiscoveryNodes = event.state().getNodes();
+                // Remove all bans that were registered by nodes that are no longer in the cluster state
+                Iterator<TaskId> banIterator = banedParents.keySet().iterator();
+                while (banIterator.hasNext()) {
+                    TaskId taskId = banIterator.next();
+                    if (lastDiscoveryNodes.nodeExists(taskId.getNodeId()) == false) {
+                        logger.debug(
+                            "Removing ban for the parent [{}] on the node [{}], reason: the parent node is gone",
+                            taskId,
+                            event.state().getNodes().getLocalNode()
+                        );
+                        banIterator.remove();
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public void applyProtobufClusterState(ProtobufClusterChangedEvent event) {
+        lastDiscoveryNodesProtobuf = event.state().getNodes();
+        if (event.nodesRemoved()) {
+            synchronized (banedParentsProtobuf) {
+                lastDiscoveryNodesProtobuf = event.state().getNodes();
+                // Remove all bans that were registered by nodes that are no longer in the cluster state
+                Iterator<ProtobufTaskId> banIterator = banedParentsProtobuf.keySet().iterator();
+                while (banIterator.hasNext()) {
+                    ProtobufTaskId taskId = banIterator.next();
+                    if (lastDiscoveryNodesProtobuf.nodeExists(taskId.getNodeId()) == false) {
+                        logger.debug(
+                            "Removing ban for the parent [{}] on the node [{}], reason: the parent node is gone",
+                            taskId,
+                            event.state().getNodes().getLocalNode()
+                        );
+                        banIterator.remove();
+                    }
+                }
             }
         }
     }
@@ -565,6 +977,23 @@ public void waitForTaskCompletion(Task task, long untilInNanos) {
         throw new OpenSearchTimeoutException("Timed out waiting for completion of [{}]", task);
     }
 
+    /**
+     * Blocks the calling thread, waiting for the task to vanish from the ProtobufTaskManager.
+    */
+    public void waitForProtobufTaskCompletion(ProtobufTask task, long untilInNanos) {
+        while (System.nanoTime() - untilInNanos < 0) {
+            if (getTask(task.getId()) == null) {
+                return;
+            }
+            try {
+                Thread.sleep(WAIT_FOR_COMPLETION_POLL.millis());
+            } catch (InterruptedException e) {
+                throw new OpenSearchException("Interrupted waiting for completion of [{}]", e, task);
+            }
+        }
+        throw new OpenSearchTimeoutException("Timed out waiting for completion of [{}]", task);
+    }
+
     /**
      * Takes actions when a task is registered and its execution starts
      *
@@ -577,6 +1006,18 @@ public ThreadContext.StoredContext taskExecutionStarted(Task task) {
         return taskResourceTrackingService.get().startTracking(task);
     }
 
+    /**
+     * Takes actions when a task is registered and its execution starts
+    *
+    * @param task getting executed.
+    * @return AutoCloseable to free up resources (clean up thread context) when task execution block returns
+    */
+    public ThreadContext.StoredContext protobufTaskExecutionStarted(ProtobufTask task) {
+        if (protobufTaskResourceTrackingService.get() == null) return () -> {};
+
+        return protobufTaskResourceTrackingService.get().startTracking(task);
+    }
+
     private static class CancellableTaskHolder {
         private final CancellableTask task;
         private boolean finished = false;
@@ -710,6 +1151,271 @@ Set<DiscoveryNode> startBan(Runnable onChildTasksCompleted) {
         }
     }
 
+    private static class ProtobufCancellableTaskHolder {
+        private final ProtobufCancellableTask task;
+        private boolean finished = false;
+        private List<Runnable> cancellationListeners = null;
+        private ObjectIntMap<ProtobufDiscoveryNode> childTasksPerNode = null;
+        private boolean banChildren = false;
+        private List<Runnable> childTaskCompletedListeners = null;
+
+        ProtobufCancellableTaskHolder(ProtobufCancellableTask task) {
+            this.task = task;
+        }
+
+        void cancel(String reason, Runnable listener) {
+            final Runnable toRun;
+            synchronized (this) {
+                if (finished) {
+                    assert cancellationListeners == null;
+                    toRun = listener;
+                } else {
+                    toRun = () -> {};
+                    if (listener != null) {
+                        if (cancellationListeners == null) {
+                            cancellationListeners = new ArrayList<>();
+                        }
+                        cancellationListeners.add(listener);
+                    }
+                }
+            }
+            try {
+                task.cancel(reason);
+            } finally {
+                if (toRun != null) {
+                    toRun.run();
+                }
+            }
+        }
+
+        void cancel(String reason) {
+            task.cancel(reason);
+        }
+
+        /**
+         * Marks task as finished.
+        */
+        public void finish() {
+            final List<Runnable> listeners;
+            synchronized (this) {
+                this.finished = true;
+                if (cancellationListeners != null) {
+                    listeners = cancellationListeners;
+                    cancellationListeners = null;
+                } else {
+                    listeners = Collections.emptyList();
+                }
+            }
+            // We need to call the listener outside of the synchronised section to avoid potential bottle necks
+            // in the listener synchronization
+            notifyListeners(listeners);
+        }
+
+        private void notifyListeners(List<Runnable> listeners) {
+            assert Thread.holdsLock(this) == false;
+            Exception rootException = null;
+            for (Runnable listener : listeners) {
+                try {
+                    listener.run();
+                } catch (RuntimeException inner) {
+                    rootException = ExceptionsHelper.useOrSuppress(rootException, inner);
+                }
+            }
+            ExceptionsHelper.reThrowIfNotNull(rootException);
+        }
+
+        public boolean hasParent(ProtobufTaskId parentTaskId) {
+            return task.getParentTaskId().equals(parentTaskId);
+        }
+
+        public ProtobufCancellableTask getTask() {
+            return task;
+        }
+
+        synchronized void registerChildNode(ProtobufDiscoveryNode node) {
+            if (banChildren) {
+                throw new TaskCancelledException("The parent task was cancelled, shouldn't start any child tasks");
+            }
+            if (childTasksPerNode == null) {
+                childTasksPerNode = new ObjectIntHashMap<>();
+            }
+            childTasksPerNode.addTo(node, 1);
+        }
+
+        void unregisterChildNode(ProtobufDiscoveryNode node) {
+            final List<Runnable> listeners;
+            synchronized (this) {
+                if (childTasksPerNode.addTo(node, -1) == 0) {
+                    childTasksPerNode.remove(node);
+                }
+                if (childTasksPerNode.isEmpty() && this.childTaskCompletedListeners != null) {
+                    listeners = childTaskCompletedListeners;
+                    childTaskCompletedListeners = null;
+                } else {
+                    listeners = Collections.emptyList();
+                }
+            }
+            notifyListeners(listeners);
+        }
+
+        Set<ProtobufDiscoveryNode> startBan(Runnable onChildTasksCompleted) {
+            final Set<ProtobufDiscoveryNode> pendingChildNodes;
+            final Runnable toRun;
+            synchronized (this) {
+                banChildren = true;
+                if (childTasksPerNode == null) {
+                    pendingChildNodes = Collections.emptySet();
+                } else {
+                    pendingChildNodes = Set.copyOf(childTasksPerNode.keySet());
+                }
+                if (pendingChildNodes.isEmpty()) {
+                    assert childTaskCompletedListeners == null;
+                    toRun = onChildTasksCompleted;
+                } else {
+                    toRun = () -> {};
+                    if (childTaskCompletedListeners == null) {
+                        childTaskCompletedListeners = new ArrayList<>();
+                    }
+                    childTaskCompletedListeners.add(onChildTasksCompleted);
+                }
+            }
+            toRun.run();
+            return pendingChildNodes;
+        }
+    }
+
+    private static class ProtobufCancellableTaskHolder {
+        private final ProtobufCancellableTask task;
+        private boolean finished = false;
+        private List<Runnable> cancellationListeners = null;
+        private ObjectIntMap<ProtobufDiscoveryNode> childTasksPerNode = null;
+        private boolean banChildren = false;
+        private List<Runnable> childTaskCompletedListeners = null;
+
+        ProtobufCancellableTaskHolder(ProtobufCancellableTask task) {
+            this.task = task;
+        }
+
+        void cancel(String reason, Runnable listener) {
+            final Runnable toRun;
+            synchronized (this) {
+                if (finished) {
+                    assert cancellationListeners == null;
+                    toRun = listener;
+                } else {
+                    toRun = () -> {};
+                    if (listener != null) {
+                        if (cancellationListeners == null) {
+                            cancellationListeners = new ArrayList<>();
+                        }
+                        cancellationListeners.add(listener);
+                    }
+                }
+            }
+            try {
+                task.cancel(reason);
+            } finally {
+                if (toRun != null) {
+                    toRun.run();
+                }
+            }
+        }
+
+        void cancel(String reason) {
+            task.cancel(reason);
+        }
+
+        /**
+         * Marks task as finished.
+        */
+        public void finish() {
+            final List<Runnable> listeners;
+            synchronized (this) {
+                this.finished = true;
+                if (cancellationListeners != null) {
+                    listeners = cancellationListeners;
+                    cancellationListeners = null;
+                } else {
+                    listeners = Collections.emptyList();
+                }
+            }
+            // We need to call the listener outside of the synchronised section to avoid potential bottle necks
+            // in the listener synchronization
+            notifyListeners(listeners);
+        }
+
+        private void notifyListeners(List<Runnable> listeners) {
+            assert Thread.holdsLock(this) == false;
+            Exception rootException = null;
+            for (Runnable listener : listeners) {
+                try {
+                    listener.run();
+                } catch (RuntimeException inner) {
+                    rootException = ExceptionsHelper.useOrSuppress(rootException, inner);
+                }
+            }
+            ExceptionsHelper.reThrowIfNotNull(rootException);
+        }
+
+        public boolean hasParent(ProtobufTaskId parentTaskId) {
+            return task.getParentTaskId().equals(parentTaskId);
+        }
+
+        public ProtobufCancellableTask getTask() {
+            return task;
+        }
+
+        synchronized void registerChildNode(ProtobufDiscoveryNode node) {
+            if (banChildren) {
+                throw new TaskCancelledException("The parent task was cancelled, shouldn't start any child tasks");
+            }
+            if (childTasksPerNode == null) {
+                childTasksPerNode = new ObjectIntHashMap<>();
+            }
+            childTasksPerNode.addTo(node, 1);
+        }
+
+        void unregisterChildNode(ProtobufDiscoveryNode node) {
+            final List<Runnable> listeners;
+            synchronized (this) {
+                if (childTasksPerNode.addTo(node, -1) == 0) {
+                    childTasksPerNode.remove(node);
+                }
+                if (childTasksPerNode.isEmpty() && this.childTaskCompletedListeners != null) {
+                    listeners = childTaskCompletedListeners;
+                    childTaskCompletedListeners = null;
+                } else {
+                    listeners = Collections.emptyList();
+                }
+            }
+            notifyListeners(listeners);
+        }
+
+        Set<ProtobufDiscoveryNode> startBan(Runnable onChildTasksCompleted) {
+            final Set<ProtobufDiscoveryNode> pendingChildNodes;
+            final Runnable toRun;
+            synchronized (this) {
+                banChildren = true;
+                if (childTasksPerNode == null) {
+                    pendingChildNodes = Collections.emptySet();
+                } else {
+                    pendingChildNodes = Set.copyOf(childTasksPerNode.keySet());
+                }
+                if (pendingChildNodes.isEmpty()) {
+                    assert childTaskCompletedListeners == null;
+                    toRun = onChildTasksCompleted;
+                } else {
+                    toRun = () -> {};
+                    if (childTaskCompletedListeners == null) {
+                        childTaskCompletedListeners = new ArrayList<>();
+                    }
+                    childTaskCompletedListeners.add(onChildTasksCompleted);
+                }
+            }
+            toRun.run();
+            return pendingChildNodes;
+        }
+    }
     /**
      * Start tracking a cancellable task with its tcp channel, so if the channel gets closed we can get a set of
      * pending tasks associated that channel and cancel them as these results won't be retrieved by the parent task.
@@ -800,4 +1506,100 @@ public void cancelTaskAndDescendants(CancellableTask task, String reason, boolea
             throw new IllegalStateException("TaskCancellationService is not initialized");
         }
     }
+
+    /**
+     * Start tracking a cancellable task with its tcp channel, so if the channel gets closed we can get a set of
+    * pending tasks associated that channel and cancel them as these results won't be retrieved by the parent task.
+    *
+    * @return a releasable that should be called when this pending task is completed
+    */
+    public Releasable startProtobufTrackingCancellableChannelTask(TcpChannel channel, ProtobufCancellableTask task) {
+        assert protobufCancellableTasks.containsKey(task.getId()) : "task [" + task.getId() + "] is not registered yet";
+        final ProtobufChannelPendingTaskTracker tracker = protobufChannelPendingTaskTrackers.compute(channel, (k, curr) -> {
+            if (curr == null) {
+                curr = new ProtobufChannelPendingTaskTracker();
+            }
+            curr.addTask(task);
+            return curr;
+        });
+        if (tracker.registered.compareAndSet(false, true)) {
+            channel.addCloseListener(ActionListener.wrap(r -> {
+                final ProtobufChannelPendingTaskTracker removedTracker = protobufChannelPendingTaskTrackers.remove(channel);
+                assert removedTracker == tracker;
+                cancelProtobufTasksOnChannelClosed(tracker.drainTasks());
+            }, e -> { assert false : new AssertionError("must not be here", e); }));
+        }
+        return () -> tracker.removeTask(task);
+    }
+
+    // for testing
+    final int numberOfProtobufChannelPendingTaskTrackers() {
+        return protobufChannelPendingTaskTrackers.size();
+    }
+
+    private static class ProtobufChannelPendingTaskTracker {
+        final AtomicBoolean registered = new AtomicBoolean();
+        final Semaphore permits = Assertions.ENABLED ? new Semaphore(Integer.MAX_VALUE) : null;
+        final Set<ProtobufCancellableTask> pendingTasks = ConcurrentCollections.newConcurrentSet();
+
+        void addTask(ProtobufCancellableTask task) {
+            assert permits.tryAcquire() : "tracker was drained";
+            final boolean added = pendingTasks.add(task);
+            assert added : "task " + task.getId() + " is in the pending list already";
+            assert releasePermit();
+        }
+
+        boolean acquireAllPermits() {
+            permits.acquireUninterruptibly(Integer.MAX_VALUE);
+            return true;
+        }
+
+        boolean releasePermit() {
+            permits.release();
+            return true;
+        }
+
+        Set<ProtobufCancellableTask> drainTasks() {
+            assert acquireAllPermits(); // do not release permits so we can't add tasks to this tracker after draining
+            return Collections.unmodifiableSet(pendingTasks);
+        }
+
+        void removeTask(ProtobufCancellableTask task) {
+            final boolean removed = pendingTasks.remove(task);
+            assert removed : "task " + task.getId() + " is not in the pending list";
+        }
+    }
+
+    private void cancelProtobufTasksOnChannelClosed(Set<ProtobufCancellableTask> tasks) {
+        if (tasks.isEmpty() == false) {
+            threadPool.generic().execute(new AbstractRunnable() {
+                @Override
+                public void onFailure(Exception e) {
+                    logger.warn("failed to cancel tasks on channel closed", e);
+                }
+
+                @Override
+                protected void doRun() {
+                    for (ProtobufCancellableTask task : tasks) {
+                        cancelProtobufTaskAndDescendants(task, "channel was closed", false, ActionListener.wrap(() -> {}));
+                    }
+                }
+            });
+        }
+    }
+
+    public void cancelProtobufTaskAndDescendants(
+        ProtobufCancellableTask task,
+        String reason,
+        boolean waitForCompletion,
+        ActionListener<Void> listener
+    ) {
+        final ProtobufTaskCancellationService service = protobufCancellationService.get();
+        if (service != null) {
+            service.cancelTaskAndDescendants(task, reason, waitForCompletion, listener);
+        } else {
+            assert false : "ProtobufTaskCancellationService is not initialized";
+            throw new IllegalStateException("ProtobufTaskCancellationService is not initialized");
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/threadpool/ProtobufExecutorBuilder.java b/server/src/main/java/org/opensearch/threadpool/ProtobufExecutorBuilder.java
deleted file mode 100644
index 3276e5029e6f2..0000000000000
--- a/server/src/main/java/org/opensearch/threadpool/ProtobufExecutorBuilder.java
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.threadpool;
-
-import org.opensearch.common.settings.Setting;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.util.concurrent.OpenSearchExecutors;
-import org.opensearch.common.util.concurrent.ThreadContext;
-
-import java.util.List;
-
-/**
- * Base class for executor builders.
-*
-* @param <U> the underlying type of the executor settings
-*
-* @opensearch.internal
-*/
-public abstract class ProtobufExecutorBuilder<U extends ProtobufExecutorBuilder.ExecutorSettings> {
-
-    private final String name;
-
-    public ProtobufExecutorBuilder(String name) {
-        this.name = name;
-    }
-
-    protected String name() {
-        return name;
-    }
-
-    protected static String settingsKey(final String prefix, final String key) {
-        return String.join(".", prefix, key);
-    }
-
-    protected int applyHardSizeLimit(final Settings settings, final String name) {
-        if (name.equals("bulk") || name.equals(ThreadPool.Names.WRITE) || name.equals(ThreadPool.Names.SYSTEM_WRITE)) {
-            return 1 + OpenSearchExecutors.allocatedProcessors(settings);
-        } else {
-            return Integer.MAX_VALUE;
-        }
-    }
-
-    /**
-     * The list of settings this builder will register.
-    *
-    * @return the list of registered settings
-    */
-    public abstract List<Setting<?>> getRegisteredSettings();
-
-    /**
-     * Return an executor settings object from the node-level settings.
-    *
-    * @param settings the node-level settings
-    * @return the executor settings object
-    */
-    abstract U getSettings(Settings settings);
-
-    /**
-     * Builds the executor with the specified executor settings.
-    *
-    * @param settings      the executor settings
-    * @param threadContext the current thread context
-    * @return a new executor built from the specified executor settings
-    */
-    abstract ProtobufThreadPool.ExecutorHolder build(U settings, ThreadContext threadContext);
-
-    /**
-     * Format the thread pool info object for this executor.
-    *
-    * @param info the thread pool info object to format
-    * @return a formatted thread pool info (useful for logging)
-    */
-    abstract String formatInfo(ProtobufThreadPool.Info info);
-
-    abstract static class ExecutorSettings {
-
-        protected final String nodeName;
-
-        ExecutorSettings(String nodeName) {
-            this.nodeName = nodeName;
-        }
-
-    }
-
-}
diff --git a/server/src/main/java/org/opensearch/threadpool/ProtobufFixedExecutorBuilder.java b/server/src/main/java/org/opensearch/threadpool/ProtobufFixedExecutorBuilder.java
deleted file mode 100644
index 6d5bce32533ab..0000000000000
--- a/server/src/main/java/org/opensearch/threadpool/ProtobufFixedExecutorBuilder.java
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.threadpool;
-
-import org.opensearch.common.settings.Setting;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.unit.ProtobufSizeValue;
-import org.opensearch.common.util.concurrent.OpenSearchExecutors;
-import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.node.Node;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.Locale;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.ThreadFactory;
-
-/**
- * A builder for fixed executors.
-*
-* @opensearch.internal
-*/
-public final class ProtobufFixedExecutorBuilder extends ProtobufExecutorBuilder<ProtobufFixedExecutorBuilder.FixedExecutorSettings> {
-
-    private final Setting<Integer> sizeSetting;
-    private final Setting<Integer> queueSizeSetting;
-
-    /**
-     * Construct a fixed executor builder; the settings will have the key prefix "thread_pool." followed by the executor name.
-    *
-    * @param settings  the node-level settings
-    * @param name      the name of the executor
-    * @param size      the fixed number of threads
-    * @param queueSize the size of the backing queue, -1 for unbounded
-    */
-    ProtobufFixedExecutorBuilder(final Settings settings, final String name, final int size, final int queueSize) {
-        this(settings, name, size, queueSize, false);
-    }
-
-    /**
-     * Construct a fixed executor builder; the settings will have the key prefix "thread_pool." followed by the executor name.
-    *
-    * @param settings   the node-level settings
-    * @param name       the name of the executor
-    * @param size       the fixed number of threads
-    * @param queueSize  the size of the backing queue, -1 for unbounded
-    * @param deprecated whether or not the thread pool is deprecated
-    */
-    ProtobufFixedExecutorBuilder(
-        final Settings settings,
-        final String name,
-        final int size,
-        final int queueSize,
-        final boolean deprecated
-    ) {
-        this(settings, name, size, queueSize, "thread_pool." + name, deprecated);
-    }
-
-    /**
-     * Construct a fixed executor builder.
-    *
-    * @param settings  the node-level settings
-    * @param name      the name of the executor
-    * @param size      the fixed number of threads
-    * @param queueSize the size of the backing queue, -1 for unbounded
-    * @param prefix    the prefix for the settings keys
-    */
-    public ProtobufFixedExecutorBuilder(
-        final Settings settings,
-        final String name,
-        final int size,
-        final int queueSize,
-        final String prefix
-    ) {
-        this(settings, name, size, queueSize, prefix, false);
-    }
-
-    /**
-     * Construct a fixed executor builder.
-    *
-    * @param settings   the node-level settings
-    * @param name       the name of the executor
-    * @param size       the fixed number of threads
-    * @param queueSize  the size of the backing queue, -1 for unbounded
-    * @param prefix     the prefix for the settings keys
-    * @param deprecated whether or not the thread pool is deprecated
-    */
-    public ProtobufFixedExecutorBuilder(
-        final Settings settings,
-        final String name,
-        final int size,
-        final int queueSize,
-        final String prefix,
-        final boolean deprecated
-    ) {
-        super(name);
-        final String sizeKey = settingsKey(prefix, "size");
-        final Setting.Property[] properties;
-        if (deprecated) {
-            properties = new Setting.Property[] { Setting.Property.NodeScope, Setting.Property.Deprecated };
-        } else {
-            properties = new Setting.Property[] { Setting.Property.NodeScope };
-        }
-        this.sizeSetting = new Setting<>(
-            sizeKey,
-            s -> Integer.toString(size),
-            s -> Setting.parseInt(s, 1, applyHardSizeLimit(settings, name), sizeKey),
-            properties
-        );
-        final String queueSizeKey = settingsKey(prefix, "queue_size");
-        this.queueSizeSetting = Setting.intSetting(queueSizeKey, queueSize, properties);
-    }
-
-    @Override
-    public List<Setting<?>> getRegisteredSettings() {
-        return Arrays.asList(sizeSetting, queueSizeSetting);
-    }
-
-    @Override
-    FixedExecutorSettings getSettings(Settings settings) {
-        final String nodeName = Node.NODE_NAME_SETTING.get(settings);
-        final int size = sizeSetting.get(settings);
-        final int queueSize = queueSizeSetting.get(settings);
-        return new FixedExecutorSettings(nodeName, size, queueSize);
-    }
-
-    @Override
-    ProtobufThreadPool.ExecutorHolder build(final FixedExecutorSettings settings, final ThreadContext threadContext) {
-        int size = settings.size;
-        int queueSize = settings.queueSize;
-        final ThreadFactory threadFactory = OpenSearchExecutors.daemonThreadFactory(
-            OpenSearchExecutors.threadName(settings.nodeName, name())
-        );
-        final ExecutorService executor = OpenSearchExecutors.newFixed(
-            settings.nodeName + "/" + name(),
-            size,
-            queueSize,
-            threadFactory,
-            threadContext
-        );
-        final ProtobufThreadPool.Info info = new ProtobufThreadPool.Info(
-            name(),
-            ProtobufThreadPool.ThreadPoolType.FIXED,
-            size,
-            size,
-            null,
-            queueSize < 0 ? null : new ProtobufSizeValue(queueSize)
-        );
-        return new ProtobufThreadPool.ExecutorHolder(executor, info);
-    }
-
-    @Override
-    String formatInfo(ProtobufThreadPool.Info info) {
-        return String.format(
-            Locale.ROOT,
-            "name [%s], size [%d], queue size [%s]",
-            info.getName(),
-            info.getMax(),
-            info.getQueueSize() == null ? "unbounded" : info.getQueueSize()
-        );
-    }
-
-    static class FixedExecutorSettings extends ProtobufExecutorBuilder.ExecutorSettings {
-
-        private final int size;
-        private final int queueSize;
-
-        FixedExecutorSettings(final String nodeName, final int size, final int queueSize) {
-            super(nodeName);
-            this.size = size;
-            this.queueSize = queueSize;
-        }
-
-    }
-
-}
diff --git a/server/src/main/java/org/opensearch/threadpool/ProtobufResizableExecutorBuilder.java b/server/src/main/java/org/opensearch/threadpool/ProtobufResizableExecutorBuilder.java
deleted file mode 100644
index f95a13d2b6a82..0000000000000
--- a/server/src/main/java/org/opensearch/threadpool/ProtobufResizableExecutorBuilder.java
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.threadpool;
-
-import org.opensearch.common.settings.Setting;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.unit.ProtobufSizeValue;
-import org.opensearch.common.util.concurrent.OpenSearchExecutors;
-import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.node.Node;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.Locale;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.atomic.AtomicReference;
-
-/**
- * A builder for resizable executors.
-*
-* @opensearch.internal
-*/
-public final class ProtobufResizableExecutorBuilder extends ProtobufExecutorBuilder<
-    ProtobufResizableExecutorBuilder.ResizableExecutorSettings> {
-
-    private final Setting<Integer> sizeSetting;
-    private final Setting<Integer> queueSizeSetting;
-    private final AtomicReference<RunnableTaskExecutionListener> runnableTaskListener;
-
-    ProtobufResizableExecutorBuilder(
-        final Settings settings,
-        final String name,
-        final int size,
-        final int queueSize,
-        final AtomicReference<RunnableTaskExecutionListener> runnableTaskListener
-    ) {
-        this(settings, name, size, queueSize, "thread_pool." + name, runnableTaskListener);
-    }
-
-    public ProtobufResizableExecutorBuilder(
-        final Settings settings,
-        final String name,
-        final int size,
-        final int queueSize,
-        final String prefix,
-        final AtomicReference<RunnableTaskExecutionListener> runnableTaskListener
-    ) {
-        super(name);
-        final String sizeKey = settingsKey(prefix, "size");
-        this.sizeSetting = new Setting<>(
-            sizeKey,
-            s -> Integer.toString(size),
-            s -> Setting.parseInt(s, 1, applyHardSizeLimit(settings, name), sizeKey),
-            Setting.Property.NodeScope
-        );
-        final String queueSizeKey = settingsKey(prefix, "queue_size");
-        this.queueSizeSetting = Setting.intSetting(
-            queueSizeKey,
-            queueSize,
-            new Setting.Property[] { Setting.Property.NodeScope, Setting.Property.Dynamic }
-        );
-        this.runnableTaskListener = runnableTaskListener;
-    }
-
-    @Override
-    public List<Setting<?>> getRegisteredSettings() {
-        return Arrays.asList(sizeSetting, queueSizeSetting);
-    }
-
-    @Override
-    ResizableExecutorSettings getSettings(Settings settings) {
-        final String nodeName = Node.NODE_NAME_SETTING.get(settings);
-        final int size = sizeSetting.get(settings);
-        final int queueSize = queueSizeSetting.get(settings);
-        return new ResizableExecutorSettings(nodeName, size, queueSize);
-    }
-
-    @Override
-    ProtobufThreadPool.ExecutorHolder build(final ResizableExecutorSettings settings, final ThreadContext threadContext) {
-        int size = settings.size;
-        int queueSize = settings.queueSize;
-        final ThreadFactory threadFactory = OpenSearchExecutors.daemonThreadFactory(
-            OpenSearchExecutors.threadName(settings.nodeName, name())
-        );
-        final ExecutorService executor = OpenSearchExecutors.newResizable(
-            settings.nodeName + "/" + name(),
-            size,
-            queueSize,
-            threadFactory,
-            threadContext,
-            runnableTaskListener
-        );
-        final ProtobufThreadPool.Info info = new ProtobufThreadPool.Info(
-            name(),
-            ProtobufThreadPool.ThreadPoolType.RESIZABLE,
-            size,
-            size,
-            null,
-            queueSize < 0 ? null : new ProtobufSizeValue(queueSize)
-        );
-        return new ProtobufThreadPool.ExecutorHolder(executor, info);
-    }
-
-    @Override
-    String formatInfo(ProtobufThreadPool.Info info) {
-        return String.format(
-            Locale.ROOT,
-            "name [%s], size [%d], queue size [%s]",
-            info.getName(),
-            info.getMax(),
-            info.getQueueSize() == null ? "unbounded" : info.getQueueSize()
-        );
-    }
-
-    static class ResizableExecutorSettings extends ProtobufExecutorBuilder.ExecutorSettings {
-
-        private final int size;
-        private final int queueSize;
-
-        ResizableExecutorSettings(final String nodeName, final int size, final int queueSize) {
-            super(nodeName);
-            this.size = size;
-            this.queueSize = queueSize;
-        }
-
-    }
-}
diff --git a/server/src/main/java/org/opensearch/threadpool/ProtobufScalingExecutorBuilder.java b/server/src/main/java/org/opensearch/threadpool/ProtobufScalingExecutorBuilder.java
deleted file mode 100644
index 583dfb4e785ba..0000000000000
--- a/server/src/main/java/org/opensearch/threadpool/ProtobufScalingExecutorBuilder.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.threadpool;
-
-import org.opensearch.common.settings.Setting;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.common.util.concurrent.OpenSearchExecutors;
-import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.node.Node;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.Locale;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.TimeUnit;
-
-/**
- * A builder for scaling executors.
-*
-* @opensearch.internal
-*/
-public final class ProtobufScalingExecutorBuilder extends ProtobufExecutorBuilder<ProtobufScalingExecutorBuilder.ScalingExecutorSettings> {
-
-    private final Setting<Integer> coreSetting;
-    private final Setting<Integer> maxSetting;
-    private final Setting<TimeValue> keepAliveSetting;
-
-    /**
-     * Construct a scaling executor builder; the settings will have the
-    * key prefix "thread_pool." followed by the executor name.
-    *
-    * @param name      the name of the executor
-    * @param core      the minimum number of threads in the pool
-    * @param max       the maximum number of threads in the pool
-    * @param keepAlive the time that spare threads above {@code core}
-    *                  threads will be kept alive
-    */
-    public ProtobufScalingExecutorBuilder(final String name, final int core, final int max, final TimeValue keepAlive) {
-        this(name, core, max, keepAlive, "thread_pool." + name);
-    }
-
-    /**
-     * Construct a scaling executor builder; the settings will have the
-    * specified key prefix.
-    *
-    * @param name      the name of the executor
-    * @param core      the minimum number of threads in the pool
-    * @param max       the maximum number of threads in the pool
-    * @param keepAlive the time that spare threads above {@code core}
-    *                  threads will be kept alive
-    * @param prefix    the prefix for the settings keys
-    */
-    public ProtobufScalingExecutorBuilder(
-        final String name,
-        final int core,
-        final int max,
-        final TimeValue keepAlive,
-        final String prefix
-    ) {
-        super(name);
-        this.coreSetting = Setting.intSetting(settingsKey(prefix, "core"), core, Setting.Property.NodeScope);
-        this.maxSetting = Setting.intSetting(settingsKey(prefix, "max"), max, Setting.Property.NodeScope);
-        this.keepAliveSetting = Setting.timeSetting(settingsKey(prefix, "keep_alive"), keepAlive, Setting.Property.NodeScope);
-    }
-
-    @Override
-    public List<Setting<?>> getRegisteredSettings() {
-        return Arrays.asList(coreSetting, maxSetting, keepAliveSetting);
-    }
-
-    @Override
-    ScalingExecutorSettings getSettings(Settings settings) {
-        final String nodeName = Node.NODE_NAME_SETTING.get(settings);
-        final int coreThreads = coreSetting.get(settings);
-        final int maxThreads = maxSetting.get(settings);
-        final TimeValue keepAlive = keepAliveSetting.get(settings);
-        return new ScalingExecutorSettings(nodeName, coreThreads, maxThreads, keepAlive);
-    }
-
-    ProtobufThreadPool.ExecutorHolder build(final ScalingExecutorSettings settings, final ThreadContext threadContext) {
-        TimeValue keepAlive = settings.keepAlive;
-        int core = settings.core;
-        int max = settings.max;
-        final ProtobufThreadPool.Info info = new ProtobufThreadPool.Info(
-            name(),
-            ProtobufThreadPool.ThreadPoolType.SCALING,
-            core,
-            max,
-            keepAlive,
-            null
-        );
-        final ThreadFactory threadFactory = OpenSearchExecutors.daemonThreadFactory(
-            OpenSearchExecutors.threadName(settings.nodeName, name())
-        );
-        final ExecutorService executor = OpenSearchExecutors.newScaling(
-            settings.nodeName + "/" + name(),
-            core,
-            max,
-            keepAlive.millis(),
-            TimeUnit.MILLISECONDS,
-            threadFactory,
-            threadContext
-        );
-        return new ProtobufThreadPool.ExecutorHolder(executor, info);
-    }
-
-    @Override
-    String formatInfo(ProtobufThreadPool.Info info) {
-        return String.format(
-            Locale.ROOT,
-            "name [%s], core [%d], max [%d], keep alive [%s]",
-            info.getName(),
-            info.getMin(),
-            info.getMax(),
-            info.getKeepAlive()
-        );
-    }
-
-    static class ScalingExecutorSettings extends ProtobufExecutorBuilder.ExecutorSettings {
-
-        private final int core;
-        private final int max;
-        private final TimeValue keepAlive;
-
-        ScalingExecutorSettings(final String nodeName, final int core, final int max, final TimeValue keepAlive) {
-            super(nodeName);
-            this.core = core;
-            this.max = max;
-            this.keepAlive = keepAlive;
-        }
-    }
-
-}
diff --git a/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPool.java b/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPool.java
deleted file mode 100644
index c77984a5a5953..0000000000000
--- a/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPool.java
+++ /dev/null
@@ -1,860 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.threadpool;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.message.ParameterizedMessage;
-import org.opensearch.Version;
-import org.opensearch.common.Nullable;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.settings.Setting;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.unit.ProtobufSizeValue;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.common.util.concurrent.OpenSearchExecutors;
-import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
-import org.opensearch.common.util.concurrent.OpenSearchThreadPoolExecutor;
-import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.common.util.concurrent.XRejectedExecutionHandler;
-import org.opensearch.node.Node;
-import org.opensearch.node.ProtobufReportingService;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.Executor;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.RejectedExecutionException;
-import java.util.concurrent.RejectedExecutionHandler;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledThreadPoolExecutor;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.stream.Collectors;
-
-import static java.util.Collections.unmodifiableMap;
-
-/**
- * The OpenSearch threadpool class
-*
-* @opensearch.internal
-*/
-public class ProtobufThreadPool implements ProtobufReportingService<ProtobufThreadPoolInfo>, Scheduler {
-
-    private static final Logger logger = LogManager.getLogger(ThreadPool.class);
-
-    /**
-     * The threadpool names.
-    *
-    * @opensearch.internal
-    */
-    public static class Names {
-        public static final String SAME = "same";
-        public static final String GENERIC = "generic";
-        @Deprecated
-        public static final String LISTENER = "listener";
-        public static final String GET = "get";
-        public static final String ANALYZE = "analyze";
-        public static final String WRITE = "write";
-        public static final String SEARCH = "search";
-        public static final String SEARCH_THROTTLED = "search_throttled";
-        public static final String MANAGEMENT = "management";
-        public static final String FLUSH = "flush";
-        public static final String REFRESH = "refresh";
-        public static final String WARMER = "warmer";
-        public static final String SNAPSHOT = "snapshot";
-        public static final String FORCE_MERGE = "force_merge";
-        public static final String FETCH_SHARD_STARTED = "fetch_shard_started";
-        public static final String FETCH_SHARD_STORE = "fetch_shard_store";
-        public static final String SYSTEM_READ = "system_read";
-        public static final String SYSTEM_WRITE = "system_write";
-        public static final String TRANSLOG_TRANSFER = "translog_transfer";
-        public static final String TRANSLOG_SYNC = "translog_sync";
-        public static final String REMOTE_PURGE = "remote_purge";
-    }
-
-    /**
-     * The threadpool type.
-    *
-    * @opensearch.internal
-    */
-    public enum ThreadPoolType {
-        DIRECT("direct"),
-        FIXED("fixed"),
-        RESIZABLE("resizable"),
-        SCALING("scaling");
-
-        private final String type;
-
-        public String getType() {
-            return type;
-        }
-
-        ThreadPoolType(String type) {
-            this.type = type;
-        }
-
-        private static final Map<String, ThreadPoolType> TYPE_MAP;
-
-        static {
-            Map<String, ThreadPoolType> typeMap = new HashMap<>();
-            for (ThreadPoolType threadPoolType : ThreadPoolType.values()) {
-                typeMap.put(threadPoolType.getType(), threadPoolType);
-            }
-            TYPE_MAP = Collections.unmodifiableMap(typeMap);
-        }
-
-        public static ThreadPoolType fromType(String type) {
-            ThreadPoolType threadPoolType = TYPE_MAP.get(type);
-            if (threadPoolType == null) {
-                throw new IllegalArgumentException("no ThreadPoolType for " + type);
-            }
-            return threadPoolType;
-        }
-    }
-
-    public static final Map<String, ThreadPoolType> THREAD_POOL_TYPES;
-
-    static {
-        HashMap<String, ThreadPoolType> map = new HashMap<>();
-        map.put(Names.SAME, ThreadPoolType.DIRECT);
-        map.put(Names.GENERIC, ThreadPoolType.SCALING);
-        map.put(Names.LISTENER, ThreadPoolType.FIXED);
-        map.put(Names.GET, ThreadPoolType.FIXED);
-        map.put(Names.ANALYZE, ThreadPoolType.FIXED);
-        map.put(Names.WRITE, ThreadPoolType.FIXED);
-        map.put(Names.SEARCH, ThreadPoolType.RESIZABLE);
-        map.put(Names.MANAGEMENT, ThreadPoolType.SCALING);
-        map.put(Names.FLUSH, ThreadPoolType.SCALING);
-        map.put(Names.REFRESH, ThreadPoolType.SCALING);
-        map.put(Names.WARMER, ThreadPoolType.SCALING);
-        map.put(Names.SNAPSHOT, ThreadPoolType.SCALING);
-        map.put(Names.FORCE_MERGE, ThreadPoolType.FIXED);
-        map.put(Names.FETCH_SHARD_STARTED, ThreadPoolType.SCALING);
-        map.put(Names.FETCH_SHARD_STORE, ThreadPoolType.SCALING);
-        map.put(Names.SEARCH_THROTTLED, ThreadPoolType.RESIZABLE);
-        map.put(Names.SYSTEM_READ, ThreadPoolType.FIXED);
-        map.put(Names.SYSTEM_WRITE, ThreadPoolType.FIXED);
-        map.put(Names.TRANSLOG_TRANSFER, ThreadPoolType.SCALING);
-        map.put(Names.TRANSLOG_SYNC, ThreadPoolType.FIXED);
-        map.put(Names.REMOTE_PURGE, ThreadPoolType.SCALING);
-        THREAD_POOL_TYPES = Collections.unmodifiableMap(map);
-    }
-
-    private final Map<String, ExecutorHolder> executors;
-
-    private final ProtobufThreadPoolInfo threadPoolInfo;
-
-    private final CachedTimeThread cachedTimeThread;
-
-    static final ExecutorService DIRECT_EXECUTOR = OpenSearchExecutors.newDirectExecutorService();
-
-    private final ThreadContext threadContext;
-
-    private final Map<String, ProtobufExecutorBuilder> builders;
-
-    private final ScheduledThreadPoolExecutor scheduler;
-
-    public Collection<ProtobufExecutorBuilder> builders() {
-        return Collections.unmodifiableCollection(builders.values());
-    }
-
-    public static Setting<TimeValue> ESTIMATED_TIME_INTERVAL_SETTING = Setting.timeSetting(
-        "thread_pool.estimated_time_interval",
-        TimeValue.timeValueMillis(200),
-        TimeValue.ZERO,
-        Setting.Property.NodeScope
-    );
-
-    public ProtobufThreadPool(final Settings settings, final ProtobufExecutorBuilder<?>... customBuilders) {
-        this(settings, null, customBuilders);
-    }
-
-    public ProtobufThreadPool(
-        final Settings settings,
-        final AtomicReference<RunnableTaskExecutionListener> runnableTaskListener,
-        final ProtobufExecutorBuilder<?>... customBuilders
-    ) {
-        assert Node.NODE_NAME_SETTING.exists(settings);
-
-        final Map<String, ProtobufExecutorBuilder> builders = new HashMap<>();
-        final int allocatedProcessors = OpenSearchExecutors.allocatedProcessors(settings);
-        final int halfProcMaxAt5 = halfAllocatedProcessorsMaxFive(allocatedProcessors);
-        final int halfProcMaxAt10 = halfAllocatedProcessorsMaxTen(allocatedProcessors);
-        final int genericThreadPoolMax = boundedBy(4 * allocatedProcessors, 128, 512);
-        builders.put(
-            Names.GENERIC,
-            new ProtobufScalingExecutorBuilder(Names.GENERIC, 4, genericThreadPoolMax, TimeValue.timeValueSeconds(30))
-        );
-        builders.put(Names.WRITE, new ProtobufFixedExecutorBuilder(settings, Names.WRITE, allocatedProcessors, 10000));
-        builders.put(Names.GET, new ProtobufFixedExecutorBuilder(settings, Names.GET, allocatedProcessors, 1000));
-        builders.put(Names.ANALYZE, new ProtobufFixedExecutorBuilder(settings, Names.ANALYZE, 1, 16));
-        builders.put(
-            Names.SEARCH,
-            new ProtobufResizableExecutorBuilder(
-                settings,
-                Names.SEARCH,
-                searchThreadPoolSize(allocatedProcessors),
-                1000,
-                runnableTaskListener
-            )
-        );
-        builders.put(
-            Names.SEARCH_THROTTLED,
-            new ProtobufResizableExecutorBuilder(settings, Names.SEARCH_THROTTLED, 1, 100, runnableTaskListener)
-        );
-        builders.put(Names.MANAGEMENT, new ProtobufScalingExecutorBuilder(Names.MANAGEMENT, 1, 5, TimeValue.timeValueMinutes(5)));
-        // no queue as this means clients will need to handle rejections on listener queue even if the operation succeeded
-        // the assumption here is that the listeners should be very lightweight on the listeners side
-        builders.put(Names.LISTENER, new ProtobufFixedExecutorBuilder(settings, Names.LISTENER, halfProcMaxAt10, -1, true));
-        builders.put(Names.FLUSH, new ProtobufScalingExecutorBuilder(Names.FLUSH, 1, halfProcMaxAt5, TimeValue.timeValueMinutes(5)));
-        builders.put(Names.REFRESH, new ProtobufScalingExecutorBuilder(Names.REFRESH, 1, halfProcMaxAt10, TimeValue.timeValueMinutes(5)));
-        builders.put(Names.WARMER, new ProtobufScalingExecutorBuilder(Names.WARMER, 1, halfProcMaxAt5, TimeValue.timeValueMinutes(5)));
-        builders.put(Names.SNAPSHOT, new ProtobufScalingExecutorBuilder(Names.SNAPSHOT, 1, halfProcMaxAt5, TimeValue.timeValueMinutes(5)));
-        builders.put(
-            Names.FETCH_SHARD_STARTED,
-            new ProtobufScalingExecutorBuilder(Names.FETCH_SHARD_STARTED, 1, 2 * allocatedProcessors, TimeValue.timeValueMinutes(5))
-        );
-        builders.put(Names.FORCE_MERGE, new ProtobufFixedExecutorBuilder(settings, Names.FORCE_MERGE, 1, -1));
-        builders.put(
-            Names.FETCH_SHARD_STORE,
-            new ProtobufScalingExecutorBuilder(Names.FETCH_SHARD_STORE, 1, 2 * allocatedProcessors, TimeValue.timeValueMinutes(5))
-        );
-        builders.put(Names.SYSTEM_READ, new ProtobufFixedExecutorBuilder(settings, Names.SYSTEM_READ, halfProcMaxAt5, 2000, false));
-        builders.put(Names.SYSTEM_WRITE, new ProtobufFixedExecutorBuilder(settings, Names.SYSTEM_WRITE, halfProcMaxAt5, 1000, false));
-        builders.put(
-            Names.TRANSLOG_TRANSFER,
-            new ProtobufScalingExecutorBuilder(Names.TRANSLOG_TRANSFER, 1, halfProcMaxAt10, TimeValue.timeValueMinutes(5))
-        );
-        builders.put(Names.TRANSLOG_SYNC, new ProtobufFixedExecutorBuilder(settings, Names.TRANSLOG_SYNC, allocatedProcessors * 4, 10000));
-        builders.put(
-            Names.REMOTE_PURGE,
-            new ProtobufScalingExecutorBuilder(Names.REMOTE_PURGE, 1, halfProcMaxAt5, TimeValue.timeValueMinutes(5))
-        );
-
-        for (final ProtobufExecutorBuilder<?> builder : customBuilders) {
-            if (builders.containsKey(builder.name())) {
-                throw new IllegalArgumentException("builder with name [" + builder.name() + "] already exists");
-            }
-            builders.put(builder.name(), builder);
-        }
-        this.builders = Collections.unmodifiableMap(builders);
-
-        threadContext = new ThreadContext(settings);
-
-        final Map<String, ExecutorHolder> executors = new HashMap<>();
-        for (final Map.Entry<String, ProtobufExecutorBuilder> entry : builders.entrySet()) {
-            final ProtobufExecutorBuilder.ExecutorSettings executorSettings = entry.getValue().getSettings(settings);
-            final ExecutorHolder executorHolder = entry.getValue().build(executorSettings, threadContext);
-            if (executors.containsKey(executorHolder.info.getName())) {
-                throw new IllegalStateException("duplicate executors with name [" + executorHolder.info.getName() + "] registered");
-            }
-            logger.debug("created thread pool: {}", entry.getValue().formatInfo(executorHolder.info));
-            executors.put(entry.getKey(), executorHolder);
-        }
-
-        executors.put(Names.SAME, new ExecutorHolder(DIRECT_EXECUTOR, new Info(Names.SAME, ThreadPoolType.DIRECT)));
-        this.executors = unmodifiableMap(executors);
-
-        final List<Info> infos = executors.values()
-            .stream()
-            .filter(holder -> holder.info.getName().equals("same") == false)
-            .map(holder -> holder.info)
-            .collect(Collectors.toList());
-        this.threadPoolInfo = new ProtobufThreadPoolInfo(infos);
-        this.scheduler = Scheduler.initScheduler(settings);
-        TimeValue estimatedTimeInterval = ESTIMATED_TIME_INTERVAL_SETTING.get(settings);
-        this.cachedTimeThread = new CachedTimeThread(OpenSearchExecutors.threadName(settings, "[timer]"), estimatedTimeInterval.millis());
-        this.cachedTimeThread.start();
-    }
-
-    /**
-     * Returns a value of milliseconds that may be used for relative time calculations.
-    *
-    * This method should only be used for calculating time deltas. For an epoch based
-    * timestamp, see {@link #absoluteTimeInMillis()}.
-    */
-    public long relativeTimeInMillis() {
-        return TimeValue.nsecToMSec(relativeTimeInNanos());
-    }
-
-    /**
-     * Returns a value of nanoseconds that may be used for relative time calculations.
-    *
-    * This method should only be used for calculating time deltas. For an epoch based
-    * timestamp, see {@link #absoluteTimeInMillis()}.
-    */
-    public long relativeTimeInNanos() {
-        return cachedTimeThread.relativeTimeInNanos();
-    }
-
-    /**
-     * Returns the value of milliseconds since UNIX epoch.
-    *
-    * This method should only be used for exact date/time formatting. For calculating
-    * time deltas that should not suffer from negative deltas, which are possible with
-    * this method, see {@link #relativeTimeInMillis()}.
-    */
-    public long absoluteTimeInMillis() {
-        return cachedTimeThread.absoluteTimeInMillis();
-    }
-
-    @Override
-    public ProtobufThreadPoolInfo info() {
-        return threadPoolInfo;
-    }
-
-    public Info info(String name) {
-        ExecutorHolder holder = executors.get(name);
-        if (holder == null) {
-            return null;
-        }
-        return holder.info;
-    }
-
-    public ThreadPoolStats stats() {
-        List<ThreadPoolStats.Stats> stats = new ArrayList<>();
-        for (ExecutorHolder holder : executors.values()) {
-            final String name = holder.info.getName();
-            // no need to have info on "same" thread pool
-            if ("same".equals(name)) {
-                continue;
-            }
-            int threads = -1;
-            int queue = -1;
-            int active = -1;
-            long rejected = -1;
-            int largest = -1;
-            long completed = -1;
-            if (holder.executor() instanceof ThreadPoolExecutor) {
-                ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) holder.executor();
-                threads = threadPoolExecutor.getPoolSize();
-                queue = threadPoolExecutor.getQueue().size();
-                active = threadPoolExecutor.getActiveCount();
-                largest = threadPoolExecutor.getLargestPoolSize();
-                completed = threadPoolExecutor.getCompletedTaskCount();
-                RejectedExecutionHandler rejectedExecutionHandler = threadPoolExecutor.getRejectedExecutionHandler();
-                if (rejectedExecutionHandler instanceof XRejectedExecutionHandler) {
-                    rejected = ((XRejectedExecutionHandler) rejectedExecutionHandler).rejected();
-                }
-            }
-            stats.add(new ThreadPoolStats.Stats(name, threads, queue, active, rejected, largest, completed));
-        }
-        return new ThreadPoolStats(stats);
-    }
-
-    /**
-     * Get the generic {@link ExecutorService}. This executor service
-    * {@link Executor#execute(Runnable)} method will run the {@link Runnable} it is given in the
-    * {@link ThreadContext} of the thread that queues it.
-    * <p>
-    * Warning: this {@linkplain ExecutorService} will not throw {@link RejectedExecutionException}
-    * if you submit a task while it shutdown. It will instead silently queue it and not run it.
-    */
-    public ExecutorService generic() {
-        return executor(Names.GENERIC);
-    }
-
-    /**
-     * Get the {@link ExecutorService} with the given name. This executor service's
-    * {@link Executor#execute(Runnable)} method will run the {@link Runnable} it is given in the
-    * {@link ThreadContext} of the thread that queues it.
-    * <p>
-    * Warning: this {@linkplain ExecutorService} might not throw {@link RejectedExecutionException}
-    * if you submit a task while it shutdown. It will instead silently queue it and not run it.
-    *
-    * @param name the name of the executor service to obtain
-    * @throws IllegalArgumentException if no executor service with the specified name exists
-    */
-    public ExecutorService executor(String name) {
-        final ExecutorHolder holder = executors.get(name);
-        if (holder == null) {
-            throw new IllegalArgumentException("no executor service found for [" + name + "]");
-        }
-        return holder.executor();
-    }
-
-    /**
-     * Schedules a one-shot command to run after a given delay. The command is run in the context of the calling thread.
-    *
-    * @param command the command to run
-    * @param delay delay before the task executes
-    * @param executor the name of the thread pool on which to execute this task. SAME means "execute on the scheduler thread" which changes
-    *        the meaning of the ScheduledFuture returned by this method. In that case the ScheduledFuture will complete only when the
-    *        command completes.
-    * @return a ScheduledFuture who's get will return when the task is has been added to its target thread pool and throw an exception if
-    *         the task is canceled before it was added to its target thread pool. Once the task has been added to its target thread pool
-    *         the ScheduledFuture will cannot interact with it.
-    * @throws OpenSearchRejectedExecutionException if the task cannot be scheduled for execution
-    */
-    @Override
-    public ScheduledCancellable schedule(Runnable command, TimeValue delay, String executor) {
-        command = threadContext.preserveContext(command);
-        if (!Names.SAME.equals(executor)) {
-            command = new ThreadedRunnable(command, executor(executor));
-        }
-        return new ScheduledCancellableAdapter(scheduler.schedule(command, delay.millis(), TimeUnit.MILLISECONDS));
-    }
-
-    public void scheduleUnlessShuttingDown(TimeValue delay, String executor, Runnable command) {
-        try {
-            schedule(command, delay, executor);
-        } catch (OpenSearchRejectedExecutionException e) {
-            if (e.isExecutorShutdown()) {
-                logger.debug(
-                    new ParameterizedMessage(
-                        "could not schedule execution of [{}] after [{}] on [{}] as executor is shut down",
-                        command,
-                        delay,
-                        executor
-                    ),
-                    e
-                );
-            } else {
-                throw e;
-            }
-        }
-    }
-
-    @Override
-    public Cancellable scheduleWithFixedDelay(Runnable command, TimeValue interval, String executor) {
-        return new ReschedulingRunnable(command, interval, executor, this, (e) -> {
-            if (logger.isDebugEnabled()) {
-                logger.debug(() -> new ParameterizedMessage("scheduled task [{}] was rejected on thread pool [{}]", command, executor), e);
-            }
-        },
-            (e) -> logger.warn(
-                () -> new ParameterizedMessage("failed to run scheduled task [{}] on thread pool [{}]", command, executor),
-                e
-            )
-        );
-    }
-
-    protected final void stopCachedTimeThread() {
-        cachedTimeThread.running = false;
-        cachedTimeThread.interrupt();
-    }
-
-    public void shutdown() {
-        stopCachedTimeThread();
-        scheduler.shutdown();
-        for (ExecutorHolder executor : executors.values()) {
-            if (executor.executor() instanceof ThreadPoolExecutor) {
-                executor.executor().shutdown();
-            }
-        }
-    }
-
-    public void shutdownNow() {
-        stopCachedTimeThread();
-        scheduler.shutdownNow();
-        for (ExecutorHolder executor : executors.values()) {
-            if (executor.executor() instanceof ThreadPoolExecutor) {
-                executor.executor().shutdownNow();
-            }
-        }
-    }
-
-    public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
-        boolean result = scheduler.awaitTermination(timeout, unit);
-        for (ExecutorHolder executor : executors.values()) {
-            if (executor.executor() instanceof ThreadPoolExecutor) {
-                result &= executor.executor().awaitTermination(timeout, unit);
-            }
-        }
-        cachedTimeThread.join(unit.toMillis(timeout));
-        return result;
-    }
-
-    public ScheduledExecutorService scheduler() {
-        return this.scheduler;
-    }
-
-    /**
-     * Constrains a value between minimum and maximum values
-    * (inclusive).
-    *
-    * @param value the value to constrain
-    * @param min   the minimum acceptable value
-    * @param max   the maximum acceptable value
-    * @return min if value is less than min, max if value is greater
-    * than value, otherwise value
-    */
-    static int boundedBy(int value, int min, int max) {
-        return Math.min(max, Math.max(min, value));
-    }
-
-    static int halfAllocatedProcessorsMaxFive(final int allocatedProcessors) {
-        return boundedBy((allocatedProcessors + 1) / 2, 1, 5);
-    }
-
-    static int halfAllocatedProcessorsMaxTen(final int allocatedProcessors) {
-        return boundedBy((allocatedProcessors + 1) / 2, 1, 10);
-    }
-
-    static int twiceAllocatedProcessors(final int allocatedProcessors) {
-        return boundedBy(2 * allocatedProcessors, 2, Integer.MAX_VALUE);
-    }
-
-    public static int searchThreadPoolSize(final int allocatedProcessors) {
-        return ((allocatedProcessors * 3) / 2) + 1;
-    }
-
-    class LoggingRunnable implements Runnable {
-
-        private final Runnable runnable;
-
-        LoggingRunnable(Runnable runnable) {
-            this.runnable = runnable;
-        }
-
-        @Override
-        public void run() {
-            try {
-                runnable.run();
-            } catch (Exception e) {
-                logger.warn(() -> new ParameterizedMessage("failed to run {}", runnable.toString()), e);
-                throw e;
-            }
-        }
-
-        @Override
-        public int hashCode() {
-            return runnable.hashCode();
-        }
-
-        @Override
-        public boolean equals(Object obj) {
-            return runnable.equals(obj);
-        }
-
-        @Override
-        public String toString() {
-            return "[threaded] " + runnable.toString();
-        }
-    }
-
-    class ThreadedRunnable implements Runnable {
-
-        private final Runnable runnable;
-
-        private final Executor executor;
-
-        ThreadedRunnable(Runnable runnable, Executor executor) {
-            this.runnable = runnable;
-            this.executor = executor;
-        }
-
-        @Override
-        public void run() {
-            try {
-                executor.execute(runnable);
-            } catch (OpenSearchRejectedExecutionException e) {
-                if (e.isExecutorShutdown()) {
-                    logger.debug(
-                        new ParameterizedMessage(
-                            "could not schedule execution of [{}] on [{}] as executor is shut down",
-                            runnable,
-                            executor
-                        ),
-                        e
-                    );
-                } else {
-                    throw e;
-                }
-            }
-        }
-
-        @Override
-        public int hashCode() {
-            return runnable.hashCode();
-        }
-
-        @Override
-        public boolean equals(Object obj) {
-            return runnable.equals(obj);
-        }
-
-        @Override
-        public String toString() {
-            return "[threaded] " + runnable.toString();
-        }
-    }
-
-    /**
-     * A thread to cache millisecond time values from
-    * {@link System#nanoTime()} and {@link System#currentTimeMillis()}.
-    *
-    * The values are updated at a specified interval.
-    */
-    static class CachedTimeThread extends Thread {
-
-        final long interval;
-        volatile boolean running = true;
-        volatile long relativeNanos;
-        volatile long absoluteMillis;
-
-        CachedTimeThread(String name, long interval) {
-            super(name);
-            this.interval = interval;
-            this.relativeNanos = System.nanoTime();
-            this.absoluteMillis = System.currentTimeMillis();
-            setDaemon(true);
-        }
-
-        /**
-         * Return the current time used for relative calculations. This is {@link System#nanoTime()}.
-        * <p>
-        * If {@link ThreadPool#ESTIMATED_TIME_INTERVAL_SETTING} is set to 0
-        * then the cache is disabled and the method calls {@link System#nanoTime()}
-        * whenever called. Typically used for testing.
-        */
-        long relativeTimeInNanos() {
-            if (0 < interval) {
-                return relativeNanos;
-            }
-            return System.nanoTime();
-        }
-
-        /**
-         * Return the current epoch time, used to find absolute time. This is
-        * a cached version of {@link System#currentTimeMillis()}.
-        * <p>
-        * If {@link ThreadPool#ESTIMATED_TIME_INTERVAL_SETTING} is set to 0
-        * then the cache is disabled and the method calls {@link System#currentTimeMillis()}
-        * whenever called. Typically used for testing.
-        */
-        long absoluteTimeInMillis() {
-            if (0 < interval) {
-                return absoluteMillis;
-            }
-            return System.currentTimeMillis();
-        }
-
-        @Override
-        public void run() {
-            while (running && 0 < interval) {
-                relativeNanos = System.nanoTime();
-                absoluteMillis = System.currentTimeMillis();
-                try {
-                    Thread.sleep(interval);
-                } catch (InterruptedException e) {
-                    running = false;
-                    return;
-                }
-            }
-        }
-    }
-
-    static class ExecutorHolder {
-        private final ExecutorService executor;
-        public final Info info;
-
-        ExecutorHolder(ExecutorService executor, Info info) {
-            assert executor instanceof OpenSearchThreadPoolExecutor || executor == DIRECT_EXECUTOR;
-            this.executor = executor;
-            this.info = info;
-        }
-
-        ExecutorService executor() {
-            return executor;
-        }
-    }
-
-    /**
-     * The thread pool information.
-    *
-    * @opensearch.internal
-    */
-    public static class Info implements ProtobufWriteable {
-
-        private final String name;
-        private final ThreadPoolType type;
-        private final int min;
-        private final int max;
-        private final TimeValue keepAlive;
-        private final ProtobufSizeValue queueSize;
-
-        public Info(String name, ThreadPoolType type) {
-            this(name, type, -1);
-        }
-
-        public Info(String name, ThreadPoolType type, int size) {
-            this(name, type, size, size, null, null);
-        }
-
-        public Info(
-            String name,
-            ThreadPoolType type,
-            int min,
-            int max,
-            @Nullable TimeValue keepAlive,
-            @Nullable ProtobufSizeValue queueSize
-        ) {
-            this.name = name;
-            this.type = type;
-            this.min = min;
-            this.max = max;
-            this.keepAlive = keepAlive;
-            this.queueSize = queueSize;
-        }
-
-        public Info(CodedInputStream in) throws IOException {
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-            name = in.readString();
-            final String typeStr = in.readString();
-            // Opensearch on or after 3.0.0 version doesn't know about "fixed_auto_queue_size" thread pool. Convert it to RESIZABLE.
-            if (typeStr.equalsIgnoreCase("fixed_auto_queue_size")) {
-                type = ThreadPoolType.RESIZABLE;
-            } else {
-                type = ThreadPoolType.fromType(typeStr);
-            }
-            min = in.readInt32();
-            max = in.readInt32();
-            keepAlive = protobufStreamInput.readOptionalTimeValue();
-            queueSize = protobufStreamInput.readOptionalWriteable(ProtobufSizeValue::new);
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            out.writeStringNoTag(name);
-            if (type == ThreadPoolType.RESIZABLE && protobufStreamOutput.getVersion().before(Version.V_3_0_0)) {
-                // Opensearch on older version doesn't know about "resizable" thread pool. Convert RESIZABLE to FIXED
-                // to avoid serialization/de-serization issue between nodes with different OpenSearch version
-                out.writeStringNoTag(ThreadPoolType.FIXED.getType());
-            } else {
-                out.writeStringNoTag(type.getType());
-            }
-            out.writeInt32NoTag(min);
-            out.writeInt32NoTag(max);
-            protobufStreamOutput.writeOptionalTimeValue(keepAlive);
-            protobufStreamOutput.writeOptionalWriteable(queueSize);
-        }
-
-        public String getName() {
-            return this.name;
-        }
-
-        public ThreadPoolType getThreadPoolType() {
-            return this.type;
-        }
-
-        public int getMin() {
-            return this.min;
-        }
-
-        public int getMax() {
-            return this.max;
-        }
-
-        @Nullable
-        public TimeValue getKeepAlive() {
-            return this.keepAlive;
-        }
-
-        @Nullable
-        public ProtobufSizeValue getQueueSize() {
-            return this.queueSize;
-        }
-    }
-
-    /**
-     * Returns <code>true</code> if the given service was terminated successfully. If the termination timed out,
-    * the service is <code>null</code> this method will return <code>false</code>.
-    */
-    public static boolean terminate(ExecutorService service, long timeout, TimeUnit timeUnit) {
-        if (service != null) {
-            service.shutdown();
-            if (awaitTermination(service, timeout, timeUnit)) return true;
-            service.shutdownNow();
-            return awaitTermination(service, timeout, timeUnit);
-        }
-        return false;
-    }
-
-    private static boolean awaitTermination(final ExecutorService service, final long timeout, final TimeUnit timeUnit) {
-        try {
-            if (service.awaitTermination(timeout, timeUnit)) {
-                return true;
-            }
-        } catch (final InterruptedException e) {
-            Thread.currentThread().interrupt();
-        }
-        return false;
-    }
-
-    /**
-     * Returns <code>true</code> if the given pool was terminated successfully. If the termination timed out,
-    * the service is <code>null</code> this method will return <code>false</code>.
-    */
-    public static boolean terminate(ThreadPool pool, long timeout, TimeUnit timeUnit) {
-        if (pool != null) {
-            // Leverage try-with-resources to close the threadpool
-            pool.shutdown();
-            if (awaitTermination(pool, timeout, timeUnit)) {
-                return true;
-            }
-            // last resort
-            pool.shutdownNow();
-            return awaitTermination(pool, timeout, timeUnit);
-        }
-        return false;
-    }
-
-    private static boolean awaitTermination(final ThreadPool threadPool, final long timeout, final TimeUnit timeUnit) {
-        try {
-            if (threadPool.awaitTermination(timeout, timeUnit)) {
-                return true;
-            }
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-        }
-        return false;
-    }
-
-    public ThreadContext getThreadContext() {
-        return threadContext;
-    }
-
-    public static boolean assertNotScheduleThread(String reason) {
-        assert Thread.currentThread().getName().contains("scheduler") == false : "Expected current thread ["
-            + Thread.currentThread()
-            + "] to not be the scheduler thread. Reason: ["
-            + reason
-            + "]";
-        return true;
-    }
-
-    public static boolean assertCurrentMethodIsNotCalledRecursively() {
-        final StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
-        assert stackTraceElements.length >= 3 : stackTraceElements.length;
-        assert stackTraceElements[0].getMethodName().equals("getStackTrace") : stackTraceElements[0];
-        assert stackTraceElements[1].getMethodName().equals("assertCurrentMethodIsNotCalledRecursively") : stackTraceElements[1];
-        final StackTraceElement testingMethod = stackTraceElements[2];
-        for (int i = 3; i < stackTraceElements.length; i++) {
-            assert stackTraceElements[i].getClassName().equals(testingMethod.getClassName()) == false
-                || stackTraceElements[i].getMethodName().equals(testingMethod.getMethodName()) == false : testingMethod.getClassName()
-                    + "#"
-                    + testingMethod.getMethodName()
-                    + " is called recursively";
-        }
-        return true;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java b/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java
index f4a67d306f4bc..c9e3a51bb077c 100644
--- a/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java
+++ b/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java
@@ -25,17 +25,17 @@
 *
 * @opensearch.internal
 */
-public class ProtobufThreadPoolInfo implements ProtobufReportingService.ProtobufInfo, Iterable<ProtobufThreadPool.Info> {
+public class ProtobufThreadPoolInfo implements ProtobufReportingService.ProtobufInfo, Iterable<ThreadPool.Info> {
 
-    private final List<ProtobufThreadPool.Info> infos;
+    private final List<ThreadPool.Info> infos;
 
-    public ProtobufThreadPoolInfo(List<ProtobufThreadPool.Info> infos) {
+    public ProtobufThreadPoolInfo(List<ThreadPool.Info> infos) {
         this.infos = Collections.unmodifiableList(infos);
     }
 
     public ProtobufThreadPoolInfo(CodedInputStream in) throws IOException {
         ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        this.infos = Collections.unmodifiableList(protobufStreamInput.readList(ProtobufThreadPool.Info::new));
+        this.infos = Collections.unmodifiableList(protobufStreamInput.readList(ThreadPool.Info::new));
     }
 
     @Override
@@ -45,7 +45,7 @@ public void writeTo(CodedOutputStream out) throws IOException {
     }
 
     @Override
-    public Iterator<ProtobufThreadPool.Info> iterator() {
+    public Iterator<ThreadPool.Info> iterator() {
         return infos.iterator();
     }
 }
diff --git a/server/src/main/java/org/opensearch/threadpool/ThreadPool.java b/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
index 0851677bcb13a..fa94ec0156090 100644
--- a/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
+++ b/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
@@ -32,16 +32,22 @@
 
 package org.opensearch.threadpool;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.Version;
 import org.opensearch.common.Nullable;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.ProtobufSizeValue;
 import org.opensearch.common.unit.SizeValue;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.FeatureFlags;
@@ -53,10 +59,12 @@
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.node.Node;
+import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.node.ReportingService;
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
@@ -80,7 +88,7 @@
  *
  * @opensearch.internal
  */
-public class ThreadPool implements ReportingService<ThreadPoolInfo>, Scheduler {
+public class ThreadPool implements ReportingService<ThreadPoolInfo>, Scheduler, ProtobufReportingService<ProtobufThreadPoolInfo> {
 
     private static final Logger logger = LogManager.getLogger(ThreadPool.class);
 
@@ -359,6 +367,13 @@ public ThreadPoolInfo info() {
         return threadPoolInfo;
     }
 
+    @Override
+    public ProtobufThreadPoolInfo protobufInfo() {
+        List<ThreadPool.Info> threadPoolInfos = new ArrayList<>();
+        threadPoolInfo.iterator().forEachRemaining(threadPoolInfos::add);
+        return new ProtobufThreadPoolInfo(threadPoolInfos);
+    }
+
     public Info info(String name) {
         ExecutorHolder holder = executors.get(name);
         if (holder == null) {
@@ -398,6 +413,37 @@ public ThreadPoolStats stats() {
         return new ThreadPoolStats(stats);
     }
 
+    public ProtobufThreadPoolStats protobufStats() {
+        List<ProtobufThreadPoolStats.Stats> stats = new ArrayList<>();
+        for (ExecutorHolder holder : executors.values()) {
+            final String name = holder.info.getName();
+            // no need to have info on "same" thread pool
+            if ("same".equals(name)) {
+                continue;
+            }
+            int threads = -1;
+            int queue = -1;
+            int active = -1;
+            long rejected = -1;
+            int largest = -1;
+            long completed = -1;
+            if (holder.executor() instanceof ThreadPoolExecutor) {
+                ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) holder.executor();
+                threads = threadPoolExecutor.getPoolSize();
+                queue = threadPoolExecutor.getQueue().size();
+                active = threadPoolExecutor.getActiveCount();
+                largest = threadPoolExecutor.getLargestPoolSize();
+                completed = threadPoolExecutor.getCompletedTaskCount();
+                RejectedExecutionHandler rejectedExecutionHandler = threadPoolExecutor.getRejectedExecutionHandler();
+                if (rejectedExecutionHandler instanceof XRejectedExecutionHandler) {
+                    rejected = ((XRejectedExecutionHandler) rejectedExecutionHandler).rejected();
+                }
+            }
+            stats.add(new ProtobufThreadPoolStats.Stats(name, threads, queue, active, rejected, largest, completed));
+        }
+        return new ProtobufThreadPoolStats(stats);
+    }
+
     /**
      * Get the generic {@link ExecutorService}. This executor service
      * {@link Executor#execute(Runnable)} method will run the {@link Runnable} it is given in the
@@ -721,7 +767,7 @@ ExecutorService executor() {
      *
      * @opensearch.internal
      */
-    public static class Info implements Writeable, ToXContentFragment {
+    public static class Info implements Writeable, ToXContentFragment, ProtobufWriteable {
 
         private final String name;
         private final ThreadPoolType type;
@@ -778,6 +824,40 @@ public void writeTo(StreamOutput out) throws IOException {
             out.writeOptionalWriteable(queueSize);
         }
 
+        public Info(CodedInputStream in) throws IOException {
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+            name = in.readString();
+            final String typeStr = in.readString();
+            // Opensearch on or after 3.0.0 version doesn't know about "fixed_auto_queue_size" thread pool. Convert it to RESIZABLE.
+            if (typeStr.equalsIgnoreCase("fixed_auto_queue_size")) {
+                type = ThreadPoolType.RESIZABLE;
+            } else {
+                type = ThreadPoolType.fromType(typeStr);
+            }
+            min = in.readInt32();
+            max = in.readInt32();
+            keepAlive = protobufStreamInput.readOptionalTimeValue();
+            ProtobufSizeValue protobufQueueSize = protobufStreamInput.readOptionalWriteable(ProtobufSizeValue::new);
+            queueSize = new SizeValue(protobufQueueSize.getSize(), protobufQueueSize.getSizeUnit());
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+            out.writeStringNoTag(name);
+            if (type == ThreadPoolType.RESIZABLE && protobufStreamOutput.getVersion().before(Version.V_3_0_0)) {
+                // Opensearch on older version doesn't know about "resizable" thread pool. Convert RESIZABLE to FIXED
+                // to avoid serialization/de-serization issue between nodes with different OpenSearch version
+                out.writeStringNoTag(ThreadPoolType.FIXED.getType());
+            } else {
+                out.writeStringNoTag(type.getType());
+            }
+            out.writeInt32NoTag(min);
+            out.writeInt32NoTag(max);
+            protobufStreamOutput.writeOptionalTimeValue(keepAlive);
+            protobufStreamOutput.writeOptionalWriteable(new ProtobufSizeValue(queueSize.getSize(), queueSize.getSizeUnit()));
+        }
+
         public String getName() {
             return this.name;
         }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java b/server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java
index d8a3a7e87c80b..377451f06892d 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java
@@ -39,16 +39,16 @@ public class ProtobufClusterConnectionManager implements ProtobufConnectionManag
 
     private static final Logger logger = LogManager.getLogger(ProtobufClusterConnectionManager.class);
 
-    private final ConcurrentMap<ProtobufDiscoveryNode, ProtobufTransport.Connection> connectedNodes = ConcurrentCollections
+    private final ConcurrentMap<ProtobufDiscoveryNode, Transport.ProtobufConnection> connectedNodes = ConcurrentCollections
         .newConcurrentMap();
     private final ConcurrentMap<ProtobufDiscoveryNode, ListenableFuture<Void>> pendingConnections = ConcurrentCollections
         .newConcurrentMap();
     private final AbstractRefCounted connectingRefCounter = new AbstractRefCounted("connection manager") {
         @Override
         protected void closeInternal() {
-            Iterator<Map.Entry<ProtobufDiscoveryNode, ProtobufTransport.Connection>> iterator = connectedNodes.entrySet().iterator();
+            Iterator<Map.Entry<ProtobufDiscoveryNode, Transport.ProtobufConnection>> iterator = connectedNodes.entrySet().iterator();
             while (iterator.hasNext()) {
-                Map.Entry<ProtobufDiscoveryNode, ProtobufTransport.Connection> next = iterator.next();
+                Map.Entry<ProtobufDiscoveryNode, Transport.ProtobufConnection> next = iterator.next();
                 try {
                     IOUtils.closeWhileHandlingException(next.getValue());
                 } finally {
@@ -58,17 +58,17 @@ protected void closeInternal() {
             closeLatch.countDown();
         }
     };
-    private final ProtobufTransport transport;
+    private final Transport transport;
     private final ProtobufConnectionProfile defaultProfile;
     private final AtomicBoolean closing = new AtomicBoolean(false);
     private final CountDownLatch closeLatch = new CountDownLatch(1);
     private final DelegatingNodeConnectionListener connectionListener = new DelegatingNodeConnectionListener();
 
-    public ProtobufClusterConnectionManager(Settings settings, ProtobufTransport transport) {
+    public ProtobufClusterConnectionManager(Settings settings, Transport transport) {
         this(ProtobufConnectionProfile.buildDefaultConnectionProfile(settings), transport);
     }
 
-    public ProtobufClusterConnectionManager(ProtobufConnectionProfile connectionProfile, ProtobufTransport transport) {
+    public ProtobufClusterConnectionManager(ProtobufConnectionProfile connectionProfile, Transport transport) {
         this.transport = transport;
         this.defaultProfile = connectionProfile;
     }
@@ -87,7 +87,7 @@ public void removeListener(ProtobufTransportConnectionListener listener) {
     public void openConnection(
         ProtobufDiscoveryNode node,
         ProtobufConnectionProfile connectionProfile,
-        ActionListener<ProtobufTransport.Connection> listener
+        ActionListener<Transport.ProtobufConnection> listener
     ) {
         ProtobufConnectionProfile resolvedProfile = ProtobufConnectionProfile.resolveConnectionProfile(connectionProfile, defaultProfile);
         internalOpenConnection(node, resolvedProfile, listener);
@@ -149,7 +149,7 @@ public void connectToNode(
                         try {
                             connectionListener.onNodeConnected(node, conn);
                         } finally {
-                            final ProtobufTransport.Connection finalConnection = conn;
+                            final Transport.ProtobufConnection finalConnection = conn;
                             conn.addCloseListener(ActionListener.wrap(() -> {
                                 logger.trace("unregistering {} after connection close and marking as disconnected", node);
                                 connectedNodes.remove(node, finalConnection);
@@ -183,8 +183,8 @@ public void connectToNode(
     * @see #connectToNode(ProtobufDiscoveryNode, ProtobufConnectionProfile, ConnectionValidator, ActionListener)
     */
     @Override
-    public ProtobufTransport.Connection getConnection(ProtobufDiscoveryNode node) {
-        ProtobufTransport.Connection connection = connectedNodes.get(node);
+    public Transport.ProtobufConnection getConnection(ProtobufDiscoveryNode node) {
+        Transport.ProtobufConnection connection = connectedNodes.get(node);
         if (connection == null) {
             throw new ProtobufNodeNotConnectedException(node, "Node not connected");
         }
@@ -204,7 +204,7 @@ public boolean nodeConnected(ProtobufDiscoveryNode node) {
     */
     @Override
     public void disconnectFromNode(ProtobufDiscoveryNode node) {
-        ProtobufTransport.Connection nodeChannels = connectedNodes.remove(node);
+        Transport.ProtobufConnection nodeChannels = connectedNodes.remove(node);
         if (nodeChannels != null) {
             // if we found it and removed it we close
             nodeChannels.close();
@@ -252,9 +252,9 @@ private void internalClose(boolean waitForPendingConnections) {
     private void internalOpenConnection(
         ProtobufDiscoveryNode node,
         ProtobufConnectionProfile connectionProfile,
-        ActionListener<ProtobufTransport.Connection> listener
+        ActionListener<Transport.ProtobufConnection> listener
     ) {
-        transport.openConnection(node, connectionProfile, ActionListener.map(listener, connection -> {
+        transport.openProtobufConnection(node, connectionProfile, ActionListener.map(listener, connection -> {
             assert Transports.assertNotTransportThread("internalOpenConnection success");
             try {
                 connectionListener.onConnectionOpened(connection);
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java b/server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java
index 8e94a43d53d37..05d059955d0fb 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java
@@ -29,7 +29,7 @@ public interface ProtobufConnectionManager extends Closeable {
     void openConnection(
         ProtobufDiscoveryNode node,
         ProtobufConnectionProfile connectionProfile,
-        ActionListener<ProtobufTransport.Connection> listener
+        ActionListener<Transport.ProtobufConnection> listener
     );
 
     void connectToNode(
@@ -39,7 +39,7 @@ void connectToNode(
         ActionListener<Void> listener
     ) throws ConnectTransportException;
 
-    ProtobufTransport.Connection getConnection(ProtobufDiscoveryNode node);
+    Transport.ProtobufConnection getConnection(ProtobufDiscoveryNode node);
 
     boolean nodeConnected(ProtobufDiscoveryNode node);
 
@@ -63,7 +63,7 @@ void connectToNode(
     */
     @FunctionalInterface
     interface ConnectionValidator {
-        void validate(ProtobufTransport.Connection connection, ProtobufConnectionProfile profile, ActionListener<Void> listener);
+        void validate(Transport.ProtobufConnection connection, ProtobufConnectionProfile profile, ActionListener<Void> listener);
     }
 
     /**
@@ -76,28 +76,28 @@ final class DelegatingNodeConnectionListener implements ProtobufTransportConnect
         private final CopyOnWriteArrayList<ProtobufTransportConnectionListener> listeners = new CopyOnWriteArrayList<>();
 
         @Override
-        public void onNodeDisconnected(ProtobufDiscoveryNode key, ProtobufTransport.Connection connection) {
+        public void onNodeDisconnected(ProtobufDiscoveryNode key, Transport.ProtobufConnection connection) {
             for (ProtobufTransportConnectionListener listener : listeners) {
                 listener.onNodeDisconnected(key, connection);
             }
         }
 
         @Override
-        public void onNodeConnected(ProtobufDiscoveryNode node, ProtobufTransport.Connection connection) {
+        public void onNodeConnected(ProtobufDiscoveryNode node, Transport.ProtobufConnection connection) {
             for (ProtobufTransportConnectionListener listener : listeners) {
                 listener.onNodeConnected(node, connection);
             }
         }
 
         @Override
-        public void onConnectionOpened(ProtobufTransport.Connection connection) {
+        public void onConnectionOpened(Transport.ProtobufConnection connection) {
             for (ProtobufTransportConnectionListener listener : listeners) {
                 listener.onConnectionOpened(connection);
             }
         }
 
         @Override
-        public void onConnectionClosed(ProtobufTransport.Connection connection) {
+        public void onConnectionClosed(Transport.ProtobufConnection connection) {
             for (ProtobufTransportConnectionListener listener : listeners) {
                 listener.onConnectionClosed(connection);
             }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java b/server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java
index e18057f7818df..365bed06c42f7 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java
@@ -24,7 +24,7 @@
 import org.opensearch.common.transport.NetworkExceptionHelper;
 import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.threadpool.ThreadPool;
 
 import java.io.IOException;
 import java.util.Set;
@@ -42,7 +42,7 @@ final class ProtobufOutboundHandler {
     private final Version version;
     private final String[] features;
     private final StatsTracker statsTracker;
-    private final ProtobufThreadPool threadPool;
+    private final ThreadPool threadPool;
     // private final BigArrays bigArrays;
     private final byte[] bytes;
     private volatile ProtobufTransportMessageListener messageListener = ProtobufTransportMessageListener.NOOP_LISTENER;
@@ -52,7 +52,7 @@ final class ProtobufOutboundHandler {
         Version version,
         String[] features,
         StatsTracker statsTracker,
-        ProtobufThreadPool threadPool,
+        ThreadPool threadPool,
         byte[] bytes
     ) {
         this.nodeName = nodeName;
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java
index c400597c97d4f..a5317b0fcee62 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java
@@ -17,7 +17,7 @@
 import org.opensearch.client.support.ProtobufAbstractClient;
 import org.opensearch.cluster.node.ProtobufDiscoveryNode;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.threadpool.ThreadPool;
 
 /**
  * ProtobufClient that is aware of remote clusters
@@ -28,11 +28,11 @@ final class ProtobufRemoteClusterAwareClient extends ProtobufAbstractClient {
 
     private final ProtobufTransportService service;
     private final String clusterAlias;
-    private final ProtobufRemoteClusterService remoteClusterService;
+    private final RemoteClusterService remoteClusterService;
 
     ProtobufRemoteClusterAwareClient(
         Settings settings,
-        ProtobufThreadPool threadPool,
+        ThreadPool threadPool,
         ProtobufTransportService service,
         String clusterAlias
     ) {
@@ -49,12 +49,12 @@ protected <Request extends ProtobufActionRequest, Response extends ProtobufActio
         ActionListener<Response> listener
     ) {
         remoteClusterService.ensureConnected(clusterAlias, ActionListener.wrap(v -> {
-            ProtobufTransport.Connection connection;
+            Transport.ProtobufConnection connection;
             if (request instanceof ProtobufRemoteClusterAwareRequest) {
                 ProtobufDiscoveryNode preferredTargetNode = ((ProtobufRemoteClusterAwareRequest) request).getPreferredTargetNode();
-                connection = remoteClusterService.getConnection(preferredTargetNode, clusterAlias);
+                connection = remoteClusterService.getConnectionProtobuf(preferredTargetNode, clusterAlias);
             } else {
-                connection = remoteClusterService.getConnection(clusterAlias);
+                connection = remoteClusterService.getConnectionProtobuf(clusterAlias);
             }
             service.sendRequest(
                 connection,
@@ -73,6 +73,6 @@ public void close() {
 
     @Override
     public ProtobufClient getRemoteClusterClient(String clusterAlias) {
-        return remoteClusterService.getRemoteClusterClient(threadPool(), clusterAlias);
+        return remoteClusterService.getRemoteClusterClientProtobuf(threadPool(), clusterAlias);
     }
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
index 58d90365f0ef5..ef896f62e856e 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
@@ -20,7 +20,7 @@
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.common.util.io.IOUtils;
-import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.threadpool.ThreadPool;
 
 import java.io.Closeable;
 import java.io.IOException;
@@ -47,7 +47,7 @@ final class ProtobufRemoteClusterConnection implements Closeable {
     private final ProtobufRemoteConnectionManager remoteConnectionManager;
     private final ProtobufRemoteConnectionStrategy connectionStrategy;
     private final String clusterAlias;
-    private final ProtobufThreadPool threadPool;
+    private final ThreadPool threadPool;
     private volatile boolean skipUnavailable;
     private final TimeValue initialConnectionTimeout;
 
@@ -127,7 +127,7 @@ void collectNodes(ActionListener<Function<String, ProtobufDiscoveryNode>> listen
                 request.clear();
                 request.nodes(true);
                 request.local(true); // run this on the node that gets the request it's as good as any other
-                ProtobufTransport.Connection connection = remoteConnectionManager.getAnyRemoteConnection();
+                Transport.ProtobufConnection connection = remoteConnectionManager.getAnyRemoteConnection();
                 transportService.sendRequest(
                     connection,
                     ClusterStateAction.NAME,
@@ -153,7 +153,7 @@ public void handleException(ProtobufTransportException exp) {
 
                         @Override
                         public String executor() {
-                            return ProtobufThreadPool.Names.SAME;
+                            return ThreadPool.Names.SAME;
                         }
                     }
                 );
@@ -175,11 +175,11 @@ public String executor() {
      * Returns a connection to the remote cluster, preferably a direct connection to the provided {@link ProtobufDiscoveryNode}.
     * If such node is not connected, the returned connection will be a proxy connection that redirects to it.
     */
-    ProtobufTransport.Connection getConnection(ProtobufDiscoveryNode remoteClusterNode) {
+    Transport.ProtobufConnection getConnection(ProtobufDiscoveryNode remoteClusterNode) {
         return remoteConnectionManager.getConnection(remoteClusterNode);
     }
 
-    ProtobufTransport.Connection getConnection() {
+    Transport.ProtobufConnection getConnection() {
         return remoteConnectionManager.getAnyRemoteConnection();
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java
index 4148beb90c6e1..eef008cbb398e 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java
@@ -26,7 +26,7 @@
 import org.opensearch.common.util.concurrent.ConcurrentCollections;
 import org.opensearch.common.util.concurrent.CountDown;
 import org.opensearch.common.util.io.IOUtils;
-import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.threadpool.ThreadPool;
 
 import java.io.Closeable;
 import java.io.IOException;
@@ -185,7 +185,7 @@ public Set<String> getRegisteredRemoteClusterNames() {
     *
     * @throws IllegalArgumentException if the remote cluster is unknown
     */
-    public ProtobufTransport.Connection getConnection(ProtobufDiscoveryNode node, String cluster) {
+    public Transport.ProtobufConnection getConnection(ProtobufDiscoveryNode node, String cluster) {
         return getRemoteClusterConnection(cluster).getConnection(node);
     }
 
@@ -204,7 +204,7 @@ public boolean isSkipUnavailable(String clusterAlias) {
         return getRemoteClusterConnection(clusterAlias).isSkipUnavailable();
     }
 
-    public ProtobufTransport.Connection getConnection(String cluster) {
+    public Transport.ProtobufConnection getConnection(String cluster) {
         return getRemoteClusterConnection(cluster).getConnection();
     }
 
@@ -392,11 +392,11 @@ public void onFailure(Exception e) {
     /**
      * Returns a client to the remote cluster if the given cluster alias exists.
     *
-    * @param threadPool   the {@link ProtobufThreadPool} for the client
+    * @param threadPool   the {@link ThreadPool} for the client
     * @param clusterAlias the cluster alias the remote cluster is registered under
     * @throws IllegalArgumentException if the given clusterAlias doesn't exist
     */
-    public ProtobufClient getRemoteClusterClient(ProtobufThreadPool threadPool, String clusterAlias) {
+    public ProtobufClient getRemoteClusterClient(ThreadPool threadPool, String clusterAlias) {
         if (transportService.getRemoteClusterService().isEnabled() == false) {
             throw new IllegalArgumentException(
                 "this node does not have the " + DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName() + " role"
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java
index a8608b80768a6..95c0e2a9624bd 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java
@@ -36,12 +36,12 @@ public class ProtobufRemoteConnectionManager implements ProtobufConnectionManage
         this.delegate = delegate;
         this.delegate.addListener(new ProtobufTransportConnectionListener() {
             @Override
-            public void onNodeConnected(ProtobufDiscoveryNode node, ProtobufTransport.Connection connection) {
+            public void onNodeConnected(ProtobufDiscoveryNode node, Transport.ProtobufConnection connection) {
                 addConnectedNode(node);
             }
 
             @Override
-            public void onNodeDisconnected(ProtobufDiscoveryNode node, ProtobufTransport.Connection connection) {
+            public void onNodeDisconnected(ProtobufDiscoveryNode node, Transport.ProtobufConnection connection) {
                 removeConnectedNode(node);
             }
         });
@@ -71,13 +71,13 @@ public void removeListener(ProtobufTransportConnectionListener listener) {
     public void openConnection(
         ProtobufDiscoveryNode node,
         ProtobufConnectionProfile profile,
-        ActionListener<ProtobufTransport.Connection> listener
+        ActionListener<Transport.ProtobufConnection> listener
     ) {
         delegate.openConnection(node, profile, listener);
     }
 
     @Override
-    public ProtobufTransport.Connection getConnection(ProtobufDiscoveryNode node) {
+    public Transport.ProtobufConnection getConnection(ProtobufDiscoveryNode node) {
         try {
             return delegate.getConnection(node);
         } catch (NodeNotConnectedException e) {
@@ -100,7 +100,7 @@ public ProtobufConnectionProfile getConnectionProfile() {
         return delegate.getConnectionProfile();
     }
 
-    public ProtobufTransport.Connection getAnyRemoteConnection() {
+    public Transport.ProtobufConnection getAnyRemoteConnection() {
         List<ProtobufDiscoveryNode> localConnectedNodes = this.connectedNodes;
         long curr;
         while ((curr = counter.incrementAndGet()) == Long.MIN_VALUE)
@@ -164,11 +164,11 @@ private synchronized void removeConnectedNode(ProtobufDiscoveryNode removedNode)
         this.connectedNodes = Collections.unmodifiableList(newConnectedNodes);
     }
 
-    static final class ProxyConnection implements ProtobufTransport.Connection {
-        private final ProtobufTransport.Connection connection;
+    static final class ProxyConnection implements Transport.ProtobufConnection {
+        private final Transport.ProtobufConnection connection;
         private final ProtobufDiscoveryNode targetNode;
 
-        private ProxyConnection(ProtobufTransport.Connection connection, ProtobufDiscoveryNode targetNode) {
+        private ProxyConnection(Transport.ProtobufConnection connection, ProtobufDiscoveryNode targetNode) {
             this.connection = connection;
             this.targetNode = targetNode;
         }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java
index 0ee4507fc98a8..53f3ad80acc4e 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java
@@ -361,7 +361,7 @@ boolean shouldRebuildConnection(Settings newSettings) {
     protected abstract ProtobufConnectionStrategy strategyType();
 
     @Override
-    public void onNodeDisconnected(ProtobufDiscoveryNode node, ProtobufTransport.Connection connection) {
+    public void onNodeDisconnected(ProtobufDiscoveryNode node, Transport.ProtobufConnection connection) {
         if (shouldOpenMoreConnections()) {
             // try to reconnect and fill up the slot of the disconnected node
             connect(
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
index 6e4fdbfc4f053..8a2d15db70e11 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
@@ -15,7 +15,7 @@
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.tasks.ProtobufCancellableTask;
 import org.opensearch.tasks.ProtobufTask;
-import org.opensearch.tasks.ProtobufTaskManager;
+import org.opensearch.tasks.TaskManager;
 
 import java.io.IOException;
 
@@ -31,13 +31,13 @@ public final class ProtobufRequestHandlerRegistry<Request extends ProtobufTransp
     private final boolean forceExecution;
     private final boolean canTripCircuitBreaker;
     private final String executor;
-    private final ProtobufTaskManager taskManager;
+    private final TaskManager taskManager;
     private final ProtobufWriteable.Reader<Request> requestReader;
 
     public ProtobufRequestHandlerRegistry(
         String action,
         ProtobufWriteable.Reader<Request> requestReader,
-        ProtobufTaskManager taskManager,
+        TaskManager taskManager,
         ProtobufTransportRequestHandler<Request> handler,
         String executor,
         boolean forceExecution,
@@ -61,10 +61,10 @@ public Request newRequest(CodedInputStream in) throws IOException {
     }
 
     public void processMessageReceived(Request request, ProtobufTransportChannel channel) throws Exception {
-        final ProtobufTask task = taskManager.register(channel.getChannelType(), action, request);
-        ThreadContext.StoredContext contextToRestore = taskManager.taskExecutionStarted(task);
+        final ProtobufTask task = taskManager.registerProtobuf(channel.getChannelType(), action, request);
+        ThreadContext.StoredContext contextToRestore = taskManager.protobufTaskExecutionStarted(task);
 
-        Releasable unregisterTask = () -> taskManager.unregister(task);
+        Releasable unregisterTask = () -> taskManager.unregisterProtobufTask(task);
         try {
             if (channel instanceof ProtobufTcpTransportChannel && task instanceof ProtobufCancellableTask) {
                 // if (request instanceof ShardSearchRequest) {
@@ -74,7 +74,7 @@ public void processMessageReceived(Request request, ProtobufTransportChannel cha
                 // );
                 // }
                 final TcpChannel tcpChannel = ((ProtobufTcpTransportChannel) channel).getChannel();
-                final Releasable stopTracking = taskManager.startTrackingCancellableChannelTask(tcpChannel, (ProtobufCancellableTask) task);
+                final Releasable stopTracking = taskManager.startProtobufTrackingCancellableChannelTask(tcpChannel, (ProtobufCancellableTask) task);
                 unregisterTask = Releasables.wrap(unregisterTask, stopTracking);
             }
             final ProtobufTaskTransportChannel taskTransportChannel = new ProtobufTaskTransportChannel(channel, unregisterTask);
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java
index 36c851592a6fd..f503ff0951eda 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java
@@ -33,7 +33,7 @@
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.common.util.io.IOUtils;
-import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.threadpool.ThreadPool;
 
 import java.io.IOException;
 import java.net.InetSocketAddress;
@@ -256,7 +256,7 @@ private void collectRemoteNodes(Iterator<Supplier<ProtobufDiscoveryNode>> seedNo
 
             final ProtobufDiscoveryNode seedNode = seedNodes.next().get();
             logger.trace("[{}] opening transient connection to seed node: [{}]", clusterAlias, seedNode);
-            final StepListener<ProtobufTransport.Connection> openConnectionStep = new StepListener<>();
+            final StepListener<Transport.ProtobufConnection> openConnectionStep = new StepListener<>();
             try {
                 connectionManager.openConnection(seedNode, null, openConnectionStep);
             } catch (Exception e) {
@@ -296,7 +296,7 @@ private void collectRemoteNodes(Iterator<Supplier<ProtobufDiscoveryNode>> seedNo
                     fullConnectionStep.onResponse(null);
                 }
             }, e -> {
-                final ProtobufTransport.Connection connection = openConnectionStep.result();
+                final Transport.ProtobufConnection connection = openConnectionStep.result();
                 final ProtobufDiscoveryNode node = connection.getNode();
                 logger.debug(() -> new ParameterizedMessage("[{}] failed to handshake with seed node: [{}]", clusterAlias, node), e);
                 IOUtils.closeWhileHandlingException(connection);
@@ -309,7 +309,7 @@ private void collectRemoteNodes(Iterator<Supplier<ProtobufDiscoveryNode>> seedNo
                     assert handshakeResponse.getClusterName().value() != null;
                     remoteClusterName.set(handshakeResponse.getClusterName());
                 }
-                final ProtobufTransport.Connection connection = openConnectionStep.result();
+                final Transport.ProtobufConnection connection = openConnectionStep.result();
 
                 ProtobufClusterStateRequest request = new ProtobufClusterStateRequest();
                 request.clear();
@@ -317,7 +317,7 @@ private void collectRemoteNodes(Iterator<Supplier<ProtobufDiscoveryNode>> seedNo
                 // here we pass on the connection since we can only close it once the sendRequest returns otherwise
                 // due to the async nature (it will return before it's actually sent) this can cause the request to fail
                 // due to an already closed connection.
-                ProtobufThreadPool threadPool = transportService.getThreadPool();
+                ThreadPool threadPool = transportService.getThreadPool();
                 ThreadContext threadContext = threadPool.getThreadContext();
                 ProtobufTransportService.ContextRestoreResponseHandler<ProtobufClusterStateResponse> responseHandler =
                     new ProtobufTransportService.ContextRestoreResponseHandler<>(
@@ -337,7 +337,7 @@ private void collectRemoteNodes(Iterator<Supplier<ProtobufDiscoveryNode>> seedNo
                     );
                 }
             }, e -> {
-                final ProtobufTransport.Connection connection = openConnectionStep.result();
+                final Transport.ProtobufConnection connection = openConnectionStep.result();
                 final ProtobufDiscoveryNode node = connection.getNode();
                 logger.debug(
                     () -> new ParameterizedMessage("[{}] failed to open managed connection to seed node: [{}]", clusterAlias, node),
@@ -354,12 +354,12 @@ private void collectRemoteNodes(Iterator<Supplier<ProtobufDiscoveryNode>> seedNo
     /* This class handles the _state response from the remote cluster when sniffing nodes to connect to */
     private class SniffClusterStateResponseHandler implements ProtobufTransportResponseHandler<ProtobufClusterStateResponse> {
 
-        private final ProtobufTransport.Connection connection;
+        private final Transport.ProtobufConnection connection;
         private final ActionListener<Void> listener;
         private final Iterator<Supplier<ProtobufDiscoveryNode>> seedNodes;
 
         SniffClusterStateResponseHandler(
-            ProtobufTransport.Connection connection,
+            Transport.ProtobufConnection connection,
             ActionListener<Void> listener,
             Iterator<Supplier<ProtobufDiscoveryNode>> seedNodes
         ) {
@@ -447,7 +447,7 @@ public void handleException(ProtobufTransportException exp) {
 
         @Override
         public String executor() {
-            return ProtobufThreadPool.Names.MANAGEMENT;
+            return ThreadPool.Names.MANAGEMENT;
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransport.java b/server/src/main/java/org/opensearch/transport/ProtobufTransport.java
index 9a9890255fa67..234583dd011a8 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransport.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransport.java
@@ -82,7 +82,7 @@ void openConnection(
         ActionListener<ProtobufTransport.Connection> listener
     );
 
-    TransportStats getStats();
+    ProtobufTransportStats getStats();
 
     ResponseHandlers getResponseHandlers();
 
@@ -241,7 +241,7 @@ public ProtobufTransportResponseHandler<? extends ProtobufTransportResponse> onR
             final ProtobufTransportMessageListener listener
         ) {
             ResponseContext<? extends ProtobufTransportResponse> context = handlers.remove(requestId);
-            listener.onResponseReceived(requestId, context);
+            // listener.onResponseReceived(requestId, context);
             if (context == null) {
                 return null;
             } else {
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java
index 5c0fdea673c9d..15b51edeabd0f 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java
@@ -13,7 +13,7 @@
 import org.opensearch.cluster.node.ProtobufDiscoveryNode;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.tasks.ProtobufTask;
-import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.threadpool.ThreadPool;
 
 import java.io.IOException;
 import java.io.UncheckedIOException;
@@ -104,7 +104,7 @@ public void handleException(ProtobufTransportException exp) {
 
         @Override
         public String executor() {
-            return ProtobufThreadPool.Names.SAME;
+            return ThreadPool.Names.SAME;
         }
     }
 
@@ -148,7 +148,7 @@ public static void registerProxyActionWithDynamicResponseType(
         ProtobufRequestHandlerRegistry<? extends ProtobufTransportRequest> requestHandler = service.getRequestHandler(action);
         service.registerRequestHandler(
             getProxyAction(action),
-            ProtobufThreadPool.Names.SAME,
+            ThreadPool.Names.SAME,
             true,
             false,
             in -> new ProxyRequest<>(in, requestHandler::newRequest),
@@ -168,7 +168,7 @@ public static void registerProxyAction(
         ProtobufRequestHandlerRegistry<? extends ProtobufTransportRequest> requestHandler = service.getRequestHandler(action);
         service.registerRequestHandler(
             getProxyAction(action),
-            ProtobufThreadPool.Names.SAME,
+            ThreadPool.Names.SAME,
             true,
             false,
             in -> new ProxyRequest<>(in, requestHandler::newRequest),
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java
index 2f348b72e1a5a..30c66104145e8 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java
@@ -23,21 +23,21 @@ public interface ProtobufTransportConnectionListener {
      * Called once a connection was opened
     * @param connection the connection
     */
-    default void onConnectionOpened(ProtobufTransport.Connection connection) {}
+    default void onConnectionOpened(Transport.ProtobufConnection connection) {}
 
     /**
      * Called once a connection ws closed.
     * @param connection the closed connection
     */
-    default void onConnectionClosed(ProtobufTransport.Connection connection) {}
+    default void onConnectionClosed(Transport.ProtobufConnection connection) {}
 
     /**
      * Called once a node connection is opened and registered.
     */
-    default void onNodeConnected(ProtobufDiscoveryNode node, ProtobufTransport.Connection connection) {}
+    default void onNodeConnected(ProtobufDiscoveryNode node, Transport.ProtobufConnection connection) {}
 
     /**
      * Called once a node connection is closed and unregistered.
     */
-    default void onNodeDisconnected(ProtobufDiscoveryNode node, ProtobufTransport.Connection connection) {}
+    default void onNodeDisconnected(ProtobufDiscoveryNode node, Transport.ProtobufConnection connection) {}
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java
index 2476882515de1..bf109d0518693 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java
@@ -45,11 +45,11 @@ default AsyncSender interceptSender(AsyncSender sender) {
 
     /**
      * A simple interface to decorate
-    * {@link #sendRequest(ProtobufTransport.Connection, String, ProtobufTransportRequest, TransportRequestOptions, ProtobufTransportResponseHandler)}
+    * {@link #sendRequest(Transport.ProtobufConnection, String, ProtobufTransportRequest, TransportRequestOptions, ProtobufTransportResponseHandler)}
     */
     interface AsyncSender {
         <T extends ProtobufTransportResponse> void sendRequest(
-            ProtobufTransport.Connection connection,
+            Transport.ProtobufConnection connection,
             String action,
             ProtobufTransportRequest request,
             TransportRequestOptions options,
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java
index 0d54c80512c03..5c58c2064801f 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java
@@ -65,5 +65,5 @@ default void onRequestSent(
     * @param requestId the request id for this reponse
     * @param context the response context or null if the context was already processed ie. due to a timeout.
     */
-    default void onResponseReceived(long requestId, ProtobufTransport.ResponseContext context) {}
+    default void onResponseReceived(long requestId, Transport.ProtobufResponseContext context) {}
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java
index 9f5107009d977..4b1e934977c7e 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java
@@ -15,6 +15,7 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.Version;
 import org.opensearch.action.ActionListener;
+import org.opensearch.action.ActionListenerResponseHandler;
 import org.opensearch.action.ProtobufActionListenerResponseHandler;
 import org.opensearch.action.support.PlainActionFuture;
 import org.opensearch.cluster.ProtobufClusterName;
@@ -40,9 +41,9 @@
 import org.opensearch.node.ProtobufNodeClosedException;
 import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.tasks.ProtobufTask;
-import org.opensearch.tasks.ProtobufTaskManager;
+import org.opensearch.tasks.TaskManager;
 import org.opensearch.threadpool.Scheduler;
-import org.opensearch.threadpool.ProtobufThreadPool;
+import org.opensearch.threadpool.ThreadPool;
 
 import java.io.IOException;
 import java.io.UncheckedIOException;
@@ -79,15 +80,15 @@ public class ProtobufTransportService extends AbstractLifecycleComponent
 
     private final AtomicBoolean handleIncomingRequests = new AtomicBoolean();
     private final DelegatingTransportMessageListener messageListener = new DelegatingTransportMessageListener();
-    protected final ProtobufTransport transport;
+    protected final Transport transport;
     protected final ProtobufConnectionManager connectionManager;
-    protected final ProtobufThreadPool threadPool;
+    protected final ThreadPool threadPool;
     protected final ProtobufClusterName clusterName;
-    protected final ProtobufTaskManager taskManager;
+    protected final TaskManager taskManager;
     private final ProtobufTransportInterceptor.AsyncSender asyncSender;
     private final Function<ProtobufBoundTransportAddress, ProtobufDiscoveryNode> localNodeFactory;
     private final boolean remoteClusterClient;
-    private final ProtobufTransport.ResponseHandlers responseHandlers;
+    private final Transport.ProtobufResponseHandlers responseHandlers;
     private final ProtobufTransportInterceptor interceptor;
 
     // An LRU (don't really care about concurrency here) that holds the latest timed out requests so if they
@@ -111,11 +112,11 @@ protected boolean removeEldestEntry(Map.Entry eldest) {
     volatile String[] tracerLogInclude;
     volatile String[] tracerLogExclude;
 
-    private final ProtobufRemoteClusterService remoteClusterService;
+    private final RemoteClusterService remoteClusterService;
 
     /** if set will call requests sent to this id to shortcut and executed locally */
     volatile ProtobufDiscoveryNode localNode = null;
-    private final ProtobufTransport.Connection localNodeConnection = new ProtobufTransport.Connection() {
+    private final Transport.ProtobufConnection localNodeConnection = new Transport.ProtobufConnection() {
         @Override
         public ProtobufDiscoveryNode getNode() {
             return localNode;
@@ -147,8 +148,8 @@ public void close() {}
     */
     public ProtobufTransportService(
         Settings settings,
-        ProtobufTransport transport,
-        ProtobufThreadPool threadPool,
+        Transport transport,
+        ThreadPool threadPool,
         ProtobufTransportInterceptor transportInterceptor,
         Function<ProtobufBoundTransportAddress, ProtobufDiscoveryNode> localNodeFactory,
         @Nullable ClusterSettings clusterSettings,
@@ -168,8 +169,8 @@ public ProtobufTransportService(
 
     public ProtobufTransportService(
         Settings settings,
-        ProtobufTransport transport,
-        ProtobufThreadPool threadPool,
+        Transport transport,
+        ThreadPool threadPool,
         ProtobufTransportInterceptor transportInterceptor,
         Function<ProtobufBoundTransportAddress, ProtobufDiscoveryNode> localNodeFactory,
         @Nullable ClusterSettings clusterSettings,
@@ -189,8 +190,8 @@ public ProtobufTransportService(
         this.interceptor = transportInterceptor;
         this.asyncSender = interceptor.interceptSender(this::sendRequestInternal);
         this.remoteClusterClient = ProtobufDiscoveryNode.isRemoteClusterClient(settings);
-        remoteClusterService = new ProtobufRemoteClusterService(settings, this);
-        responseHandlers = transport.getResponseHandlers();
+        remoteClusterService = new RemoteClusterService(settings, this);
+        responseHandlers = transport.getProtobufResponseHandlers();
         if (clusterSettings != null) {
             clusterSettings.addSettingsUpdateConsumer(TransportSettings.TRACE_LOG_INCLUDE_SETTING, this::setTracerLogInclude);
             clusterSettings.addSettingsUpdateConsumer(TransportSettings.TRACE_LOG_EXCLUDE_SETTING, this::setTracerLogExclude);
@@ -201,7 +202,7 @@ public ProtobufTransportService(
         }
         registerRequestHandler(
             HANDSHAKE_ACTION_NAME,
-            ProtobufThreadPool.Names.SAME,
+            ThreadPool.Names.SAME,
             false,
             false,
             HandshakeRequest::new,
@@ -209,7 +210,7 @@ public ProtobufTransportService(
         );
     }
 
-    public ProtobufRemoteClusterService getRemoteClusterService() {
+    public RemoteClusterService getRemoteClusterService() {
         return remoteClusterService;
     }
 
@@ -217,20 +218,20 @@ public ProtobufDiscoveryNode getLocalNode() {
         return localNode;
     }
 
-    public ProtobufTaskManager getTaskManager() {
+    public TaskManager getTaskManager() {
         return taskManager;
     }
 
-    protected ProtobufTaskManager createTaskManager(
+    protected TaskManager createTaskManager(
         Settings settings,
         ClusterSettings clusterSettings,
-        ProtobufThreadPool threadPool,
+        ThreadPool threadPool,
         Set<String> taskHeaders
     ) {
         if (clusterSettings != null) {
-            return ProtobufTaskManager.createTaskManagerWithClusterSettings(settings, clusterSettings, threadPool, taskHeaders);
+            return TaskManager.createTaskManagerWithClusterSettings(settings, clusterSettings, threadPool, taskHeaders);
         } else {
-            return new ProtobufTaskManager(settings, threadPool, taskHeaders);
+            return new TaskManager(settings, threadPool, taskHeaders);
         }
     }
 
@@ -258,11 +259,11 @@ protected void doStart() {
         transport.start();
         if (transport.boundAddress() != null && logger.isInfoEnabled()) {
             logger.info("{}", transport.boundAddress());
-            for (Map.Entry<String, ProtobufBoundTransportAddress> entry : transport.profileBoundAddresses().entrySet()) {
+            for (Map.Entry<String, ProtobufBoundTransportAddress> entry : transport.profileProtobufBoundAddresses().entrySet()) {
                 logger.info("profile [{}]: {}", entry.getKey(), entry.getValue());
             }
         }
-        localNode = localNodeFactory.apply(transport.boundAddress());
+        localNode = localNodeFactory.apply(transport.boundProtobufAddress());
 
         if (remoteClusterClient) {
             // here we start to connect to the remote clusters
@@ -279,7 +280,7 @@ protected void doStop() {
         } finally {
             // in case the transport is not connected to our local node (thus cleaned on node disconnect)
             // make sure to clean any leftover on going handles
-            for (final ProtobufTransport.ResponseContext holderToNotify : responseHandlers.prune(h -> true)) {
+            for (final Transport.ProtobufResponseContext holderToNotify : responseHandlers.prune(h -> true)) {
                 // callback that an exception happened, but on a different thread since we don't
                 // want handlers to worry about stack overflows
                 getExecutorService().execute(new AbstractRunnable() {
@@ -335,16 +336,16 @@ public final void acceptIncomingRequests() {
     }
 
     @Override
-    public ProtobufTransportInfo info() {
+    public ProtobufTransportInfo protobufInfo() {
         ProtobufBoundTransportAddress boundTransportAddress = boundAddress();
         if (boundTransportAddress == null) {
             return null;
         }
-        return new ProtobufTransportInfo(boundTransportAddress, transport.profileBoundAddresses());
+        return new ProtobufTransportInfo(boundTransportAddress, transport.profileProtobufBoundAddresses());
     }
 
-    public TransportStats stats() {
-        return transport.getStats();
+    public ProtobufTransportStats stats() {
+        return transport.getProtobufStats();
     }
 
     public boolean isTransportSecure() {
@@ -352,7 +353,7 @@ public boolean isTransportSecure() {
     }
 
     public ProtobufBoundTransportAddress boundAddress() {
-        return transport.boundAddress();
+        return transport.boundProtobufAddress();
     }
 
     public List<String> getDefaultSeedAddresses() {
@@ -474,7 +475,7 @@ public ProtobufConnectionManager.ConnectionValidator extensionConnectionValidato
     * @param node the node to connect to
     * @param connectionProfile the connection profile to use
     */
-    public ProtobufTransport.Connection openConnection(final ProtobufDiscoveryNode node, ProtobufConnectionProfile connectionProfile) {
+    public Transport.ProtobufConnection openConnection(final ProtobufDiscoveryNode node, ProtobufConnectionProfile connectionProfile) {
         return PlainActionFuture.get(fut -> openConnection(node, connectionProfile, fut));
     }
 
@@ -489,7 +490,7 @@ public ProtobufTransport.Connection openConnection(final ProtobufDiscoveryNode n
     public void openConnection(
         final ProtobufDiscoveryNode node,
         ProtobufConnectionProfile connectionProfile,
-        ActionListener<ProtobufTransport.Connection> listener
+        ActionListener<Transport.ProtobufConnection> listener
     ) {
         if (isLocalNode(node)) {
             listener.onResponse(localNodeConnection);
@@ -512,7 +513,7 @@ public void openConnection(
     * @throws IllegalStateException if the handshake failed
     */
     public void handshake(
-        final ProtobufTransport.Connection connection,
+        final Transport.ProtobufConnection connection,
         final long handshakeTimeout,
         final ActionListener<ProtobufDiscoveryNode> listener
     ) {
@@ -538,7 +539,7 @@ public void handshake(
     * @throws IllegalStateException if the handshake failed
     */
     public void handshake(
-        final ProtobufTransport.Connection connection,
+        final Transport.ProtobufConnection connection,
         final long handshakeTimeout,
         Predicate<ProtobufClusterName> clusterNamePredicate,
         final ActionListener<HandshakeResponse> listener
@@ -584,7 +585,7 @@ public void onResponse(HandshakeResponse response) {
                 public void onFailure(Exception e) {
                     listener.onFailure(e);
                 }
-            }, HandshakeResponse::new, ProtobufThreadPool.Names.GENERIC)
+            }, HandshakeResponse::new, ThreadPool.Names.GENERIC)
         );
     }
 
@@ -691,7 +692,7 @@ public <T extends ProtobufTransportResponse> TransportFuture<T> submitRequest(
     ) throws ProtobufTransportException {
         ProtobufPlainTransportFuture<T> futureHandler = new ProtobufPlainTransportFuture<>(handler);
         try {
-            ProtobufTransport.Connection connection = getConnection(node);
+            Transport.ProtobufConnection connection = getConnection(node);
             sendRequest(connection, action, request, options, futureHandler);
         } catch (ProtobufNodeNotConnectedException ex) {
             // the caller might not handle this so we invoke the handler
@@ -706,7 +707,7 @@ public <T extends ProtobufTransportResponse> void sendRequest(
         final ProtobufTransportRequest request,
         final ProtobufTransportResponseHandler<T> handler
     ) {
-        final ProtobufTransport.Connection connection;
+        final Transport.ProtobufConnection connection;
         try {
             connection = getConnection(node);
         } catch (final ProtobufNodeNotConnectedException ex) {
@@ -724,7 +725,7 @@ public final <T extends ProtobufTransportResponse> void sendRequest(
         final TransportRequestOptions options,
         ProtobufTransportResponseHandler<T> handler
     ) {
-        final ProtobufTransport.Connection connection;
+        final Transport.ProtobufConnection connection;
         try {
             connection = getConnection(node);
         } catch (final ProtobufNodeNotConnectedException ex) {
@@ -746,7 +747,7 @@ public final <T extends ProtobufTransportResponse> void sendRequest(
     * @param <T>        the type of the transport response
     */
     public final <T extends ProtobufTransportResponse> void sendRequest(
-        final ProtobufTransport.Connection connection,
+        final Transport.ProtobufConnection connection,
         final String action,
         final ProtobufTransportRequest request,
         final TransportRequestOptions options,
@@ -757,7 +758,7 @@ public final <T extends ProtobufTransportResponse> void sendRequest(
             final ProtobufTransportResponseHandler<T> delegate;
             if (request.getParentTask().isSet()) {
                 // TODO: capture the connection instead so that we can cancel child tasks on the remote connections.
-                final Releasable unregisterChildNode = taskManager.registerChildNode(request.getParentTask().getId(), connection.getNode());
+                final Releasable unregisterChildNode = taskManager.registerProtobufChildNode(request.getParentTask().getId(), connection.getNode());
                 delegate = new ProtobufTransportResponseHandler<T>() {
                     @Override
                     public void handleResponse(T response) {
@@ -806,7 +807,7 @@ public String toString() {
      * Returns either a real transport connection or a local node connection if we are using the local node optimization.
     * @throws ProtobufNodeNotConnectedException if the given node is not connected
     */
-    public ProtobufTransport.Connection getConnection(ProtobufDiscoveryNode node) {
+    public Transport.ProtobufConnection getConnection(ProtobufDiscoveryNode node) {
         if (isLocalNode(node)) {
             return localNodeConnection;
         } else {
@@ -822,7 +823,7 @@ public final <T extends ProtobufTransportResponse> void sendChildRequest(
         final TransportRequestOptions options,
         final ProtobufTransportResponseHandler<T> handler
     ) {
-        final ProtobufTransport.Connection connection;
+        final Transport.ProtobufConnection connection;
         try {
             connection = getConnection(node);
         } catch (final ProtobufNodeNotConnectedException ex) {
@@ -834,7 +835,7 @@ public final <T extends ProtobufTransportResponse> void sendChildRequest(
     }
 
     public <T extends ProtobufTransportResponse> void sendChildRequest(
-        final ProtobufTransport.Connection connection,
+        final Transport.ProtobufConnection connection,
         final String action,
         final ProtobufTransportRequest request,
         final ProtobufTask parentTask,
@@ -844,7 +845,7 @@ public <T extends ProtobufTransportResponse> void sendChildRequest(
     }
 
     public <T extends ProtobufTransportResponse> void sendChildRequest(
-        final ProtobufTransport.Connection connection,
+        final Transport.ProtobufConnection connection,
         final String action,
         final ProtobufTransportRequest request,
         final ProtobufTask parentTask,
@@ -856,7 +857,7 @@ public <T extends ProtobufTransportResponse> void sendChildRequest(
     }
 
     private <T extends ProtobufTransportResponse> void sendRequestInternal(
-        final ProtobufTransport.Connection connection,
+        final Transport.ProtobufConnection connection,
         final String action,
         final ProtobufTransportRequest request,
         final TransportRequestOptions options,
@@ -870,7 +871,7 @@ private <T extends ProtobufTransportResponse> void sendRequestInternal(
         Supplier<ThreadContext.StoredContext> storedContextSupplier = threadPool.getThreadContext().newRestorableContext(true);
         ContextRestoreResponseHandler<T> responseHandler = new ContextRestoreResponseHandler<>(storedContextSupplier, handler);
         // TODO we can probably fold this entire request ID dance into connection.sendReqeust but it will be a bigger refactoring
-        final long requestId = responseHandlers.add(new ProtobufTransport.ResponseContext<>(responseHandler, connection, action));
+        final long requestId = responseHandlers.add(new Transport.ProtobufResponseContext<>(responseHandler, connection, action));
         final TimeoutHandler timeoutHandler;
         if (options.timeout() != null) {
             timeoutHandler = new TimeoutHandler(requestId, connection.getNode(), action);
@@ -894,7 +895,7 @@ private <T extends ProtobufTransportResponse> void sendRequestInternal(
         } catch (final Exception e) {
             // usually happen either because we failed to connect to the node
             // or because we failed serializing the message
-            final ProtobufTransport.ResponseContext<? extends ProtobufTransportResponse> contextToNotify = responseHandlers.remove(
+            final Transport.ProtobufResponseContext<? extends ProtobufTransportResponse> contextToNotify = responseHandlers.remove(
                 requestId
             );
             // If holderToNotify == null then handler has already been taken care of.
@@ -910,7 +911,7 @@ private <T extends ProtobufTransportResponse> void sendRequestInternal(
                     action,
                     e
                 );
-                final String executor = lifecycle.stoppedOrClosed() ? ProtobufThreadPool.Names.SAME : ProtobufThreadPool.Names.GENERIC;
+                final String executor = lifecycle.stoppedOrClosed() ? ThreadPool.Names.SAME : ThreadPool.Names.GENERIC;
                 threadPool.executor(executor).execute(new AbstractRunnable() {
                     @Override
                     public void onRejection(Exception e) {
@@ -961,7 +962,7 @@ private void sendLocalRequest(
                 throw new ActionNotFoundTransportException("Action [" + action + "] not found");
             }
             final String executor = reg.getExecutor();
-            if (ProtobufThreadPool.Names.SAME.equals(executor)) {
+            if (ThreadPool.Names.SAME.equals(executor)) {
                 // noinspection unchecked
                 reg.processMessageReceived(request, channel);
             } else {
@@ -1024,7 +1025,7 @@ public static boolean shouldTraceAction(String action, String[] include, String[
     }
 
     public ProtobufTransportAddress[] addressesFromString(String address) throws UnknownHostException {
-        return transport.addressesFromString(address);
+        return transport.addressesFromStringProtobuf(address);
     }
 
     /**
@@ -1095,7 +1096,7 @@ public <Request extends ProtobufTransportRequest> void registerRequestHandler(
             false,
             true
         );
-        transport.registerRequestHandler(reg);
+        transport.registerProtobufRequestHandler(reg);
     }
 
     /**
@@ -1127,11 +1128,11 @@ public <Request extends ProtobufTransportRequest> void registerRequestHandler(
             forceExecution,
             canTripCircuitBreaker
         );
-        transport.registerRequestHandler(reg);
+        transport.registerProtobufRequestHandler(reg);
     }
 
     /**
-     * called by the {@link ProtobufTransport} implementation when an incoming request arrives but before
+     * called by the {@link Transport} implementation when an incoming request arrives but before
     * any parsing of it has happened (with the exception of the requestId and action)
     */
     @Override
@@ -1145,7 +1146,7 @@ public void onRequestReceived(long requestId, String action) {
         messageListener.onRequestReceived(requestId, action);
     }
 
-    /** called by the {@link ProtobufTransport} implementation once a request has been sent */
+    /** called by the {@link Transport} implementation once a request has been sent */
     @Override
     public void onRequestSent(
         ProtobufDiscoveryNode node,
@@ -1161,7 +1162,7 @@ public void onRequestSent(
     }
 
     @Override
-    public void onResponseReceived(long requestId, ProtobufTransport.ResponseContext holder) {
+    public void onResponseReceived(long requestId, Transport.ProtobufResponseContext holder) {
         if (holder == null) {
             checkForTimeout(requestId);
         } else if (tracerLog.isTraceEnabled() && shouldTraceAction(holder.action())) {
@@ -1170,7 +1171,7 @@ public void onResponseReceived(long requestId, ProtobufTransport.ResponseContext
         messageListener.onResponseReceived(requestId, holder);
     }
 
-    /** called by the {@link ProtobufTransport} implementation once a response was sent to calling node */
+    /** called by the {@link Transport} implementation once a response was sent to calling node */
     @Override
     public void onResponseSent(long requestId, String action, ProtobufTransportResponse response) {
         if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
@@ -1179,7 +1180,7 @@ public void onResponseSent(long requestId, String action, ProtobufTransportRespo
         messageListener.onResponseSent(requestId, action, response);
     }
 
-    /** called by the {@link ProtobufTransport} implementation after an exception was sent as a response to an incoming request */
+    /** called by the {@link Transport} implementation after an exception was sent as a response to an incoming request */
     @Override
     public void onResponseSent(long requestId, String action, Exception e) {
         if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
@@ -1189,7 +1190,7 @@ public void onResponseSent(long requestId, String action, Exception e) {
     }
 
     public ProtobufRequestHandlerRegistry<? extends ProtobufTransportRequest> getRequestHandler(String action) {
-        return transport.getRequestHandlers().getHandler(action);
+        return transport.getProtobufRequestHandlers().getHandler(action);
     }
 
     private void checkForTimeout(long requestId) {
@@ -1229,9 +1230,9 @@ private void checkForTimeout(long requestId) {
     }
 
     @Override
-    public void onConnectionClosed(ProtobufTransport.Connection connection) {
+    public void onConnectionClosed(Transport.ProtobufConnection connection) {
         try {
-            List<ProtobufTransport.ResponseContext<? extends ProtobufTransportResponse>> pruned = responseHandlers.prune(
+            List<Transport.ProtobufResponseContext<? extends ProtobufTransportResponse>> pruned = responseHandlers.prune(
                 h -> h.connection().getCacheKey().equals(connection.getCacheKey())
             );
             // callback that an exception happened, but on a different thread since we don't
@@ -1239,7 +1240,7 @@ public void onConnectionClosed(ProtobufTransport.Connection connection) {
             getExecutorService().execute(new Runnable() {
                 @Override
                 public void run() {
-                    for (ProtobufTransport.ResponseContext holderToNotify : pruned) {
+                    for (Transport.ProtobufResponseContext holderToNotify : pruned) {
                         holderToNotify.handler()
                             .handleException(new ProtobufNodeDisconnectedException(connection.getNode(), holderToNotify.action()));
                     }
@@ -1275,7 +1276,7 @@ public void run() {
                 long timeoutTime = threadPool.relativeTimeInMillis();
                 timeoutInfoHandlers.put(requestId, new TimeoutInfoHolder(node, action, sentTime, timeoutTime));
                 // now that we have the information visible via timeoutInfoHandlers, we try to remove the request id
-                final ProtobufTransport.ResponseContext<? extends ProtobufTransportResponse> holder = responseHandlers.remove(requestId);
+                final Transport.ProtobufResponseContext<? extends ProtobufTransportResponse> holder = responseHandlers.remove(requestId);
                 if (holder != null) {
                     assert holder.action().equals(action);
                     assert holder.connection().getNode().equals(node);
@@ -1313,7 +1314,7 @@ public String toString() {
         }
 
         private void scheduleTimeout(TimeValue timeout) {
-            this.cancellable = threadPool.schedule(this, timeout, ProtobufThreadPool.Names.GENERIC);
+            this.cancellable = threadPool.schedule(this, timeout, ThreadPool.Names.GENERIC);
         }
     }
 
@@ -1424,14 +1425,14 @@ static class DirectResponseChannel implements ProtobufTransportChannel {
         private final String action;
         private final long requestId;
         final ProtobufTransportService service;
-        final ProtobufThreadPool threadPool;
+        final ThreadPool threadPool;
 
         DirectResponseChannel(
             ProtobufDiscoveryNode localNode,
             String action,
             long requestId,
             ProtobufTransportService service,
-            ProtobufThreadPool threadPool
+            ThreadPool threadPool
         ) {
             this.localNode = localNode;
             this.action = action;
@@ -1452,7 +1453,7 @@ public void sendResponse(ProtobufTransportResponse response) throws IOException
             // ignore if its null, the service logs it
             if (handler != null) {
                 final String executor = handler.executor();
-                if (ProtobufThreadPool.Names.SAME.equals(executor)) {
+                if (ThreadPool.Names.SAME.equals(executor)) {
                     processResponse(handler, response);
                 } else {
                     threadPool.executor(executor).execute(new Runnable() {
@@ -1487,7 +1488,7 @@ public void sendResponse(Exception exception) throws IOException {
             if (handler != null) {
                 final ProtobufRemoteTransportException rtx = wrapInRemote(exception);
                 final String executor = handler.executor();
-                if (ProtobufThreadPool.Names.SAME.equals(executor)) {
+                if (ThreadPool.Names.SAME.equals(executor)) {
                     processException(handler, rtx);
                 } else {
                     threadPool.executor(handler.executor()).execute(new Runnable() {
@@ -1537,7 +1538,7 @@ public Version getVersion() {
     /**
      * Returns the internal thread pool
     */
-    public ProtobufThreadPool getThreadPool() {
+    public ThreadPool getThreadPool() {
         return threadPool;
     }
 
@@ -1584,7 +1585,7 @@ public void onRequestSent(
         }
 
         @Override
-        public void onResponseReceived(long requestId, ProtobufTransport.ResponseContext holder) {
+        public void onResponseReceived(long requestId, Transport.ProtobufResponseContext holder) {
             for (ProtobufTransportMessageListener listener : listeners) {
                 listener.onResponseReceived(requestId, holder);
             }
diff --git a/server/src/main/java/org/opensearch/transport/RemoteClusterService.java b/server/src/main/java/org/opensearch/transport/RemoteClusterService.java
index 60e166a4e300c..ae4a98b04fdef 100644
--- a/server/src/main/java/org/opensearch/transport/RemoteClusterService.java
+++ b/server/src/main/java/org/opensearch/transport/RemoteClusterService.java
@@ -39,8 +39,10 @@
 import org.opensearch.action.support.GroupedActionListener;
 import org.opensearch.action.support.IndicesOptions;
 import org.opensearch.client.Client;
+import org.opensearch.client.ProtobufClient;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
 import org.opensearch.common.Strings;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
@@ -150,10 +152,21 @@ public boolean isEnabled() {
     private final TransportService transportService;
     private final Map<String, RemoteClusterConnection> remoteClusters = ConcurrentCollections.newConcurrentMap();
 
+    private final ProtobufTransportService protobufTransportService;
+    private final Map<String, ProtobufRemoteClusterConnection> remoteClustersProtobuf = ConcurrentCollections.newConcurrentMap();
+
     RemoteClusterService(Settings settings, TransportService transportService) {
         super(settings);
         this.enabled = DiscoveryNode.isRemoteClusterClient(settings);
         this.transportService = transportService;
+        this.protobufTransportService = null;
+    }
+
+    RemoteClusterService(Settings settings, ProtobufTransportService transportService) {
+        super(settings);
+        this.enabled = ProtobufDiscoveryNode.isRemoteClusterClient(settings);
+        this.protobufTransportService = transportService;
+        this.transportService = null;
     }
 
     /**
@@ -163,13 +176,20 @@ public boolean isCrossClusterSearchEnabled() {
         return remoteClusters.isEmpty() == false;
     }
 
+    /**
+     * Returns <code>true</code> if at least one remote cluster is configured
+     */
+    public boolean isCrossClusterSearchEnabledProtobuf() {
+        return remoteClustersProtobuf.isEmpty() == false;
+    }
+
     boolean isRemoteNodeConnected(final String remoteCluster, final DiscoveryNode node) {
         return remoteClusters.get(remoteCluster).isNodeConnected(node);
     }
 
     public Map<String, OriginalIndices> groupIndices(IndicesOptions indicesOptions, String[] indices, Predicate<String> indexExists) {
         Map<String, OriginalIndices> originalIndicesMap = new HashMap<>();
-        if (isCrossClusterSearchEnabled()) {
+        if (isCrossClusterSearchEnabled() || isCrossClusterSearchEnabledProtobuf()) {
             final Map<String, List<String>> groupedIndices = groupClusterIndices(getRemoteClusterNames(), indices, indexExists);
             if (groupedIndices.isEmpty()) {
                 // search on _all in the local cluster if neither local indices nor remote indices were specified
@@ -211,6 +231,15 @@ public Transport.Connection getConnection(DiscoveryNode node, String cluster) {
         return getRemoteClusterConnection(cluster).getConnection(node);
     }
 
+    /**
+     * Returns a connection to the given node on the given remote cluster
+     *
+     * @throws IllegalArgumentException if the remote cluster is unknown
+     */
+    public Transport.ProtobufConnection getConnectionProtobuf(ProtobufDiscoveryNode node, String cluster) {
+        return getRemoteClusterConnectionProtobuf(cluster).getConnection(node);
+    }
+
     /**
      * Ensures that the given cluster alias is connected. If the cluster is connected this operation
      * will invoke the listener immediately.
@@ -230,6 +259,10 @@ public Transport.Connection getConnection(String cluster) {
         return getRemoteClusterConnection(cluster).getConnection();
     }
 
+    public Transport.ProtobufConnection getConnectionProtobuf(String cluster) {
+        return getRemoteClusterConnectionProtobuf(cluster).getConnection();
+    }
+
     RemoteClusterConnection getRemoteClusterConnection(String cluster) {
         if (enabled == false) {
             throw new IllegalArgumentException(
@@ -243,6 +276,19 @@ RemoteClusterConnection getRemoteClusterConnection(String cluster) {
         return connection;
     }
 
+    ProtobufRemoteClusterConnection getRemoteClusterConnectionProtobuf(String cluster) {
+        if (enabled == false) {
+            throw new IllegalArgumentException(
+                "this node does not have the " + DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName() + " role"
+            );
+        }
+        ProtobufRemoteClusterConnection connection = remoteClustersProtobuf.get(cluster);
+        if (connection == null) {
+            throw new NoSuchRemoteClusterException(cluster);
+        }
+        return connection;
+    }
+
     Set<String> getRemoteClusterNames() {
         return this.remoteClusters.keySet();
     }
@@ -418,6 +464,25 @@ public Client getRemoteClusterClient(ThreadPool threadPool, String clusterAlias)
         return new RemoteClusterAwareClient(settings, threadPool, transportService, clusterAlias);
     }
 
+    /**
+     * Returns a client to the remote cluster if the given cluster alias exists.
+    *
+    * @param threadPool   the {@link ThreadPool} for the client
+    * @param clusterAlias the cluster alias the remote cluster is registered under
+    * @throws IllegalArgumentException if the given clusterAlias doesn't exist
+    */
+    public ProtobufClient getRemoteClusterClientProtobuf(ThreadPool threadPool, String clusterAlias) {
+        if (protobufTransportService.getRemoteClusterService().isEnabled() == false) {
+            throw new IllegalArgumentException(
+                "this node does not have the " + DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName() + " role"
+            );
+        }
+        if (protobufTransportService.getRemoteClusterService().getRemoteClusterNames().contains(clusterAlias) == false) {
+            throw new NoSuchRemoteClusterException(clusterAlias);
+        }
+        return new ProtobufRemoteClusterAwareClient(settings, threadPool, protobufTransportService, clusterAlias);
+    }
+
     Collection<RemoteClusterConnection> getConnections() {
         return remoteClusters.values();
     }
diff --git a/server/src/main/java/org/opensearch/transport/TcpTransport.java b/server/src/main/java/org/opensearch/transport/TcpTransport.java
index 8733cb5fe7e8e..a72ba2b78fef6 100644
--- a/server/src/main/java/org/opensearch/transport/TcpTransport.java
+++ b/server/src/main/java/org/opensearch/transport/TcpTransport.java
@@ -39,6 +39,7 @@
 import org.opensearch.action.ActionListener;
 import org.opensearch.action.support.ThreadedActionListener;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
 import org.opensearch.common.Booleans;
 import org.opensearch.core.common.breaker.CircuitBreaker;
 import org.opensearch.core.common.bytes.BytesArray;
@@ -56,6 +57,8 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.transport.BoundTransportAddress;
 import org.opensearch.common.transport.PortsRange;
+import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.common.unit.TimeValue;
@@ -149,6 +152,8 @@ public abstract class TcpTransport extends AbstractLifecycleComponent implements
     private final InboundHandler inboundHandler;
     private final ResponseHandlers responseHandlers = new ResponseHandlers();
     private final RequestHandlers requestHandlers = new RequestHandlers();
+    private final ProtobufResponseHandlers protobufResponseHandlers = new ProtobufResponseHandlers();
+    private final ProtobufRequestHandlers protobufRequestHandlers = new ProtobufRequestHandlers();
 
     private final AtomicLong outboundConnectionCount = new AtomicLong(); // also used as a correlation ID for open/close logs
 
@@ -1015,6 +1020,53 @@ public final RequestHandlers getRequestHandlers() {
         return requestHandlers;
     }
 
+    @Override
+    public void setMessageListener(ProtobufTransportMessageListener listener) {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'setMessageListener'");
+    }
+
+    @Override
+    public ProtobufBoundTransportAddress boundProtobufAddress() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'boundProtobufAddress'");
+    }
+
+    @Override
+    public Map<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'profileProtobufBoundAddresses'");
+    }
+
+    @Override
+    public ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'addressesFromStringProtobuf'");
+    }
+
+    @Override
+    public void openProtobufConnection(ProtobufDiscoveryNode node, ProtobufConnectionProfile profile,
+            ActionListener<ProtobufConnection> listener) {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'openProtobufConnection'");
+    }
+
+    @Override
+    public ProtobufTransportStats getProtobufStats() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getProtobufStats'");
+    }
+
+    @Override
+    public ProtobufResponseHandlers getProtobufResponseHandlers() {
+        return protobufResponseHandlers;
+    }
+
+    @Override
+    public ProtobufRequestHandlers getProtobufRequestHandlers() {
+        return protobufRequestHandlers;
+    }
+
     private final class ChannelsConnectedListener implements ActionListener<Void> {
 
         private final DiscoveryNode node;
diff --git a/server/src/main/java/org/opensearch/transport/Transport.java b/server/src/main/java/org/opensearch/transport/Transport.java
index 3bf855f847685..079934562a03d 100644
--- a/server/src/main/java/org/opensearch/transport/Transport.java
+++ b/server/src/main/java/org/opensearch/transport/Transport.java
@@ -35,9 +35,12 @@
 import org.opensearch.Version;
 import org.opensearch.action.ActionListener;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
 import org.opensearch.common.collect.MapBuilder;
 import org.opensearch.common.lifecycle.LifecycleComponent;
 import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.ConcurrentCollections;
@@ -69,6 +72,15 @@ default <Request extends TransportRequest> void registerRequestHandler(RequestHa
 
     void setMessageListener(TransportMessageListener listener);
 
+    /**
+     * Registers a new request handler
+    */
+    default <Request extends ProtobufTransportRequest> void registerProtobufRequestHandler(ProtobufRequestHandlerRegistry<Request> reg) {
+        getProtobufRequestHandlers().registerHandler(reg);
+    }
+
+    void setMessageListener(ProtobufTransportMessageListener listener);
+
     default void setSlowLogThreshold(TimeValue slowLogThreshold) {}
 
     default boolean isSecure() {
@@ -91,6 +103,23 @@ default boolean isSecure() {
      */
     TransportAddress[] addressesFromString(String address) throws UnknownHostException;
 
+    /**
+     * The address the transport is bound on.
+    */
+    ProtobufBoundTransportAddress boundProtobufAddress();
+
+    /**
+     * Further profile bound addresses
+    * @return <code>null</code> iff profiles are unsupported, otherwise a map with name of profile and its bound transport address
+    */
+    Map<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses();
+
+    /**
+     * Returns an address from its string representation.
+    */
+    ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException;
+
+
     /**
      * Returns a list of all local addresses for this transport
      */
@@ -102,12 +131,28 @@ default boolean isSecure() {
      */
     void openConnection(DiscoveryNode node, ConnectionProfile profile, ActionListener<Transport.Connection> listener);
 
+    /**
+     * Opens a new connection to the given node. When the connection is fully connected, the listener is called.
+     * The ActionListener will be called on the calling thread or the generic thread pool.
+     */
+    void openProtobufConnection(
+        ProtobufDiscoveryNode node,
+        ProtobufConnectionProfile profile,
+        ActionListener<Transport.ProtobufConnection> listener
+    );
+
     TransportStats getStats();
 
     ResponseHandlers getResponseHandlers();
 
     RequestHandlers getRequestHandlers();
 
+    ProtobufTransportStats getProtobufStats();
+
+    ProtobufResponseHandlers getProtobufResponseHandlers();
+
+    ProtobufRequestHandlers getProtobufRequestHandlers();
+
     /**
      * A unidirectional connection to a {@link DiscoveryNode}
      */
@@ -158,6 +203,56 @@ default Object getCacheKey() {
         void close();
     }
 
+    /**
+     * A unidirectional connection to a {@link ProtobufDiscoveryNode}
+    */
+    interface ProtobufConnection extends Closeable {
+        /**
+         * The node this connection is associated with
+        */
+        ProtobufDiscoveryNode getNode();
+
+        /**
+         * Sends the request to the node this connection is associated with
+        * @param requestId see {@link ResponseHandlers#add(ResponseContext)} for details
+        * @param action the action to execute
+        * @param request the request to send
+        * @param options request options to apply
+        * @throws NodeNotConnectedException if the given node is not connected
+        */
+        void sendRequest(long requestId, String action, ProtobufTransportRequest request, TransportRequestOptions options)
+            throws IOException, TransportException;
+
+        /**
+         * The listener's {@link ActionListener#onResponse(Object)} method will be called when this
+        * connection is closed. No implementations currently throw an exception during close, so
+        * {@link ActionListener#onFailure(Exception)} will not be called.
+        *
+        * @param listener to be called
+        */
+        void addCloseListener(ActionListener<Void> listener);
+
+        boolean isClosed();
+
+        /**
+         * Returns the version of the node this connection was established with.
+        */
+        default Version getVersion() {
+            return getNode().getVersion();
+        }
+
+        /**
+         * Returns a key that this connection can be cached on. Delegating subclasses must delegate method call to
+        * the original connection.
+        */
+        default Object getCacheKey() {
+            return this;
+        }
+
+        @Override
+        void close();
+    }
+
     /**
      * This class represents a response context that encapsulates the actual response handler, the action and the connection it was
      * executed on.
@@ -189,6 +284,37 @@ public String action() {
         }
     }
 
+    /**
+     * This class represents a response context that encapsulates the actual response handler, the action and the connection it was
+    * executed on.
+    */
+    final class ProtobufResponseContext<T extends ProtobufTransportResponse> {
+
+        private final ProtobufTransportResponseHandler<T> handler;
+
+        private final ProtobufConnection connection;
+
+        private final String action;
+
+        ProtobufResponseContext(ProtobufTransportResponseHandler<T> handler, ProtobufConnection connection, String action) {
+            this.handler = handler;
+            this.connection = connection;
+            this.action = action;
+        }
+
+        public ProtobufTransportResponseHandler<T> handler() {
+            return handler;
+        }
+
+        public ProtobufConnection connection() {
+            return this.connection;
+        }
+
+        public String action() {
+            return this.action;
+        }
+    }
+
     /**
      * This class is a registry that allows
      */
@@ -268,6 +394,87 @@ public TransportResponseHandler<? extends TransportResponse> onResponseReceived(
         }
     }
 
+    /**
+     * This class is a registry that allows
+    */
+    final class ProtobufResponseHandlers {
+        private final ConcurrentMapLong<ProtobufResponseContext<? extends ProtobufTransportResponse>> handlers = ConcurrentCollections
+            .newConcurrentMapLongWithAggressiveConcurrency();
+        private final AtomicLong requestIdGenerator = new AtomicLong();
+
+        /**
+         * Returns <code>true</code> if the give request ID has a context associated with it.
+        */
+        public boolean contains(long requestId) {
+            return handlers.containsKey(requestId);
+        }
+
+        /**
+         * Removes and return the {@link ResponseContext} for the given request ID or returns
+        * <code>null</code> if no context is associated with this request ID.
+        */
+        public ProtobufResponseContext<? extends ProtobufTransportResponse> remove(long requestId) {
+            return handlers.remove(requestId);
+        }
+
+        /**
+         * Adds a new response context and associates it with a new request ID.
+        * @return the new request ID
+        * @see ProtobufConnection#sendRequest(long, String, ProtobufTransportRequest, TransportRequestOptions)
+        */
+        public long add(ProtobufResponseContext<? extends ProtobufTransportResponse> holder) {
+            long requestId = newRequestId();
+            ProtobufResponseContext<? extends ProtobufTransportResponse> existing = handlers.put(requestId, holder);
+            assert existing == null : "request ID already in use: " + requestId;
+            return requestId;
+        }
+
+        /**
+         * Returns a new request ID to use when sending a message via {@link ProtobufConnection#sendRequest(long, String,
+        * ProtobufTransportRequest, TransportRequestOptions)}
+        */
+        long newRequestId() {
+            return requestIdGenerator.incrementAndGet();
+        }
+
+        /**
+         * Removes and returns all {@link ResponseContext} instances that match the predicate
+        */
+        public List<ProtobufResponseContext<? extends ProtobufTransportResponse>> prune(
+            Predicate<ProtobufResponseContext<? extends ProtobufTransportResponse>> predicate
+        ) {
+            final List<ProtobufResponseContext<? extends ProtobufTransportResponse>> holders = new ArrayList<>();
+            for (Map.Entry<Long, ProtobufResponseContext<? extends ProtobufTransportResponse>> entry : handlers.entrySet()) {
+                ProtobufResponseContext<? extends ProtobufTransportResponse> holder = entry.getValue();
+                if (predicate.test(holder)) {
+                    ProtobufResponseContext<? extends ProtobufTransportResponse> remove = handlers.remove(entry.getKey());
+                    if (remove != null) {
+                        holders.add(holder);
+                    }
+                }
+            }
+            return holders;
+        }
+
+        /**
+         * called by the {@link Transport} implementation when a response or an exception has been received for a previously
+        * sent request (before any processing or deserialization was done). Returns the appropriate response handler or null if not
+        * found.
+        */
+        public ProtobufTransportResponseHandler<? extends ProtobufTransportResponse> onResponseReceived(
+            final long requestId,
+            final ProtobufTransportMessageListener listener
+        ) {
+            ProtobufResponseContext<? extends ProtobufTransportResponse> context = handlers.remove(requestId);
+            listener.onResponseReceived(requestId, context);
+            if (context == null) {
+                return null;
+            } else {
+                return context.handler();
+            }
+        }
+    }
+
     /**
      * Request handler implementations
      *
@@ -277,6 +484,9 @@ final class RequestHandlers {
 
         private volatile Map<String, RequestHandlerRegistry<? extends TransportRequest>> requestHandlers = Collections.emptyMap();
 
+        private volatile Map<String, ProtobufRequestHandlerRegistry<? extends ProtobufTransportRequest>> protobufRequestHandlers = Collections
+            .emptyMap();
+
         synchronized <Request extends TransportRequest> void registerHandler(RequestHandlerRegistry<Request> reg) {
             if (requestHandlers.containsKey(reg.getAction())) {
                 throw new IllegalArgumentException("transport handlers for action " + reg.getAction() + " is already registered");
@@ -295,4 +505,33 @@ public <T extends TransportRequest> RequestHandlerRegistry<T> getHandler(String
             return (RequestHandlerRegistry<T>) requestHandlers.get(action);
         }
     }
+
+    /**
+     * Request handler implementations
+    *
+    * @opensearch.internal
+    */
+    final class ProtobufRequestHandlers {
+
+        private volatile Map<String, ProtobufRequestHandlerRegistry<? extends ProtobufTransportRequest>> requestHandlers = Collections
+            .emptyMap();
+
+        synchronized <Request extends ProtobufTransportRequest> void registerHandler(ProtobufRequestHandlerRegistry<Request> reg) {
+            if (requestHandlers.containsKey(reg.getAction())) {
+                throw new IllegalArgumentException("transport handlers for action " + reg.getAction() + " is already registered");
+            }
+            requestHandlers = MapBuilder.newMapBuilder(requestHandlers).put(reg.getAction(), reg).immutableMap();
+        }
+
+        // TODO: Only visible for testing. Perhaps move StubbableTransport from
+        // org.opensearch.test.transport to org.opensearch.transport
+        public synchronized <Request extends ProtobufTransportRequest> void forceRegister(ProtobufRequestHandlerRegistry<Request> reg) {
+            requestHandlers = MapBuilder.newMapBuilder(requestHandlers).put(reg.getAction(), reg).immutableMap();
+        }
+
+        @SuppressWarnings("unchecked")
+        public <T extends ProtobufTransportRequest> ProtobufRequestHandlerRegistry<T> getHandler(String action) {
+            return (ProtobufRequestHandlerRegistry<T>) requestHandlers.get(action);
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/usage/UsageService.java b/server/src/main/java/org/opensearch/usage/UsageService.java
index 14e25b591bda0..cffdb99b802eb 100644
--- a/server/src/main/java/org/opensearch/usage/UsageService.java
+++ b/server/src/main/java/org/opensearch/usage/UsageService.java
@@ -53,6 +53,7 @@
 
 import org.opensearch.action.admin.cluster.node.usage.NodeUsage;
 import org.opensearch.rest.BaseRestHandler;
+import org.opensearch.rest.ProtobufBaseRestHandler;
 
 import java.util.HashMap;
 import java.util.Locale;
@@ -67,9 +68,11 @@
 public class UsageService {
 
     private final Map<String, BaseRestHandler> handlers;
+    private final Map<String, ProtobufBaseRestHandler> protobufHandlers;
 
     public UsageService() {
         this.handlers = new HashMap<>();
+        this.protobufHandlers = new HashMap<>();
     }
 
     /**
@@ -100,6 +103,34 @@ public void addRestHandler(BaseRestHandler handler) {
         }
     }
 
+    /**
+     * Add a REST handler to this service.
+     *
+     * @param handler the {@link ProtobufBaseRestHandler} to add to the usage service.
+     */
+    public void addProtobufRestHandler(ProtobufBaseRestHandler handler) {
+        Objects.requireNonNull(handler);
+        if (handler.getName() == null) {
+            throw new IllegalArgumentException("handler of type [" + handler.getClass().getName() + "] does not have a name");
+        }
+        final ProtobufBaseRestHandler maybeHandler = protobufHandlers.put(handler.getName(), handler);
+        /*
+         * Handlers will be registered multiple times, once for each route that the handler handles. This means that we will see handlers
+         * multiple times, so we do not have a conflict if we are seeing the same instance multiple times. So, we only reject if a handler
+         * with the same name was registered before, and it is not the same instance as before.
+         */
+        if (maybeHandler != null && maybeHandler != handler) {
+            final String message = String.format(
+                Locale.ROOT,
+                "handler of type [%s] conflicts with handler of type [%s] as they both have the same name [%s]",
+                handler.getClass().getName(),
+                maybeHandler.getClass().getName(),
+                handler.getName()
+            );
+            throw new IllegalArgumentException(message);
+        }
+    }
+
     /**
      * Get the current usage statistics for this node.
      *
diff --git a/server/src/test/java/org/opensearch/rest/RestControllerTests.java b/server/src/test/java/org/opensearch/rest/RestControllerTests.java
index ea0ce54913a8d..25a8637479ec5 100644
--- a/server/src/test/java/org/opensearch/rest/RestControllerTests.java
+++ b/server/src/test/java/org/opensearch/rest/RestControllerTests.java
@@ -228,7 +228,7 @@ public void testRegisterAsDeprecatedHandler() {
 
         controller.registerAsDeprecatedHandler(method, path, handler, deprecationMessage);
 
-        verify(controller).registerHandler(eq(method), eq(path), any(DeprecationRestHandler.class));
+        verify(controller).registerProtobufHandler(eq(method), eq(path), any(DeprecationRestHandler.class));
     }
 
     public void testRegisterWithDeprecatedHandler() {
@@ -255,7 +255,7 @@ public void testRegisterWithDeprecatedHandler() {
 
         controller.registerWithDeprecatedHandler(method, path, handler, deprecatedMethod, deprecatedPath);
 
-        verify(controller).registerHandler(method, path, handler);
+        verify(controller).registerProtobufHandler(method, path, handler);
         verify(controller).registerAsDeprecatedHandler(deprecatedMethod, deprecatedPath, handler, deprecationMessage);
     }
 
diff --git a/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java b/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
index 4d59afd5f99ed..b70a143cff948 100644
--- a/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
@@ -34,17 +34,24 @@
 
 import org.opensearch.action.ActionListener;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
 import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.transport.CloseableConnection;
 import org.opensearch.transport.ConnectionProfile;
+import org.opensearch.transport.ProtobufConnectionProfile;
+import org.opensearch.transport.ProtobufTransportMessageListener;
+import org.opensearch.transport.ProtobufTransportStats;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportMessageListener;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestOptions;
 import org.opensearch.transport.TransportStats;
 
+import java.net.UnknownHostException;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
@@ -130,4 +137,53 @@ protected void doStop() {
     protected void doClose() {
 
     }
+
+    @Override
+    public void setMessageListener(ProtobufTransportMessageListener listener) {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'setMessageListener'");
+    }
+
+    @Override
+    public ProtobufBoundTransportAddress boundProtobufAddress() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'boundProtobufAddress'");
+    }
+
+    @Override
+    public Map<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'profileProtobufBoundAddresses'");
+    }
+
+    @Override
+    public ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'addressesFromStringProtobuf'");
+    }
+
+    @Override
+    public void openProtobufConnection(ProtobufDiscoveryNode node, ProtobufConnectionProfile profile,
+            ActionListener<ProtobufConnection> listener) {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'openProtobufConnection'");
+    }
+
+    @Override
+    public ProtobufTransportStats getProtobufStats() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getProtobufStats'");
+    }
+
+    @Override
+    public ProtobufResponseHandlers getProtobufResponseHandlers() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getProtobufResponseHandlers'");
+    }
+
+    @Override
+    public ProtobufRequestHandlers getProtobufRequestHandlers() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getProtobufRequestHandlers'");
+    }
 }
diff --git a/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java b/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
index 8d66d481dc4aa..9770e9e93d1e6 100644
--- a/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
@@ -35,12 +35,18 @@
 import org.opensearch.Version;
 import org.opensearch.action.ActionListener;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.ProtobufDiscoveryNode;
 import org.opensearch.common.lifecycle.Lifecycle;
 import org.opensearch.common.lifecycle.LifecycleListener;
 import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.tasks.Task;
 import org.opensearch.transport.ConnectionProfile;
+import org.opensearch.transport.ProtobufConnectionProfile;
+import org.opensearch.transport.ProtobufTransportMessageListener;
+import org.opensearch.transport.ProtobufTransportStats;
 import org.opensearch.transport.RequestHandlerRegistry;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportChannel;
@@ -310,4 +316,53 @@ void messageReceived(TransportRequestHandler<Request> handler, Request request,
 
         default void clearCallback() {}
     }
+
+    @Override
+    public void setMessageListener(ProtobufTransportMessageListener listener) {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'setMessageListener'");
+    }
+
+    @Override
+    public ProtobufBoundTransportAddress boundProtobufAddress() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'boundProtobufAddress'");
+    }
+
+    @Override
+    public Map<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'profileProtobufBoundAddresses'");
+    }
+
+    @Override
+    public ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'addressesFromStringProtobuf'");
+    }
+
+    @Override
+    public void openProtobufConnection(ProtobufDiscoveryNode node, ProtobufConnectionProfile profile,
+            ActionListener<ProtobufConnection> listener) {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'openProtobufConnection'");
+    }
+
+    @Override
+    public ProtobufTransportStats getProtobufStats() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getProtobufStats'");
+    }
+
+    @Override
+    public ProtobufResponseHandlers getProtobufResponseHandlers() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getProtobufResponseHandlers'");
+    }
+
+    @Override
+    public ProtobufRequestHandlers getProtobufRequestHandlers() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getProtobufRequestHandlers'");
+    }
 }

From a5ce258ae0b44a779e0cdc77749763a8d3b69d7f Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Wed, 21 Jun 2023 23:14:33 +0000
Subject: [PATCH 10/37] Fixes

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 ...ProtobufNodeAndClusterIdStateListener.java | 68 +++++++++++++++++++
 .../main/java/org/opensearch/node/Node.java   | 47 +++++++++++++
 2 files changed, 115 insertions(+)
 create mode 100644 server/src/main/java/org/opensearch/common/logging/ProtobufNodeAndClusterIdStateListener.java

diff --git a/server/src/main/java/org/opensearch/common/logging/ProtobufNodeAndClusterIdStateListener.java b/server/src/main/java/org/opensearch/common/logging/ProtobufNodeAndClusterIdStateListener.java
new file mode 100644
index 0000000000000..4b1be0914747d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/logging/ProtobufNodeAndClusterIdStateListener.java
@@ -0,0 +1,68 @@
+/*
+ * 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.
+ */
+
+package org.opensearch.common.logging;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.cluster.ProtobufClusterState;
+import org.opensearch.cluster.ProtobufClusterStateObserver;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.concurrent.ThreadContext;
+
+/**
+ * The {@link ProtobufNodeAndClusterIdStateListener} listens to cluster state changes and ONLY when receives the first update
+ * it sets the clusterUUID and nodeID in log4j pattern converter {@link NodeAndClusterIdConverter}.
+ * Once the first update is received, it will automatically be de-registered from subsequent updates.
+ *
+ * @opensearch.internal
+ */
+public class ProtobufNodeAndClusterIdStateListener implements ProtobufClusterStateObserver.Listener {
+    private static final Logger logger = LogManager.getLogger(ProtobufNodeAndClusterIdStateListener.class);
+
+    private ProtobufNodeAndClusterIdStateListener() {}
+
+    /**
+     * Subscribes for the first cluster state update where nodeId and clusterId is present
+     * and sets these values in {@link NodeAndClusterIdConverter}.
+     */
+    public static void getAndSetNodeIdAndClusterId(ClusterService clusterService, ThreadContext threadContext) {
+        ProtobufClusterState clusterState = clusterService.protobufState();
+        ProtobufClusterStateObserver observer = new ProtobufClusterStateObserver(clusterState, clusterService, null, logger, threadContext);
+
+        observer.waitForNextChange(new ProtobufNodeAndClusterIdStateListener(), ProtobufNodeAndClusterIdStateListener::isNodeAndClusterIdPresent);
+    }
+
+    private static boolean isNodeAndClusterIdPresent(ProtobufClusterState clusterState) {
+        return getNodeId(clusterState) != null && getClusterUUID(clusterState) != null;
+    }
+
+    private static String getClusterUUID(ProtobufClusterState state) {
+        return state.getMetadata().clusterUUID();
+    }
+
+    private static String getNodeId(ProtobufClusterState state) {
+        return state.getNodes().getLocalNodeId();
+    }
+
+    @Override
+    public void onNewClusterState(ProtobufClusterState state) {
+        String nodeId = getNodeId(state);
+        String clusterUUID = getClusterUUID(state);
+
+        logger.debug("Received cluster state update. Setting nodeId=[{}] and clusterUuid=[{}]", nodeId, clusterUUID);
+        NodeAndClusterIdConverter.setNodeIdAndClusterId(nodeId, clusterUUID);
+    }
+
+    @Override
+    public void onClusterServiceClose() {}
+
+    @Override
+    public void onTimeout(TimeValue timeout) {}
+}
diff --git a/server/src/main/java/org/opensearch/node/Node.java b/server/src/main/java/org/opensearch/node/Node.java
index e77e82368bd9b..60c0d4c75879b 100644
--- a/server/src/main/java/org/opensearch/node/Node.java
+++ b/server/src/main/java/org/opensearch/node/Node.java
@@ -101,6 +101,8 @@
 import org.opensearch.cluster.ClusterStateObserver;
 import org.opensearch.cluster.InternalClusterInfoService;
 import org.opensearch.cluster.NodeConnectionsService;
+import org.opensearch.cluster.ProtobufClusterState;
+import org.opensearch.cluster.ProtobufClusterStateObserver;
 import org.opensearch.cluster.action.index.MappingUpdatedAction;
 import org.opensearch.cluster.metadata.AliasValidator;
 import org.opensearch.cluster.metadata.IndexTemplateMetadata;
@@ -129,6 +131,7 @@
 import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.logging.HeaderWarning;
 import org.opensearch.common.logging.NodeAndClusterIdStateListener;
+import org.opensearch.common.logging.ProtobufNodeAndClusterIdStateListener;
 import org.opensearch.common.network.NetworkAddress;
 import org.opensearch.common.network.NetworkModule;
 import org.opensearch.common.network.NetworkService;
@@ -225,6 +228,7 @@
 import org.opensearch.snapshots.SnapshotShardsService;
 import org.opensearch.snapshots.SnapshotsInfoService;
 import org.opensearch.snapshots.SnapshotsService;
+import org.opensearch.tasks.ProtobufTaskCancellationService;
 import org.opensearch.tasks.Task;
 import org.opensearch.tasks.TaskCancellationService;
 import org.opensearch.tasks.TaskResultsService;
@@ -1402,8 +1406,13 @@ public Node start() throws NodeValidationException {
         transportService.getTaskManager().setTaskResultsService(injector.getInstance(TaskResultsService.class));
         transportService.getTaskManager().setTaskCancellationService(new TaskCancellationService(transportService));
 
+        ProtobufTransportService protobufTransportService = injector.getInstance(ProtobufTransportService.class);
+        protobufTransportService.getTaskManager().setTaskResultsService(injector.getInstance(TaskResultsService.class));
+        protobufTransportService.getTaskManager().setTaskCancellationService(new ProtobufTaskCancellationService(protobufTransportService));
+
         TaskResourceTrackingService taskResourceTrackingService = injector.getInstance(TaskResourceTrackingService.class);
         transportService.getTaskManager().setTaskResourceTrackingService(taskResourceTrackingService);
+        protobufTransportService.getTaskManager().setTaskResourceTrackingService(taskResourceTrackingService);
         runnableTaskListener.set(taskResourceTrackingService);
 
         transportService.start();
@@ -1456,14 +1465,18 @@ public Node start() throws NodeValidationException {
         assert clusterService.localNode().equals(localNodeFactory.getNode())
             : "clusterService has a different local node than the factory provided";
         transportService.acceptIncomingRequests();
+        // protobufTransportService.acceptIncomingRequests();
         discovery.startInitialJoin();
         final TimeValue initialStateTimeout = DiscoverySettings.INITIAL_STATE_TIMEOUT_SETTING.get(settings());
         configureNodeAndClusterIdStateListener(clusterService);
+        configureProtobufNodeAndClusterIdStateListener(clusterService);
 
         if (initialStateTimeout.millis() > 0) {
             final ThreadPool thread = injector.getInstance(ThreadPool.class);
             ClusterState clusterState = clusterService.state();
+            ProtobufClusterState protobufClusterState = clusterService.protobufState();
             ClusterStateObserver observer = new ClusterStateObserver(clusterState, clusterService, null, logger, thread.getThreadContext());
+            ProtobufClusterStateObserver protobufObserver = new ProtobufClusterStateObserver(protobufClusterState, clusterService, null, logger, thread.getThreadContext());
 
             if (clusterState.nodes().getClusterManagerNodeId() == null) {
                 logger.debug("waiting to join the cluster. timeout [{}]", initialStateTimeout);
@@ -1486,6 +1499,33 @@ public void onTimeout(TimeValue timeout) {
                     }
                 }, state -> state.nodes().getClusterManagerNodeId() != null, initialStateTimeout);
 
+                try {
+                    latch.await();
+                } catch (InterruptedException e) {
+                    throw new OpenSearchTimeoutException("Interrupted while waiting for initial discovery state");
+                }
+            }
+            if (protobufClusterState.nodes().getClusterManagerNodeId() == null) {
+                logger.debug("waiting to join the cluster. timeout [{}]", initialStateTimeout);
+                final CountDownLatch latch = new CountDownLatch(1);
+                protobufObserver.waitForNextChange(new ProtobufClusterStateObserver.Listener() {
+                    @Override
+                    public void onNewClusterState(ProtobufClusterState state) {
+                        latch.countDown();
+                    }
+
+                    @Override
+                    public void onClusterServiceClose() {
+                        latch.countDown();
+                    }
+
+                    @Override
+                    public void onTimeout(TimeValue timeout) {
+                        logger.warn("timed out while waiting for initial discovery state - timeout: {}", initialStateTimeout);
+                        latch.countDown();
+                    }
+                }, state -> state.nodes().getClusterManagerNodeId() != null, initialStateTimeout);
+
                 try {
                     latch.await();
                 } catch (InterruptedException e) {
@@ -1517,6 +1557,13 @@ protected void configureNodeAndClusterIdStateListener(ClusterService clusterServ
         );
     }
 
+    protected void configureProtobufNodeAndClusterIdStateListener(ClusterService clusterService) {
+        ProtobufNodeAndClusterIdStateListener.getAndSetNodeIdAndClusterId(
+            clusterService,
+            injector.getInstance(ThreadPool.class).getThreadContext()
+        );
+    }
+
     private Node stop() {
         if (!lifecycle.moveToStopped()) {
             return this;

From 0d76b3be3b0c6eb41d34fcc80272ee52b7f6b495 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Fri, 30 Jun 2023 07:09:05 +0000
Subject: [PATCH 11/37] Fixing nodes api response for protobuf

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../java/org/opensearch/core/index/Index.java |  20 +-
 .../opensearch/core/index/shard/ShardId.java  |  18 +-
 .../breaker/CircuitBreakerService.java        |  10 +
 .../breaker/NoneCircuitBreakerService.java    |  10 +
 .../org/opensearch/action/ActionModule.java   |  40 +-
 .../cluster/node/info/ProtobufNodeInfo.java   |  24 +-
 .../node/info/ProtobufNodesInfoResponse.java  | 116 ++-
 .../node/info/ProtobufPluginsAndModules.java  |  18 +
 .../ProtobufTransportNodesInfoAction.java     |  33 +-
 .../node/info/TransportNodesInfoAction.java   |   3 +-
 .../cluster/node/stats/ProtobufNodeStats.java |   4 +-
 .../node/stats/ProtobufNodesStatsRequest.java |  10 +-
 .../ProtobufNodesStatsRequestBuilder.java     |   4 +-
 .../stats/ProtobufNodesStatsResponse.java     |   8 +-
 .../ProtobufTransportNodesStatsAction.java    |  12 +-
 .../state/ProtobufClusterStateResponse.java   |  15 +-
 .../ProtobufTransportClusterStateAction.java  |   5 +-
 .../admin/indices/stats/CommonStatsFlags.java |  51 +-
 .../indices/stats/ProtobufCommonStats.java    |  74 +-
 .../stats/ProtobufIndexShardStats.java        |  98 +++
 .../indices/stats/ProtobufShardStats.java     | 178 ++++
 .../action/main/ProtobufMainRequest.java      |   1 -
 .../action/main/ProtobufMainResponse.java     |  14 +-
 .../main/ProtobufTransportMainAction.java     |   5 +-
 .../ProtobufHandledTransportAction.java       |   5 +-
 ...obufTransportClusterManagerNodeAction.java |  39 +-
 .../nodes/ProtobufBaseNodeResponse.java       |  10 +-
 .../nodes/ProtobufBaseNodesRequest.java       |  12 +-
 .../nodes/ProtobufBaseNodesResponse.java      |  16 +-
 .../nodes/ProtobufTransportNodesAction.java   |  17 +-
 .../ClusterManagerNodeChangePredicate.java    |   6 +-
 .../org/opensearch/cluster/ClusterName.java   |  15 +-
 .../org/opensearch/cluster/ClusterState.java  |  20 +
 .../cluster/ProtobufClusterName.java          |  76 --
 .../cluster/ProtobufClusterState.java         |  94 ++-
 .../cluster/ProtobufClusterStateObserver.java |  11 +-
 .../cluster/coordination/Coordinator.java     |  18 +
 .../PublicationTransportHandler.java          |   8 +
 .../opensearch/cluster/metadata/Metadata.java |  28 +
 .../ProtobufIndexNameExpressionResolver.java  |  15 +-
 .../cluster/node/DiscoveryNode.java           |  89 +-
 .../cluster/node/ProtobufDiscoveryNode.java   | 537 ------------
 .../cluster/node/ProtobufDiscoveryNodes.java  | 159 ++--
 .../cluster/routing/AllocationId.java         |  21 +-
 .../cluster/routing/IndexRoutingTable.java    |  14 +
 .../routing/IndexShardRoutingTable.java       |  16 +
 .../cluster/routing/RoutingTable.java         |  14 +
 .../cluster/routing/ShardRouting.java         |  61 +-
 .../cluster/routing/UnassignedInfo.java       |  64 +-
 .../cluster/service/ClusterApplier.java       |   7 +
 .../service/ClusterApplierService.java        |   9 +
 .../common/io/stream/ProtobufStreamInput.java |   2 +-
 ...ProtobufNodeAndClusterIdStateListener.java |   5 +-
 .../common/network/NetworkModule.java         |   6 +-
 .../common/settings/SettingsModule.java       |   1 -
 .../ProtobufBoundTransportAddress.java        |  24 +
 .../transport/ProtobufTransportAddress.java   |  28 +-
 .../org/opensearch/discovery/Discovery.java   |   5 +
 .../http/AbstractHttpServerTransport.java     |  28 +-
 .../opensearch/http/HttpServerTransport.java  |   8 +-
 .../org/opensearch/http/ProtobufHttpInfo.java |  41 +
 .../cache/request/ShardRequestCache.java      |   4 +
 .../opensearch/index/engine/CommitStats.java  |  38 +-
 .../org/opensearch/index/engine/Engine.java   |  77 ++
 .../index/fielddata/ShardFieldData.java       |  18 +
 .../opensearch/index/get/ShardGetService.java |  10 +
 .../index/search/stats/ShardSearchStats.java  |  45 ++
 .../index/seqno/RetentionLease.java           |  34 +-
 .../index/seqno/RetentionLeaseStats.java      |  28 +-
 .../index/seqno/RetentionLeases.java          |  35 +-
 .../opensearch/index/seqno/SeqNoStats.java    |  17 +-
 .../opensearch/index/shard/IndexShard.java    |  93 +++
 .../index/shard/InternalIndexingStats.java    |  25 +
 .../org/opensearch/index/store/Store.java     |   8 +
 .../index/warmer/ShardIndexWarmerService.java |   4 +
 .../opensearch/indices/IndicesQueryCache.java |  34 +
 .../opensearch/indices/IndicesService.java    | 141 ++++
 .../indices/ProtobufNodeIndicesStats.java     |  19 +-
 .../HierarchyCircuitBreakerService.java       |  33 +
 .../org/opensearch/ingest/IngestService.java  |  31 +-
 .../opensearch/ingest/ProtobufIngestInfo.java |  14 +
 .../ingest/ProtobufProcessorInfo.java         |  13 +-
 .../monitor/ProtobufMonitorService.java       |  77 ++
 .../org/opensearch/monitor/fs/FsProbe.java    |  95 +++
 .../monitor/fs/ProtobufFsService.java         |  94 +++
 .../org/opensearch/monitor/jvm/JvmInfo.java   |  87 +-
 .../monitor/jvm/ProtobufJvmInfo.java          | 571 -------------
 .../monitor/jvm/ProtobufJvmService.java       |  61 ++
 .../org/opensearch/monitor/os/OsProbe.java    | 109 +++
 .../opensearch/monitor/os/ProtobufOsInfo.java |  37 +
 .../monitor/os/ProtobufOsService.java         |  70 ++
 .../monitor/process/ProcessProbe.java         |  10 +
 .../monitor/process/ProtobufProcessInfo.java  |  21 +
 .../process/ProtobufProcessService.java       |  67 ++
 .../main/java/org/opensearch/node/Node.java   | 116 +--
 .../node/ProtobufNodeClosedException.java     |   4 +-
 .../opensearch/node/ProtobufNodeService.java  |  86 +-
 .../node/ProtobufReportingService.java        |   3 +-
 .../node/ResponseCollectorService.java        |  12 +
 .../plugins/ProtobufPluginInfo.java           |  24 +-
 .../org/opensearch/rest/BaseRestHandler.java  |   2 +
 .../rest/ProtobufBaseRestHandler.java         |   2 +
 .../rest/ProtobufDeprecationRestHandler.java  | 105 +++
 .../org/opensearch/rest/RestBaseHandler.java  |   8 +-
 .../org/opensearch/rest/RestController.java   |  41 +-
 .../action/cat/ProtobufRestNodesAction.java   |  10 +-
 .../rest/action/cat/RestNodesAction.java      |   1 -
 .../org/opensearch/script/ScriptCache.java    |   8 +
 .../org/opensearch/script/ScriptMetrics.java  |  13 +
 .../org/opensearch/script/ScriptService.java  |  16 +
 .../support/AggregationUsageService.java      |  10 +-
 .../support/ProtobufAggregationInfo.java      |  18 +
 .../pipeline/ProtobufSearchPipelineInfo.java  |  14 +
 .../pipeline/SearchPipelineService.java       |  17 +-
 .../org/opensearch/tasks/ProtobufTask.java    |   6 +-
 .../ProtobufTaskCancellationService.java      |  12 +-
 .../opensearch/tasks/ProtobufTaskManager.java | 763 ------------------
 .../org/opensearch/tasks/TaskManager.java     |  42 +-
 .../threadpool/ProtobufThreadPoolInfo.java    |  15 +
 .../org/opensearch/threadpool/ThreadPool.java |   1 -
 .../opensearch/transport/InboundHandler.java  |   9 +
 .../opensearch/transport/OutboundHandler.java |   9 +
 .../ProtobufClusterConnectionManager.java     |  35 +-
 .../ProtobufConnectTransportException.java    |  18 +-
 .../transport/ProtobufConnectionManager.java  |  18 +-
 .../transport/ProtobufConnectionProfile.java  |   9 +-
 .../ProtobufNodeDisconnectedException.java    |   4 +-
 .../ProtobufNodeNotConnectedException.java    |   4 +-
 .../transport/ProtobufOutboundHandler.java    |   4 +-
 .../ProtobufProxyConnectionStrategy.java      |  27 +-
 ...tobufReceiveTimeoutTransportException.java |   6 +-
 .../ProtobufRemoteClusterAwareClient.java     |  13 +-
 .../ProtobufRemoteClusterAwareRequest.java    |  29 -
 .../ProtobufRemoteClusterConnection.java      |  14 +-
 .../ProtobufRemoteClusterService.java         |  20 +-
 .../ProtobufRemoteConnectionManager.java      |  46 +-
 .../ProtobufRemoteConnectionStrategy.java     |   4 +-
 .../ProtobufRequestHandlerRegistry.java       |   5 +-
 ...ProtobufSendRequestTransportException.java |   6 +-
 .../ProtobufSniffConnectionStrategy.java      |  68 +-
 .../transport/ProtobufTransport.java          | 281 -------
 .../ProtobufTransportActionProxy.java         |  12 +-
 .../ProtobufTransportConnectionListener.java  |   6 +-
 .../transport/ProtobufTransportInfo.java      |  22 +
 .../ProtobufTransportInterceptor.java         |   6 +-
 .../ProtobufTransportMessageListener.java     |   4 +-
 .../transport/ProtobufTransportService.java   | 134 +--
 .../transport/RemoteClusterService.java       |   6 +-
 .../opensearch/transport/TcpTransport.java    |  73 +-
 .../org/opensearch/transport/Transport.java   |  13 +-
 .../cluster/NodeConnectionsServiceTests.java  |  79 ++
 .../coordination/NoOpClusterApplier.java      |   6 +
 .../common/network/NetworkModuleTests.java    |  12 +
 .../opensearch/rest/RestControllerTests.java  |  16 +-
 .../org/opensearch/test/NoopDiscovery.java    |   6 +
 .../opensearch/test/MockHttpTransport.java    |  24 +
 .../test/transport/FakeTransport.java         |   5 +-
 .../test/transport/StubbableTransport.java    |   5 +-
 158 files changed, 3757 insertions(+), 2970 deletions(-)
 create mode 100644 server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufIndexShardStats.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufShardStats.java
 delete mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufClusterName.java
 delete mode 100644 server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNode.java
 create mode 100644 server/src/main/java/org/opensearch/monitor/ProtobufMonitorService.java
 create mode 100644 server/src/main/java/org/opensearch/monitor/fs/ProtobufFsService.java
 delete mode 100644 server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java
 create mode 100644 server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmService.java
 create mode 100644 server/src/main/java/org/opensearch/monitor/os/ProtobufOsService.java
 create mode 100644 server/src/main/java/org/opensearch/monitor/process/ProtobufProcessService.java
 create mode 100644 server/src/main/java/org/opensearch/rest/ProtobufDeprecationRestHandler.java
 delete mode 100644 server/src/main/java/org/opensearch/tasks/ProtobufTaskManager.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareRequest.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransport.java

diff --git a/libs/core/src/main/java/org/opensearch/core/index/Index.java b/libs/core/src/main/java/org/opensearch/core/index/Index.java
index fc5c5152a5500..7bff2f7d0dc3b 100644
--- a/libs/core/src/main/java/org/opensearch/core/index/Index.java
+++ b/libs/core/src/main/java/org/opensearch/core/index/Index.java
@@ -33,6 +33,7 @@
 package org.opensearch.core.index;
 
 import org.opensearch.core.ParseField;
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
@@ -42,6 +43,9 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.Objects;
 
@@ -50,7 +54,7 @@
  *
  * @opensearch.internal
  */
-public class Index implements Writeable, ToXContentObject {
+public class Index implements Writeable, ToXContentObject, ProtobufWriteable {
 
     public static final Index[] EMPTY_ARRAY = new Index[0];
     private static final String INDEX_UUID_KEY = "index_uuid";
@@ -77,6 +81,14 @@ public Index(StreamInput in) throws IOException {
         this.uuid = in.readString();
     }
 
+    /**
+     * Read from a stream.
+     */
+    public Index(CodedInputStream in) throws IOException {
+        this.name = in.readString();
+        this.uuid = in.readString();
+    }
+
     public String getName() {
         return this.name;
     }
@@ -122,6 +134,12 @@ public void writeTo(final StreamOutput out) throws IOException {
         out.writeString(uuid);
     }
 
+    @Override
+    public void writeTo(final CodedOutputStream out) throws IOException {
+        out.writeStringNoTag(name);
+        out.writeStringNoTag(uuid);
+    }
+
     @Override
     public XContentBuilder toXContent(final XContentBuilder builder, final Params params) throws IOException {
         builder.startObject();
diff --git a/libs/core/src/main/java/org/opensearch/core/index/shard/ShardId.java b/libs/core/src/main/java/org/opensearch/core/index/shard/ShardId.java
index b01121c3f30d4..e978978f2920c 100644
--- a/libs/core/src/main/java/org/opensearch/core/index/shard/ShardId.java
+++ b/libs/core/src/main/java/org/opensearch/core/index/shard/ShardId.java
@@ -33,6 +33,7 @@
 package org.opensearch.core.index.shard;
 
 import org.opensearch.core.common.Strings;
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
@@ -40,6 +41,9 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.index.Index;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 
 /**
@@ -47,7 +51,7 @@
  *
  * @opensearch.internal
  */
-public class ShardId implements Comparable<ShardId>, ToXContentFragment, Writeable {
+public class ShardId implements Comparable<ShardId>, ToXContentFragment, Writeable, ProtobufWriteable {
 
     private final Index index;
     private final int shardId;
@@ -69,12 +73,24 @@ public ShardId(StreamInput in) throws IOException {
         hashCode = computeHashCode();
     }
 
+    public ShardId(CodedInputStream in) throws IOException {
+        index = new Index(in);
+        shardId = in.readInt32();
+        hashCode = computeHashCode();
+    }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         index.writeTo(out);
         out.writeVInt(shardId);
     }
 
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        index.writeTo(out);
+        out.writeInt32NoTag(shardId);
+    }
+
     public Index getIndex() {
         return index;
     }
diff --git a/libs/core/src/main/java/org/opensearch/core/indices/breaker/CircuitBreakerService.java b/libs/core/src/main/java/org/opensearch/core/indices/breaker/CircuitBreakerService.java
index ee9c94f432a36..6069a1a20a23a 100644
--- a/libs/core/src/main/java/org/opensearch/core/indices/breaker/CircuitBreakerService.java
+++ b/libs/core/src/main/java/org/opensearch/core/indices/breaker/CircuitBreakerService.java
@@ -63,6 +63,16 @@ protected CircuitBreakerService() {}
      */
     public abstract CircuitBreakerStats stats(String name);
 
+    /**
+     * @return stats about all breakers
+     */
+    public abstract ProtobufAllCircuitBreakerStats protobufStats();
+
+    /**
+     * @return stats about a specific breaker
+     */
+    public abstract ProtobufCircuitBreakerStats protobufStats(String name);
+
     @Override
     protected void doStart() {}
 
diff --git a/libs/core/src/main/java/org/opensearch/core/indices/breaker/NoneCircuitBreakerService.java b/libs/core/src/main/java/org/opensearch/core/indices/breaker/NoneCircuitBreakerService.java
index 4095fd32b6d3c..626c4ad5d0100 100644
--- a/libs/core/src/main/java/org/opensearch/core/indices/breaker/NoneCircuitBreakerService.java
+++ b/libs/core/src/main/java/org/opensearch/core/indices/breaker/NoneCircuitBreakerService.java
@@ -63,4 +63,14 @@ public CircuitBreakerStats stats(String name) {
         return new CircuitBreakerStats(CircuitBreaker.FIELDDATA, -1, -1, 0, 0);
     }
 
+    @Override
+    public ProtobufAllCircuitBreakerStats protobufStats() {
+        return new ProtobufAllCircuitBreakerStats(new ProtobufCircuitBreakerStats[] { protobufStats(CircuitBreaker.FIELDDATA) });
+    }
+
+    @Override
+    public ProtobufCircuitBreakerStats protobufStats(String name) {
+        return new ProtobufCircuitBreakerStats(CircuitBreaker.FIELDDATA, -1, -1, 0, 0);
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/action/ActionModule.java b/server/src/main/java/org/opensearch/action/ActionModule.java
index e7edc75b4f235..ecf5d1884cf65 100644
--- a/server/src/main/java/org/opensearch/action/ActionModule.java
+++ b/server/src/main/java/org/opensearch/action/ActionModule.java
@@ -297,7 +297,6 @@
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
 import org.opensearch.cluster.metadata.ProtobufIndexNameExpressionResolver;
 import org.opensearch.cluster.node.DiscoveryNodes;
-import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
 import org.opensearch.common.NamedRegistry;
 import org.opensearch.common.inject.AbstractModule;
 import org.opensearch.common.inject.TypeLiteral;
@@ -558,9 +557,11 @@ public ActionModule(
         this.settingsFilter = settingsFilter;
         this.actionPlugins = actionPlugins;
         this.protobufIndexNameExpressionResolver = null;
-        this.protobufActionPlugins = new ArrayList<>();;
+        this.protobufActionPlugins = new ArrayList<>();
+        ;
         this.protobufActions = new HashMap<String, ProtobufActionPlugin.ActionHandler<?, ?>>();
-        this.protobufActionFilters = setupProtobufActionFilters(this.protobufActionPlugins);;
+        this.protobufActionFilters = setupProtobufActionFilters(this.protobufActionPlugins);
+        ;
         this.threadPool = threadPool;
         this.extensionsManager = extensionsManager;
         actions = setupActions(actionPlugins);
@@ -660,7 +661,15 @@ public ActionModule(
             actionPlugins.stream().flatMap(p -> p.indicesAliasesRequestValidators().stream()).collect(Collectors.toList())
         );
 
-        restController = new RestController(headers, restWrapper, nodeClient, protobufRestWrapper, protobufNodeClient, circuitBreakerService, usageService);
+        restController = new RestController(
+            headers,
+            restWrapper,
+            nodeClient,
+            protobufRestWrapper,
+            protobufNodeClient,
+            circuitBreakerService,
+            usageService
+        );
     }
 
     public Map<String, ActionHandler<?, ?>> getActions() {
@@ -1125,17 +1134,17 @@ public void initProtobufRestHandlers() {
         registerHandler.accept(new ProtobufRestNodesAction());
 
         // for (ActionPlugin plugin : actionPlugins) {
-        //     for (ProtobufActionPlugin handler : plugin.getRestHandlers(
-        //         settings,
-        //         restController,
-        //         clusterSettings,
-        //         indexScopedSettings,
-        //         settingsFilter,
-        //         indexNameExpressionResolver,
-        //         nodesInCluster
-        //     )) {
-        //         registerHandler.accept(handler);
-        //     }
+        // for (ProtobufActionPlugin handler : plugin.getRestHandlers(
+        // settings,
+        // restController,
+        // clusterSettings,
+        // indexScopedSettings,
+        // settingsFilter,
+        // indexNameExpressionResolver,
+        // nodesInCluster
+        // )) {
+        // registerHandler.accept(handler);
+        // }
         // }
         registerHandler.accept(new ProtobufRestCatAction(catActions));
     }
@@ -1192,7 +1201,6 @@ protected void configure() {
         // register dynamic ActionType -> transportAction Map used by NodeClient
         bind(ProtobufDynamicActionRegistry.class).toInstance(protobufDynamicActionRegistry);
 
-
     }
 
     public ActionFilters getActionFilters() {
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
index df059711196cd..d8184bfa0a46d 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
@@ -18,7 +18,7 @@
 import org.opensearch.Build;
 import org.opensearch.Version;
 import org.opensearch.action.support.nodes.ProtobufBaseNodeResponse;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
@@ -27,7 +27,7 @@
 import org.opensearch.http.ProtobufHttpInfo;
 import org.opensearch.ingest.ProtobufIngestInfo;
 import org.opensearch.monitor.jvm.JvmInfo;
-import org.opensearch.monitor.jvm.ProtobufJvmInfo;
+import org.opensearch.monitor.jvm.JvmInfo;
 import org.opensearch.monitor.os.OsInfo;
 import org.opensearch.monitor.os.ProtobufOsInfo;
 import org.opensearch.monitor.process.ProtobufProcessInfo;
@@ -79,7 +79,7 @@ public ProtobufNodeInfo(CodedInputStream in) throws IOException {
         }
         addInfoIfNonNull(ProtobufOsInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufOsInfo::new));
         addInfoIfNonNull(ProtobufProcessInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufProcessInfo::new));
-        addInfoIfNonNull(ProtobufJvmInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufJvmInfo::new));
+        addInfoIfNonNull(JvmInfo.class, protobufStreamInput.readOptionalWriteable(JvmInfo::new));
         addInfoIfNonNull(ProtobufThreadPoolInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufThreadPoolInfo::new));
         addInfoIfNonNull(ProtobufTransportInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufTransportInfo::new));
         addInfoIfNonNull(ProtobufHttpInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufHttpInfo::new));
@@ -94,11 +94,11 @@ public ProtobufNodeInfo(CodedInputStream in) throws IOException {
     public ProtobufNodeInfo(
         Version version,
         Build build,
-        ProtobufDiscoveryNode node,
+        DiscoveryNode node,
         @Nullable Settings settings,
         @Nullable ProtobufOsInfo os,
         @Nullable ProtobufProcessInfo process,
-        @Nullable ProtobufJvmInfo jvm,
+        @Nullable JvmInfo jvm,
         @Nullable ProtobufThreadPoolInfo threadPool,
         @Nullable ProtobufTransportInfo transport,
         @Nullable ProtobufHttpInfo http,
@@ -114,7 +114,7 @@ public ProtobufNodeInfo(
         this.settings = settings;
         addInfoIfNonNull(ProtobufOsInfo.class, os);
         addInfoIfNonNull(ProtobufProcessInfo.class, process);
-        addInfoIfNonNull(ProtobufJvmInfo.class, jvm);
+        addInfoIfNonNull(JvmInfo.class, jvm);
         addInfoIfNonNull(ProtobufThreadPoolInfo.class, threadPool);
         addInfoIfNonNull(ProtobufTransportInfo.class, transport);
         addInfoIfNonNull(ProtobufHttpInfo.class, http);
@@ -204,7 +204,7 @@ public void writeTo(CodedOutputStream out) throws IOException {
         }
         protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufOsInfo.class));
         protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufProcessInfo.class));
-        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufJvmInfo.class));
+        protobufStreamOutput.writeOptionalWriteable(getInfo(JvmInfo.class));
         protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufThreadPoolInfo.class));
         protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufTransportInfo.class));
         protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufHttpInfo.class));
@@ -216,7 +216,7 @@ public void writeTo(CodedOutputStream out) throws IOException {
         }
     }
 
-    public static ProtobufNodeInfo.Builder builder(Version version, Build build, ProtobufDiscoveryNode node) {
+    public static ProtobufNodeInfo.Builder builder(Version version, Build build, DiscoveryNode node) {
         return new Builder(version, build, node);
     }
 
@@ -226,9 +226,9 @@ public static ProtobufNodeInfo.Builder builder(Version version, Build build, Pro
     public static class Builder {
         private final Version version;
         private final Build build;
-        private final ProtobufDiscoveryNode node;
+        private final DiscoveryNode node;
 
-        private Builder(Version version, Build build, ProtobufDiscoveryNode node) {
+        private Builder(Version version, Build build, DiscoveryNode node) {
             this.version = version;
             this.build = build;
             this.node = node;
@@ -237,7 +237,7 @@ private Builder(Version version, Build build, ProtobufDiscoveryNode node) {
         private Settings settings;
         private ProtobufOsInfo os;
         private ProtobufProcessInfo process;
-        private ProtobufJvmInfo jvm;
+        private JvmInfo jvm;
         private ProtobufThreadPoolInfo threadPool;
         private ProtobufTransportInfo transport;
         private ProtobufHttpInfo http;
@@ -262,7 +262,7 @@ public Builder setProcess(ProtobufProcessInfo process) {
             return this;
         }
 
-        public Builder setJvm(ProtobufJvmInfo jvm) {
+        public Builder setJvm(JvmInfo jvm) {
             this.jvm = jvm;
             return this;
         }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
index 2f82367e0c9e7..7b46d535c5224 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
@@ -36,29 +36,42 @@
 import com.google.protobuf.CodedOutputStream;
 import org.opensearch.action.ProtobufFailedNodeException;
 import org.opensearch.action.support.nodes.ProtobufBaseNodesResponse;
-import org.opensearch.cluster.ProtobufClusterName;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
+import org.opensearch.common.Strings;
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.xcontent.XContentFactory;
+import org.opensearch.core.xcontent.ToXContent.Params;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.http.ProtobufHttpInfo;
+import org.opensearch.ingest.ProtobufIngestInfo;
+import org.opensearch.monitor.jvm.JvmInfo;
+import org.opensearch.monitor.os.ProtobufOsInfo;
+import org.opensearch.monitor.process.ProtobufProcessInfo;
+import org.opensearch.search.aggregations.support.ProtobufAggregationInfo;
+import org.opensearch.search.pipeline.ProtobufSearchPipelineInfo;
+import org.opensearch.threadpool.ProtobufThreadPoolInfo;
+import org.opensearch.transport.ProtobufTransportInfo;
 
 import java.io.IOException;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Transport response for OpenSearch Node Information
 *
 * @opensearch.internal
 */
-public class ProtobufNodesInfoResponse extends ProtobufBaseNodesResponse<ProtobufNodeInfo> {
+public class ProtobufNodesInfoResponse extends ProtobufBaseNodesResponse<ProtobufNodeInfo> implements ToXContentFragment {
 
     public ProtobufNodesInfoResponse(CodedInputStream in) throws IOException {
         super(in);
     }
 
-    public ProtobufNodesInfoResponse(
-        ProtobufClusterName clusterName,
-        List<ProtobufNodeInfo> nodes,
-        List<ProtobufFailedNodeException> failures
-    ) {
+    public ProtobufNodesInfoResponse(ClusterName clusterName, List<ProtobufNodeInfo> nodes, List<ProtobufFailedNodeException> failures) {
         super(clusterName, nodes, failures);
     }
 
@@ -73,4 +86,93 @@ protected void writeNodesTo(CodedOutputStream out, List<ProtobufNodeInfo> nodes)
         ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         protobufStreamOutput.writeCollection(nodes, (o, v) -> v.writeTo(o));
     }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject("nodes");
+        for (ProtobufNodeInfo nodeInfo : getNodes()) {
+            builder.startObject(nodeInfo.getNode().getId());
+
+            builder.field("name", nodeInfo.getNode().getName());
+            builder.field("transport_address", nodeInfo.getNode().getAddress().toString());
+            builder.field("host", nodeInfo.getNode().getHostName());
+            builder.field("ip", nodeInfo.getNode().getHostAddress());
+
+            builder.field("version", nodeInfo.getVersion());
+            builder.field("build_type", nodeInfo.getBuild().type().displayName());
+            builder.field("build_hash", nodeInfo.getBuild().hash());
+            if (nodeInfo.getTotalIndexingBuffer() != null) {
+                builder.humanReadableField("total_indexing_buffer", "total_indexing_buffer_in_bytes", nodeInfo.getTotalIndexingBuffer());
+            }
+
+            builder.startArray("roles");
+            for (DiscoveryNodeRole role : nodeInfo.getNode().getRoles()) {
+                builder.value(role.roleName());
+            }
+            builder.endArray();
+
+            if (!nodeInfo.getNode().getAttributes().isEmpty()) {
+                builder.startObject("attributes");
+                for (Map.Entry<String, String> entry : nodeInfo.getNode().getAttributes().entrySet()) {
+                    builder.field(entry.getKey(), entry.getValue());
+                }
+                builder.endObject();
+            }
+
+            if (nodeInfo.getSettings() != null) {
+                builder.startObject("settings");
+                Settings settings = nodeInfo.getSettings();
+                settings.toXContent(builder, params);
+                builder.endObject();
+            }
+
+            if (nodeInfo.getInfo(ProtobufOsInfo.class) != null) {
+                nodeInfo.getInfo(ProtobufOsInfo.class).toXContent(builder, params);
+            }
+            if (nodeInfo.getInfo(ProtobufProcessInfo.class) != null) {
+                nodeInfo.getInfo(ProtobufProcessInfo.class).toXContent(builder, params);
+            }
+            if (nodeInfo.getInfo(JvmInfo.class) != null) {
+                nodeInfo.getInfo(JvmInfo.class).toXContent(builder, params);
+            }
+            if (nodeInfo.getInfo(ProtobufThreadPoolInfo.class) != null) {
+                nodeInfo.getInfo(ProtobufThreadPoolInfo.class).toXContent(builder, params);
+            }
+            if (nodeInfo.getInfo(ProtobufTransportInfo.class) != null) {
+                nodeInfo.getInfo(ProtobufTransportInfo.class).toXContent(builder, params);
+            }
+            if (nodeInfo.getInfo(ProtobufHttpInfo.class) != null) {
+                nodeInfo.getInfo(ProtobufHttpInfo.class).toXContent(builder, params);
+            }
+            if (nodeInfo.getInfo(ProtobufPluginsAndModules.class) != null) {
+                nodeInfo.getInfo(ProtobufPluginsAndModules.class).toXContent(builder, params);
+            }
+            if (nodeInfo.getInfo(ProtobufIngestInfo.class) != null) {
+                nodeInfo.getInfo(ProtobufIngestInfo.class).toXContent(builder, params);
+            }
+            if (nodeInfo.getInfo(ProtobufAggregationInfo.class) != null) {
+                nodeInfo.getInfo(ProtobufAggregationInfo.class).toXContent(builder, params);
+            }
+            if (nodeInfo.getInfo(ProtobufSearchPipelineInfo.class) != null) {
+                nodeInfo.getInfo(ProtobufSearchPipelineInfo.class).toXContent(builder, params);
+            }
+
+            builder.endObject();
+        }
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public String toString() {
+        try {
+            XContentBuilder builder = XContentFactory.jsonBuilder().prettyPrint();
+            builder.startObject();
+            toXContent(builder, EMPTY_PARAMS);
+            builder.endObject();
+            return Strings.toString(builder);
+        } catch (IOException e) {
+            return "{ \"error\" : \"" + e.getMessage() + "\"}";
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufPluginsAndModules.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufPluginsAndModules.java
index c1117c4321544..8c9e574170aaa 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufPluginsAndModules.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufPluginsAndModules.java
@@ -13,6 +13,7 @@
 
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.plugins.ProtobufPluginInfo;
 
@@ -74,4 +75,21 @@ public void addPlugin(ProtobufPluginInfo info) {
     public void addModule(ProtobufPluginInfo info) {
         modules.add(info);
     }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startArray("plugins");
+        for (ProtobufPluginInfo pluginInfo : getPluginInfos()) {
+            pluginInfo.toXContent(builder, params);
+        }
+        builder.endArray();
+        // TODO: not ideal, make a better api for this (e.g. with jar metadata, and so on)
+        builder.startArray("modules");
+        for (ProtobufPluginInfo moduleInfo : getModuleInfos()) {
+            moduleInfo.toXContent(builder, params);
+        }
+        builder.endArray();
+
+        return builder;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
index 223520853fafe..e00dd900ffc35 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
@@ -13,11 +13,9 @@
 import org.opensearch.action.ProtobufFailedNodeException;
 import org.opensearch.action.support.ProtobufActionFilters;
 import org.opensearch.action.support.nodes.ProtobufTransportNodesAction;
-import org.opensearch.cluster.ProtobufClusterName;
+import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.inject.Inject;
-import org.opensearch.common.io.stream.StreamInput;
-import org.opensearch.common.io.stream.StreamOutput;
 import org.opensearch.node.ProtobufNodeService;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ProtobufTransportRequest;
@@ -68,7 +66,7 @@ protected ProtobufNodesInfoResponse newResponse(
         List<ProtobufNodeInfo> responses,
         List<ProtobufFailedNodeException> failures
     ) {
-        return new ProtobufNodesInfoResponse(new ProtobufClusterName(clusterService.getClusterName().value()), responses, failures);
+        return new ProtobufNodesInfoResponse(new ClusterName(clusterService.getClusterName().value()), responses, failures);
     }
 
     @Override
@@ -85,20 +83,21 @@ protected ProtobufNodeInfo newNodeResponse(CodedInputStream in) throws IOExcepti
     protected ProtobufNodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
         ProtobufNodesInfoRequest request = nodeRequest.request;
         Set<String> metrics = request.requestedMetrics();
-        return nodeService.info(
-            metrics.contains(NodesInfoRequest.Metric.SETTINGS.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.OS.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.PROCESS.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.JVM.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.THREAD_POOL.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.TRANSPORT.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.HTTP.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.PLUGINS.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.INGEST.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.AGGREGATIONS.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.INDICES.metricName()),
-            metrics.contains(NodesInfoRequest.Metric.SEARCH_PIPELINES.metricName())
+        ProtobufNodeInfo protobufNodeInfo = nodeService.info(
+            metrics.contains(ProtobufNodesInfoRequest.Metric.SETTINGS.metricName()),
+            metrics.contains(ProtobufNodesInfoRequest.Metric.OS.metricName()),
+            metrics.contains(ProtobufNodesInfoRequest.Metric.PROCESS.metricName()),
+            metrics.contains(ProtobufNodesInfoRequest.Metric.JVM.metricName()),
+            metrics.contains(ProtobufNodesInfoRequest.Metric.THREAD_POOL.metricName()),
+            metrics.contains(ProtobufNodesInfoRequest.Metric.TRANSPORT.metricName()),
+            metrics.contains(ProtobufNodesInfoRequest.Metric.HTTP.metricName()),
+            metrics.contains(ProtobufNodesInfoRequest.Metric.PLUGINS.metricName()),
+            metrics.contains(ProtobufNodesInfoRequest.Metric.INGEST.metricName()),
+            metrics.contains(ProtobufNodesInfoRequest.Metric.AGGREGATIONS.metricName()),
+            metrics.contains(ProtobufNodesInfoRequest.Metric.INDICES.metricName()),
+            metrics.contains(ProtobufNodesInfoRequest.Metric.SEARCH_PIPELINES.metricName())
         );
+        return protobufNodeInfo;
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
index 2c4f8522a5a5c..64cd1a887ac12 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
@@ -106,7 +106,7 @@ protected NodeInfo newNodeResponse(StreamInput in) throws IOException {
     protected NodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
         NodesInfoRequest request = nodeRequest.request;
         Set<String> metrics = request.requestedMetrics();
-        return nodeService.info(
+        NodeInfo nodeInfo = nodeService.info(
             metrics.contains(NodesInfoRequest.Metric.SETTINGS.metricName()),
             metrics.contains(NodesInfoRequest.Metric.OS.metricName()),
             metrics.contains(NodesInfoRequest.Metric.PROCESS.metricName()),
@@ -120,6 +120,7 @@ protected NodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
             metrics.contains(NodesInfoRequest.Metric.INDICES.metricName()),
             metrics.contains(NodesInfoRequest.Metric.SEARCH_PIPELINES.metricName())
         );
+        return nodeInfo;
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
index 8a96eb41bb1b7..5c5a13a4e5e65 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
@@ -11,7 +11,7 @@
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
 import org.opensearch.action.support.nodes.ProtobufBaseNodeResponse;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.io.stream.ProtobufStreamInput;
@@ -105,7 +105,7 @@ public ProtobufNodeStats(CodedInputStream in) throws IOException {
     }
 
     public ProtobufNodeStats(
-        ProtobufDiscoveryNode node,
+        DiscoveryNode node,
         long timestamp,
         @Nullable ProtobufNodeIndicesStats indices,
         @Nullable ProtobufOsStats os,
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
index c61deaf87c413..19b7f907932c7 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
@@ -10,7 +10,7 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
-import org.opensearch.action.admin.indices.stats.ProtobufCommonStatsFlags;
+import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
 import org.opensearch.action.support.nodes.ProtobufBaseNodesRequest;
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
@@ -29,7 +29,7 @@
 */
 public class ProtobufNodesStatsRequest extends ProtobufBaseNodesRequest<ProtobufNodesStatsRequest> {
 
-    private ProtobufCommonStatsFlags indices = new ProtobufCommonStatsFlags();
+    private CommonStatsFlags indices = new CommonStatsFlags();
     private final Set<String> requestedMetrics = new HashSet<>();
 
     public ProtobufNodesStatsRequest() {
@@ -39,7 +39,7 @@ public ProtobufNodesStatsRequest() {
     public ProtobufNodesStatsRequest(CodedInputStream in) throws IOException {
         super(in);
 
-        indices = new ProtobufCommonStatsFlags(in);
+        indices = new CommonStatsFlags(in);
         requestedMetrics.clear();
         ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
         requestedMetrics.addAll(protobufStreamInput.readList(CodedInputStream::readString));
@@ -76,7 +76,7 @@ public ProtobufNodesStatsRequest clear() {
     * may not have submetrics.
     * @return flags indicating which indices stats to return
     */
-    public ProtobufCommonStatsFlags indices() {
+    public CommonStatsFlags indices() {
         return indices;
     }
 
@@ -86,7 +86,7 @@ public ProtobufCommonStatsFlags indices() {
     * @param indices flags indicating which indices stats to return
     * @return This object, for request chaining.
     */
-    public ProtobufNodesStatsRequest indices(ProtobufCommonStatsFlags indices) {
+    public ProtobufNodesStatsRequest indices(CommonStatsFlags indices) {
         this.indices = indices;
         return this;
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequestBuilder.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequestBuilder.java
index 3c6d14ad478d5..659a4aa7da185 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequestBuilder.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequestBuilder.java
@@ -8,7 +8,7 @@
 
 package org.opensearch.action.admin.cluster.node.stats;
 
-import org.opensearch.action.admin.indices.stats.ProtobufCommonStatsFlags;
+import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
 import org.opensearch.action.support.nodes.ProtobufNodesOperationRequestBuilder;
 import org.opensearch.client.ProtobufOpenSearchClient;
 
@@ -75,7 +75,7 @@ public ProtobufNodesStatsRequestBuilder setIndices(boolean indices) {
     /**
      * Should the node indices stats be returned.
     */
-    public ProtobufNodesStatsRequestBuilder setIndices(ProtobufCommonStatsFlags indices) {
+    public ProtobufNodesStatsRequestBuilder setIndices(CommonStatsFlags indices) {
         request.indices(indices);
         return this;
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
index 248608203dc79..ef18285256f39 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
@@ -12,7 +12,7 @@
 import com.google.protobuf.CodedOutputStream;
 import org.opensearch.action.ProtobufFailedNodeException;
 import org.opensearch.action.support.nodes.ProtobufBaseNodesResponse;
-import org.opensearch.cluster.ProtobufClusterName;
+import org.opensearch.cluster.ClusterName;
 import org.opensearch.common.Strings;
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
@@ -34,11 +34,7 @@ public ProtobufNodesStatsResponse(CodedInputStream in) throws IOException {
         super(in);
     }
 
-    public ProtobufNodesStatsResponse(
-        ProtobufClusterName clusterName,
-        List<ProtobufNodeStats> nodes,
-        List<ProtobufFailedNodeException> failures
-    ) {
+    public ProtobufNodesStatsResponse(ClusterName clusterName, List<ProtobufNodeStats> nodes, List<ProtobufFailedNodeException> failures) {
         super(clusterName, nodes, failures);
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
index b12bd7ac0a4d1..ed7f8e4002dc0 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
@@ -13,11 +13,9 @@
 import org.opensearch.action.ProtobufFailedNodeException;
 import org.opensearch.action.support.ProtobufActionFilters;
 import org.opensearch.action.support.nodes.ProtobufTransportNodesAction;
-import org.opensearch.cluster.ProtobufClusterName;
+import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.inject.Inject;
-import org.opensearch.common.io.stream.StreamInput;
-import org.opensearch.common.io.stream.StreamOutput;
 import org.opensearch.node.ProtobufNodeService;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ProtobufTransportRequest;
@@ -63,8 +61,12 @@ public ProtobufTransportNodesStatsAction(
     }
 
     @Override
-    protected ProtobufNodesStatsResponse newResponse(ProtobufNodesStatsRequest request, List<ProtobufNodeStats> responses, List<ProtobufFailedNodeException> failures) {
-        return new ProtobufNodesStatsResponse(new ProtobufClusterName(clusterService.getClusterName().value()), responses, failures);
+    protected ProtobufNodesStatsResponse newResponse(
+        ProtobufNodesStatsRequest request,
+        List<ProtobufNodeStats> responses,
+        List<ProtobufFailedNodeException> failures
+    ) {
+        return new ProtobufNodesStatsResponse(new ClusterName(clusterService.getClusterName().value()), responses, failures);
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
index 60892290c94a5..af24e5dc13b2c 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
@@ -17,7 +17,7 @@
 import com.google.protobuf.CodedOutputStream;
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.cluster.ClusterState;
-import org.opensearch.cluster.ProtobufClusterName;
+import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ProtobufClusterState;
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
@@ -31,19 +31,19 @@
 */
 public class ProtobufClusterStateResponse extends ProtobufActionResponse {
 
-    private ProtobufClusterName clusterName;
+    private ClusterName clusterName;
     private ProtobufClusterState clusterState;
     private boolean waitForTimedOut = false;
 
     public ProtobufClusterStateResponse(CodedInputStream in) throws IOException {
         super(in);
         ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        clusterName = new ProtobufClusterName(in);
+        clusterName = new ClusterName(in);
         clusterState = protobufStreamInput.readOptionalWriteable(innerIn -> ProtobufClusterState.readFrom(innerIn, null));
         waitForTimedOut = in.readBool();
     }
 
-    public ProtobufClusterStateResponse(ProtobufClusterName clusterName, ProtobufClusterState clusterState, boolean waitForTimedOut) {
+    public ProtobufClusterStateResponse(ClusterName clusterName, ProtobufClusterState clusterState, boolean waitForTimedOut) {
         this.clusterName = clusterName;
         this.clusterState = clusterState;
         this.waitForTimedOut = waitForTimedOut;
@@ -60,7 +60,7 @@ public ProtobufClusterState getState() {
     /**
      * The name of the cluster.
     */
-    public ProtobufClusterName getClusterName() {
+    public ClusterName getClusterName() {
         return this.clusterName;
     }
 
@@ -79,4 +79,9 @@ public void writeTo(CodedOutputStream out) throws IOException {
         protobufStreamOutput.writeOptionalWriteable(clusterState);
         out.writeBoolNoTag(waitForTimedOut);
     }
+
+    @Override
+    public String toString() {
+        return "ClusterStateResponse{" + "clusterState=" + clusterState + '}';
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
index b8a663c409904..117dd3032331e 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
@@ -26,7 +26,6 @@
 import org.opensearch.cluster.routing.RoutingTable;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.inject.Inject;
-import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.node.NodeClosedException;
 import org.opensearch.threadpool.ThreadPool;
@@ -41,7 +40,9 @@
  *
  * @opensearch.internal
  */
-public class ProtobufTransportClusterStateAction extends ProtobufTransportClusterManagerNodeReadAction<ProtobufClusterStateRequest, ProtobufClusterStateResponse> {
+public class ProtobufTransportClusterStateAction extends ProtobufTransportClusterManagerNodeReadAction<
+    ProtobufClusterStateRequest,
+    ProtobufClusterStateResponse> {
 
     private final Logger logger = LogManager.getLogger(getClass());
 
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/stats/CommonStatsFlags.java b/server/src/main/java/org/opensearch/action/admin/indices/stats/CommonStatsFlags.java
index 502b90417615f..75e660b4b9e3c 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/stats/CommonStatsFlags.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/stats/CommonStatsFlags.java
@@ -37,6 +37,13 @@
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.core.common.Strings;
+import org.opensearch.common.Strings;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
 
 import java.io.IOException;
 import java.util.Collections;
@@ -47,7 +54,7 @@
  *
  * @opensearch.internal
  */
-public class CommonStatsFlags implements Writeable, Cloneable {
+public class CommonStatsFlags implements Writeable, ProtobufWriteable, Cloneable {
 
     public static final CommonStatsFlags ALL = new CommonStatsFlags().all();
     public static final CommonStatsFlags NONE = new CommonStatsFlags().clear();
@@ -111,6 +118,48 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeBoolean(includeOnlyTopIndexingPressureMetrics);
     }
 
+    public CommonStatsFlags(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        final long longFlags = in.readInt64();
+        flags.clear();
+        for (Flag flag : Flag.values()) {
+            if ((longFlags & (1 << flag.getIndex())) != 0) {
+                flags.add(flag);
+            }
+        }
+        if (protobufStreamInput.getVersion().before(Version.V_2_0_0)) {
+            protobufStreamInput.readStringArray();
+        }
+        groups = protobufStreamInput.readStringArray();
+        fieldDataFields = protobufStreamInput.readStringArray();
+        completionDataFields = protobufStreamInput.readStringArray();
+        includeSegmentFileSizes = in.readBool();
+        includeUnloadedSegments = in.readBool();
+        includeAllShardIndexingPressureTrackers = in.readBool();
+        includeOnlyTopIndexingPressureMetrics = in.readBool();
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        long longFlags = 0;
+        for (Flag flag : flags) {
+            longFlags |= (1 << flag.getIndex());
+        }
+        out.writeInt64NoTag(longFlags);
+
+        if (protobufStreamOutput.getVersion().before(Version.V_2_0_0)) {
+            protobufStreamOutput.writeStringArrayNullable(Strings.EMPTY_ARRAY);
+        }
+        protobufStreamOutput.writeStringArrayNullable(groups);
+        protobufStreamOutput.writeStringArrayNullable(fieldDataFields);
+        protobufStreamOutput.writeStringArrayNullable(completionDataFields);
+        out.writeBoolNoTag(includeSegmentFileSizes);
+        out.writeBoolNoTag(includeUnloadedSegments);
+        out.writeBoolNoTag(includeAllShardIndexingPressureTrackers);
+        out.writeBoolNoTag(includeOnlyTopIndexingPressureMetrics);
+    }
+
     /**
      * Sets all flags to return all stats.
      */
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStats.java b/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStats.java
index 89200608328dc..de1331c7f21cb 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStats.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStats.java
@@ -10,6 +10,8 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
+
+import org.apache.lucene.store.AlreadyClosedException;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
@@ -28,11 +30,13 @@
 import org.opensearch.index.recovery.ProtobufRecoveryStats;
 import org.opensearch.index.refresh.ProtobufRefreshStats;
 import org.opensearch.index.search.stats.ProtobufSearchStats;
+import org.opensearch.index.shard.IndexShard;
 import org.opensearch.index.shard.ProtobufDocsStats;
 import org.opensearch.index.shard.ProtobufIndexingStats;
 import org.opensearch.index.store.ProtobufStoreStats;
 import org.opensearch.index.translog.ProtobufTranslogStats;
 import org.opensearch.index.warmer.ProtobufWarmerStats;
+import org.opensearch.indices.IndicesQueryCache;
 import org.opensearch.search.suggest.completion.ProtobufCompletionStats;
 
 import java.io.IOException;
@@ -96,13 +100,13 @@ public class ProtobufCommonStats implements ProtobufWriteable, ToXContentFragmen
     public ProtobufRecoveryStats recoveryStats;
 
     public ProtobufCommonStats() {
-        this(ProtobufCommonStatsFlags.NONE);
+        this(CommonStatsFlags.NONE);
     }
 
-    public ProtobufCommonStats(ProtobufCommonStatsFlags flags) {
-        ProtobufCommonStatsFlags.Flag[] setFlags = flags.getFlags();
+    public ProtobufCommonStats(CommonStatsFlags flags) {
+        CommonStatsFlags.Flag[] setFlags = flags.getFlags();
 
-        for (ProtobufCommonStatsFlags.Flag flag : setFlags) {
+        for (CommonStatsFlags.Flag flag : setFlags) {
             switch (flag) {
                 case Docs:
                     docs = new ProtobufDocsStats();
@@ -158,6 +162,68 @@ public ProtobufCommonStats(ProtobufCommonStatsFlags flags) {
         }
     }
 
+    public ProtobufCommonStats(IndicesQueryCache indicesQueryCache, IndexShard indexShard, CommonStatsFlags flags) {
+        CommonStatsFlags.Flag[] setFlags = flags.getFlags();
+        for (CommonStatsFlags.Flag flag : setFlags) {
+            try {
+                switch (flag) {
+                    case Docs:
+                        docs = indexShard.protobufDocsStats();
+                        break;
+                    case Store:
+                        store = indexShard.protobufStoreStats();
+                        break;
+                    case Indexing:
+                        indexing = indexShard.protobufIndexingStats();
+                        break;
+                    case Get:
+                        get = indexShard.getProtobufStats();
+                        break;
+                    case Search:
+                        search = indexShard.protobufSearchStats(flags.groups());
+                        break;
+                    case Merge:
+                        merge = indexShard.protobufMergeStats();
+                        break;
+                    case Refresh:
+                        refresh = indexShard.protobufRefreshStats();
+                        break;
+                    case Flush:
+                        flush = indexShard.protobufFlushStats();
+                        break;
+                    case Warmer:
+                        warmer = indexShard.protobufWarmerStats();
+                        break;
+                    case QueryCache:
+                        queryCache = indicesQueryCache.getProtobufStats(indexShard.shardId());
+                        break;
+                    case FieldData:
+                        fieldData = indexShard.protobufFieldDataStats(flags.fieldDataFields());
+                        break;
+                    // case Completion:
+                    // completion = indexShard.completionStats(flags.completionDataFields());
+                    // break;
+                    case Segments:
+                        segments = indexShard.protobufSegmentStats(flags.includeSegmentFileSizes(), flags.includeUnloadedSegments());
+                        break;
+                    // case Translog:
+                    // translog = indexShard.translogStats();
+                    // break;
+                    case RequestCache:
+                        requestCache = indexShard.requestCache().protobufStats();
+                        break;
+                    case Recovery:
+                        recoveryStats = indexShard.protobufRecoveryStats();
+                        break;
+                    default:
+                        throw new IllegalStateException("Unknown Flag: " + flag);
+                }
+            } catch (AlreadyClosedException e) {
+                // shard is closed - no stats is fine
+            }
+        }
+    }
+
     public ProtobufCommonStats(CodedInputStream in) throws IOException {
         ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
         docs = protobufStreamInput.readOptionalWriteable(ProtobufDocsStats::new);
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufIndexShardStats.java b/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufIndexShardStats.java
new file mode 100644
index 0000000000000..849061e865d71
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufIndexShardStats.java
@@ -0,0 +1,98 @@
+/*
+ * 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.
+ */
+
+package org.opensearch.action.admin.indices.stats;
+
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.index.shard.ShardId;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Iterator;
+
+/**
+ * ProtobufIndexShardStats for OpenSearch
+ *
+ * @opensearch.internal
+ */
+public class ProtobufIndexShardStats implements Iterable<ProtobufShardStats>, ProtobufWriteable {
+
+    private final ShardId shardId;
+
+    private final ProtobufShardStats[] shards;
+
+    public ProtobufIndexShardStats(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        shardId = new ShardId(in);
+        shards = protobufStreamInput.readArray(ProtobufShardStats::new, ProtobufShardStats[]::new);
+    }
+
+    public ProtobufIndexShardStats(ShardId shardId, ProtobufShardStats[] shards) {
+        this.shardId = shardId;
+        this.shards = shards;
+    }
+
+    public ShardId getShardId() {
+        return this.shardId;
+    }
+
+    public ProtobufShardStats[] getShards() {
+        return shards;
+    }
+
+    public ProtobufShardStats getAt(int position) {
+        return shards[position];
+    }
+
+    @Override
+    public Iterator<ProtobufShardStats> iterator() {
+        return Arrays.stream(shards).iterator();
+    }
+
+    private ProtobufCommonStats total = null;
+
+    public ProtobufCommonStats getTotal() {
+        if (total != null) {
+            return total;
+        }
+        ProtobufCommonStats stats = new ProtobufCommonStats();
+        for (ProtobufShardStats shard : shards) {
+            stats.add(shard.getStats());
+        }
+        total = stats;
+        return stats;
+    }
+
+    private ProtobufCommonStats primary = null;
+
+    public ProtobufCommonStats getPrimary() {
+        if (primary != null) {
+            return primary;
+        }
+        ProtobufCommonStats stats = new ProtobufCommonStats();
+        for (ProtobufShardStats shard : shards) {
+            if (shard.getShardRouting().primary()) {
+                stats.add(shard.getStats());
+            }
+        }
+        primary = stats;
+        return stats;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        shardId.writeTo(out);
+        protobufStreamOutput.writeArray((o, v) -> v.writeTo(o), shards);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufShardStats.java b/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufShardStats.java
new file mode 100644
index 0000000000000..514c4195f1b1d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufShardStats.java
@@ -0,0 +1,178 @@
+/*
+ * 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.
+ */
+
+package org.opensearch.action.admin.indices.stats;
+
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.engine.CommitStats;
+import org.opensearch.index.seqno.RetentionLeaseStats;
+import org.opensearch.index.seqno.SeqNoStats;
+import org.opensearch.index.shard.ShardPath;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
+import java.io.IOException;
+
+/**
+ * Shard Stats for OpenSearch
+ *
+ * @opensearch.internal
+ */
+public class ProtobufShardStats implements ProtobufWriteable, ToXContentFragment {
+
+    private ShardRouting shardRouting;
+    private ProtobufCommonStats commonStats;
+    @Nullable
+    private CommitStats commitStats;
+    @Nullable
+    private SeqNoStats seqNoStats;
+
+    @Nullable
+    private RetentionLeaseStats retentionLeaseStats;
+
+    /**
+     * Gets the current retention lease stats.
+     *
+     * @return the current retention lease stats
+     */
+    public RetentionLeaseStats getRetentionLeaseStats() {
+        return retentionLeaseStats;
+    }
+
+    private String dataPath;
+    private String statePath;
+    private boolean isCustomDataPath;
+
+    public ProtobufShardStats(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        shardRouting = new ShardRouting(in);
+        commonStats = new ProtobufCommonStats(in);
+        commitStats = CommitStats.readOptionalCommitStatsFromProtobuf(in);
+        statePath = in.readString();
+        dataPath = in.readString();
+        isCustomDataPath = in.readBool();
+        seqNoStats = protobufStreamInput.readOptionalWriteable(SeqNoStats::new);
+        retentionLeaseStats = protobufStreamInput.readOptionalWriteable(RetentionLeaseStats::new);
+    }
+
+    public ProtobufShardStats(
+        final ShardRouting routing,
+        final ShardPath shardPath,
+        final ProtobufCommonStats commonStats,
+        final CommitStats commitStats,
+        final SeqNoStats seqNoStats,
+        final RetentionLeaseStats retentionLeaseStats
+    ) {
+        this.shardRouting = routing;
+        this.dataPath = shardPath.getRootDataPath().toString();
+        this.statePath = shardPath.getRootStatePath().toString();
+        this.isCustomDataPath = shardPath.isCustomDataPath();
+        this.commitStats = commitStats;
+        this.commonStats = commonStats;
+        this.seqNoStats = seqNoStats;
+        this.retentionLeaseStats = retentionLeaseStats;
+    }
+
+    /**
+     * The shard routing information (cluster wide shard state).
+     */
+    public ShardRouting getShardRouting() {
+        return this.shardRouting;
+    }
+
+    public ProtobufCommonStats getStats() {
+        return this.commonStats;
+    }
+
+    @Nullable
+    public CommitStats getCommitStats() {
+        return this.commitStats;
+    }
+
+    @Nullable
+    public SeqNoStats getSeqNoStats() {
+        return this.seqNoStats;
+    }
+
+    public String getDataPath() {
+        return dataPath;
+    }
+
+    public String getStatePath() {
+        return statePath;
+    }
+
+    public boolean isCustomDataPath() {
+        return isCustomDataPath;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        shardRouting.writeTo(out);
+        commonStats.writeTo(out);
+        protobufStreamOutput.writeOptionalWriteable(commitStats);
+        out.writeStringNoTag(statePath);
+        out.writeStringNoTag(dataPath);
+        out.writeBoolNoTag(isCustomDataPath);
+        protobufStreamOutput.writeOptionalWriteable(seqNoStats);
+        protobufStreamOutput.writeOptionalWriteable(retentionLeaseStats);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.ROUTING)
+            .field(Fields.STATE, shardRouting.state())
+            .field(Fields.PRIMARY, shardRouting.primary())
+            .field(Fields.NODE, shardRouting.currentNodeId())
+            .field(Fields.RELOCATING_NODE, shardRouting.relocatingNodeId())
+            .endObject();
+
+        commonStats.toXContent(builder, params);
+        if (commitStats != null) {
+            commitStats.toXContent(builder, params);
+        }
+        if (seqNoStats != null) {
+            seqNoStats.toXContent(builder, params);
+        }
+        if (retentionLeaseStats != null) {
+            retentionLeaseStats.toXContent(builder, params);
+        }
+        builder.startObject(Fields.SHARD_PATH);
+        builder.field(Fields.STATE_PATH, statePath);
+        builder.field(Fields.DATA_PATH, dataPath);
+        builder.field(Fields.IS_CUSTOM_DATA_PATH, isCustomDataPath);
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * Fields for parsing and toXContent
+     *
+     * @opensearch.internal
+     */
+    static final class Fields {
+        static final String ROUTING = "routing";
+        static final String STATE = "state";
+        static final String STATE_PATH = "state_path";
+        static final String DATA_PATH = "data_path";
+        static final String IS_CUSTOM_DATA_PATH = "is_custom_data_path";
+        static final String SHARD_PATH = "shard_path";
+        static final String PRIMARY = "primary";
+        static final String NODE = "node";
+        static final String RELOCATING_NODE = "relocating_node";
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/action/main/ProtobufMainRequest.java b/server/src/main/java/org/opensearch/action/main/ProtobufMainRequest.java
index 3fb3e35d679f0..b352a5c3ae55d 100644
--- a/server/src/main/java/org/opensearch/action/main/ProtobufMainRequest.java
+++ b/server/src/main/java/org/opensearch/action/main/ProtobufMainRequest.java
@@ -11,7 +11,6 @@
 import com.google.protobuf.CodedInputStream;
 import org.opensearch.action.ProtobufActionRequest;
 import org.opensearch.action.ActionRequestValidationException;
-import org.opensearch.common.io.stream.StreamInput;
 
 import java.io.IOException;
 
diff --git a/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java b/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java
index 36963fd5894f5..fb5359f370620 100644
--- a/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java
+++ b/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java
@@ -13,10 +13,8 @@
 import org.opensearch.Build;
 import org.opensearch.Version;
 import org.opensearch.action.ProtobufActionResponse;
-import org.opensearch.cluster.ProtobufClusterName;
+import org.opensearch.cluster.ClusterName;
 import org.opensearch.core.ParseField;
-import org.opensearch.common.io.stream.StreamInput;
-import org.opensearch.common.io.stream.StreamOutput;
 import org.opensearch.core.xcontent.ObjectParser;
 import org.opensearch.core.xcontent.ToXContentObject;
 import org.opensearch.core.xcontent.XContentBuilder;
@@ -34,7 +32,7 @@ public class ProtobufMainResponse extends ProtobufActionResponse implements ToXC
 
     private String nodeName;
     private Version version;
-    private ProtobufClusterName clusterName;
+    private ClusterName clusterName;
     private String clusterUuid;
     private Build build;
     public static final String TAGLINE = "The OpenSearch Project: https://opensearch.org/";
@@ -45,12 +43,12 @@ public class ProtobufMainResponse extends ProtobufActionResponse implements ToXC
         super(in);
         nodeName = in.readString();
         version = Version.readVersionProtobuf(in);
-        clusterName = new ProtobufClusterName(in);
+        clusterName = new ClusterName(in);
         clusterUuid = in.readString();
         build = Build.readBuildProtobuf(in);
     }
 
-    public ProtobufMainResponse(String nodeName, Version version, ProtobufClusterName clusterName, String clusterUuid, Build build) {
+    public ProtobufMainResponse(String nodeName, Version version, ClusterName clusterName, String clusterUuid, Build build) {
         this.nodeName = nodeName;
         this.version = version;
         this.clusterName = clusterName;
@@ -66,7 +64,7 @@ public Version getVersion() {
         return version;
     }
 
-    public ProtobufClusterName getClusterName() {
+    public ClusterName getClusterName() {
         return clusterName;
     }
 
@@ -117,7 +115,7 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
 
     static {
         PARSER.declareString((response, value) -> response.nodeName = value, new ParseField("name"));
-        PARSER.declareString((response, value) -> response.clusterName = new ProtobufClusterName(value), new ParseField("cluster_name"));
+        PARSER.declareString((response, value) -> response.clusterName = new ClusterName(value), new ParseField("cluster_name"));
         PARSER.declareString((response, value) -> response.clusterUuid = value, new ParseField("cluster_uuid"));
         PARSER.declareString((response, value) -> {}, new ParseField("tagline"));
         PARSER.declareObject((response, value) -> {
diff --git a/server/src/main/java/org/opensearch/action/main/ProtobufTransportMainAction.java b/server/src/main/java/org/opensearch/action/main/ProtobufTransportMainAction.java
index d5f91651d2fb0..0385dedaaeab3 100644
--- a/server/src/main/java/org/opensearch/action/main/ProtobufTransportMainAction.java
+++ b/server/src/main/java/org/opensearch/action/main/ProtobufTransportMainAction.java
@@ -14,8 +14,7 @@
 import org.opensearch.action.support.ProtobufActionFilters;
 import org.opensearch.action.support.ProtobufHandledTransportAction;
 import org.opensearch.cluster.ClusterState;
-import org.opensearch.cluster.ProtobufClusterName;
-import org.opensearch.cluster.ProtobufClusterState;
+import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.inject.Inject;
 import org.opensearch.common.settings.Settings;
@@ -48,7 +47,7 @@ public ProtobufTransportMainAction(
     @Override
     protected void doExecute(ProtobufTask task, ProtobufMainRequest request, ActionListener<ProtobufMainResponse> listener) {
         ClusterState clusterState = clusterService.state();
-        ProtobufClusterName clusterName = new ProtobufClusterName(clusterState.getClusterName().value());
+        ClusterName clusterName = new ClusterName(clusterState.getClusterName().value());
         listener.onResponse(
             new ProtobufMainResponse(nodeName, Version.CURRENT, clusterName, clusterState.metadata().clusterUUID(), Build.CURRENT)
         );
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java b/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
index 5d85e62ea9def..cf054e8e9ece9 100644
--- a/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
@@ -22,9 +22,8 @@
 *
 * @opensearch.internal
 */
-public abstract class ProtobufHandledTransportAction<Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> extends ProtobufTransportAction<
-    Request,
-    Response> {
+public abstract class ProtobufHandledTransportAction<Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> extends
+    ProtobufTransportAction<Request, Response> {
 
     protected ProtobufHandledTransportAction(
         String actionName,
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
index 5b2e3b4d927d0..55c915522b404 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
@@ -28,12 +28,12 @@
 import org.opensearch.cluster.coordination.FailedToCommitClusterStateException;
 import org.opensearch.cluster.metadata.ProtobufIndexNameExpressionResolver;
 import org.opensearch.cluster.metadata.ProcessClusterEventTimeoutException;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
 import org.opensearch.cluster.service.ClusterManagerTaskThrottler;
 import org.opensearch.cluster.service.ClusterManagerThrottlingException;
 import org.opensearch.cluster.service.ClusterService;
-import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.discovery.ClusterManagerNotDiscoveredException;
@@ -53,8 +53,9 @@
  *
  * @opensearch.internal
  */
-public abstract class ProtobufTransportClusterManagerNodeAction<Request extends ProtobufClusterManagerNodeRequest<Request>, Response extends ProtobufActionResponse>
-    extends ProtobufHandledTransportAction<Request, Response> {
+public abstract class ProtobufTransportClusterManagerNodeAction<
+    Request extends ProtobufClusterManagerNodeRequest<Request>,
+    Response extends ProtobufActionResponse> extends ProtobufHandledTransportAction<Request, Response> {
 
     private static final Logger logger = LogManager.getLogger(ProtobufTransportClusterManagerNodeAction.class);
 
@@ -108,7 +109,8 @@ protected void masterOperation(Request request, ProtobufClusterState state, Acti
     }
 
     // TODO: Add abstract keyword after removing the deprecated masterOperation()
-    protected void clusterManagerOperation(Request request, ProtobufClusterState state, ActionListener<Response> listener) throws Exception {
+    protected void clusterManagerOperation(Request request, ProtobufClusterState state, ActionListener<Response> listener)
+        throws Exception {
         masterOperation(request, state, listener);
     }
 
@@ -117,7 +119,8 @@ protected void clusterManagerOperation(Request request, ProtobufClusterState sta
      * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #clusterManagerOperation(ProtobufTask, ProtobufClusterManagerNodeRequest, ProtobufClusterState, ActionListener)}
      */
     @Deprecated
-    protected void masterOperation(ProtobufTask task, Request request, ProtobufClusterState state, ActionListener<Response> listener) throws Exception {
+    protected void masterOperation(ProtobufTask task, Request request, ProtobufClusterState state, ActionListener<Response> listener)
+        throws Exception {
         clusterManagerOperation(request, state, listener);
     }
 
@@ -125,8 +128,12 @@ protected void masterOperation(ProtobufTask task, Request request, ProtobufClust
      * Override this operation if access to the task parameter is needed
      */
     // TODO: Change the implementation to call 'clusterManagerOperation(request...)' after removing the deprecated masterOperation()
-    protected void clusterManagerOperation(ProtobufTask task, Request request, ProtobufClusterState state, ActionListener<Response> listener)
-        throws Exception {
+    protected void clusterManagerOperation(
+        ProtobufTask task,
+        Request request,
+        ProtobufClusterState state,
+        ActionListener<Response> listener
+    ) throws Exception {
         masterOperation(task, request, state, listener);
     }
 
@@ -209,7 +216,8 @@ public Exception getTimeoutException(Exception e) {
         protected void doStart(ProtobufClusterState clusterState) {
             try {
                 final ProtobufDiscoveryNodes nodes = clusterState.nodes();
-                if (nodes.isLocalNodeElectedClusterManager() || localExecute(request)) {
+                final DiscoveryNodes discoveryNodes = clusterService.state().nodes();
+                if (discoveryNodes.isLocalNodeElectedClusterManager() || localExecute(request)) {
                     // check for block, if blocked, retry, else, execute locally
                     final ClusterBlockException blockException = checkBlock(request, clusterState);
                     if (blockException != null) {
@@ -252,13 +260,16 @@ protected void doStart(ProtobufClusterState clusterState) {
                         logger.debug("no known cluster-manager node, scheduling a retry");
                         retryOnMasterChange(clusterState, null);
                     } else {
-                        ProtobufDiscoveryNode clusterManagerNode = nodes.getClusterManagerNode();
+                        DiscoveryNode clusterManagerNode = nodes.getClusterManagerNode();
                         final String actionName = getClusterManagerActionName(clusterManagerNode);
                         transportService.sendRequest(
                             clusterManagerNode,
                             actionName,
                             request,
-                            new ProtobufActionListenerResponseHandler<Response>(listener, ProtobufTransportClusterManagerNodeAction.this::read) {
+                            new ProtobufActionListenerResponseHandler<Response>(
+                                listener,
+                                ProtobufTransportClusterManagerNodeAction.this::read
+                            ) {
                                 @Override
                                 public void handleException(final ProtobufTransportException exp) {
                                     Throwable cause = exp.unwrapCause();
@@ -334,7 +345,7 @@ public void onTimeout(TimeValue timeout) {
      * Allows to conditionally return a different cluster-manager node action name in the case an action gets renamed.
      * This mainly for backwards compatibility should be used rarely
      */
-    protected String getClusterManagerActionName(ProtobufDiscoveryNode node) {
+    protected String getClusterManagerActionName(DiscoveryNode node) {
         return actionName;
     }
 
@@ -342,10 +353,10 @@ protected String getClusterManagerActionName(ProtobufDiscoveryNode node) {
      * Allows to conditionally return a different cluster-manager node action name in the case an action gets renamed.
      * This mainly for backwards compatibility should be used rarely
      *
-     * @deprecated As of 2.1, because supporting inclusive language, replaced by {@link #getClusterManagerActionName(ProtobufDiscoveryNode)}
+     * @deprecated As of 2.1, because supporting inclusive language, replaced by {@link #getClusterManagerActionName(DiscoveryNode)}
      */
     @Deprecated
-    protected String getMasterActionName(ProtobufDiscoveryNode node) {
+    protected String getMasterActionName(DiscoveryNode node) {
         return getClusterManagerActionName(node);
     }
 
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
index 5b8f96cbcd083..fb121e23a7953 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
@@ -15,7 +15,7 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.transport.ProtobufTransportResponse;
 
 import java.io.IOException;
@@ -27,14 +27,14 @@
 */
 public abstract class ProtobufBaseNodeResponse extends ProtobufTransportResponse {
 
-    private ProtobufDiscoveryNode node;
+    private DiscoveryNode node;
 
     protected ProtobufBaseNodeResponse(CodedInputStream in) throws IOException {
         super(in);
-        node = new ProtobufDiscoveryNode(in);
+        node = new DiscoveryNode(in);
     }
 
-    protected ProtobufBaseNodeResponse(ProtobufDiscoveryNode node) {
+    protected ProtobufBaseNodeResponse(DiscoveryNode node) {
         assert node != null;
         this.node = node;
     }
@@ -42,7 +42,7 @@ protected ProtobufBaseNodeResponse(ProtobufDiscoveryNode node) {
     /**
      * The node this information relates to.
     */
-    public ProtobufDiscoveryNode getNode() {
+    public DiscoveryNode getNode() {
         return node;
     }
 
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
index 3cdb26be01c1e..490c1a8ecf862 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
@@ -18,7 +18,7 @@
 import org.opensearch.action.ActionRequestValidationException;
 import org.opensearch.action.ProtobufActionRequest;
 import org.opensearch.cluster.node.DiscoveryNodes;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.unit.TimeValue;
@@ -47,7 +47,7 @@ public abstract class ProtobufBaseNodesRequest<Request extends ProtobufBaseNodes
      * once {@link #nodesIds} are resolved this will contain the concrete nodes that are part of this request. If set, {@link #nodesIds}
     * will be ignored and this will be used.
     * */
-    private ProtobufDiscoveryNode[] concreteNodes;
+    private DiscoveryNode[] concreteNodes;
     private final TimeValue DEFAULT_TIMEOUT_SECS = TimeValue.timeValueSeconds(30);
 
     private TimeValue timeout;
@@ -56,7 +56,7 @@ protected ProtobufBaseNodesRequest(CodedInputStream in) throws IOException {
         super(in);
         ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
         nodesIds = protobufStreamInput.readStringArray();
-        concreteNodes = protobufStreamInput.readOptionalArray(ProtobufDiscoveryNode::new, ProtobufDiscoveryNode[]::new);
+        concreteNodes = protobufStreamInput.readOptionalArray(DiscoveryNode::new, DiscoveryNode[]::new);
         timeout = protobufStreamInput.readOptionalTimeValue();
     }
 
@@ -64,7 +64,7 @@ protected ProtobufBaseNodesRequest(String... nodesIds) {
         this.nodesIds = nodesIds;
     }
 
-    protected ProtobufBaseNodesRequest(ProtobufDiscoveryNode... concreteNodes) {
+    protected ProtobufBaseNodesRequest(DiscoveryNode... concreteNodes) {
         this.nodesIds = null;
         this.concreteNodes = concreteNodes;
     }
@@ -95,11 +95,11 @@ public final Request timeout(String timeout) {
         return (Request) this;
     }
 
-    public ProtobufDiscoveryNode[] concreteNodes() {
+    public DiscoveryNode[] concreteNodes() {
         return concreteNodes;
     }
 
-    public void setConcreteNodes(ProtobufDiscoveryNode[] concreteNodes) {
+    public void setConcreteNodes(DiscoveryNode[] concreteNodes) {
         this.concreteNodes = concreteNodes;
     }
 
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java
index e51aa2e27251f..478a010816b1c 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java
@@ -17,7 +17,7 @@
 import com.google.protobuf.CodedOutputStream;
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.action.ProtobufFailedNodeException;
-import org.opensearch.cluster.ProtobufClusterName;
+import org.opensearch.cluster.ClusterName;
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
 
@@ -34,7 +34,7 @@
 */
 public abstract class ProtobufBaseNodesResponse<TNodeResponse extends ProtobufBaseNodeResponse> extends ProtobufActionResponse {
 
-    private ProtobufClusterName clusterName;
+    private ClusterName clusterName;
     private List<ProtobufFailedNodeException> failures;
     private List<TNodeResponse> nodes;
     private Map<String, TNodeResponse> nodesMap;
@@ -42,27 +42,23 @@ public abstract class ProtobufBaseNodesResponse<TNodeResponse extends ProtobufBa
     protected ProtobufBaseNodesResponse(CodedInputStream in) throws IOException {
         super(in);
         ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        clusterName = new ProtobufClusterName(in);
+        clusterName = new ClusterName(in);
         nodes = readNodesFrom(in);
         failures = protobufStreamInput.readList(ProtobufFailedNodeException::new);
     }
 
-    protected ProtobufBaseNodesResponse(
-        ProtobufClusterName clusterName,
-        List<TNodeResponse> nodes,
-        List<ProtobufFailedNodeException> failures
-    ) {
+    protected ProtobufBaseNodesResponse(ClusterName clusterName, List<TNodeResponse> nodes, List<ProtobufFailedNodeException> failures) {
         this.clusterName = Objects.requireNonNull(clusterName);
         this.failures = Objects.requireNonNull(failures);
         this.nodes = Objects.requireNonNull(nodes);
     }
 
     /**
-     * Get the {@link ProtobufClusterName} associated with all of the nodes.
+     * Get the {@link ClusterName} associated with all of the nodes.
     *
     * @return Never {@code null}.
     */
-    public ProtobufClusterName getClusterName() {
+    public ClusterName getClusterName() {
         return clusterName;
     }
 
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
index 4b805811f49c2..59e66c10473aa 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
@@ -16,9 +16,8 @@
 import org.opensearch.action.support.ProtobufActionFilters;
 import org.opensearch.action.support.ProtobufHandledTransportAction;
 import org.opensearch.cluster.ClusterState;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.service.ClusterService;
-import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.tasks.ProtobufTask;
 import org.opensearch.threadpool.ThreadPool;
@@ -165,7 +164,11 @@ protected NodesResponse newResponse(NodesRequest request, AtomicReferenceArray<?
     * @return Never {@code null}.
     * @throws NullPointerException if any parameter is {@code null}.
     */
-    protected abstract NodesResponse newResponse(NodesRequest request, List<NodeResponse> responses, List<ProtobufFailedNodeException> failures);
+    protected abstract NodesResponse newResponse(
+        NodesRequest request,
+        List<NodeResponse> responses,
+        List<ProtobufFailedNodeException> failures
+    );
 
     protected abstract NodeRequest newNodeRequest(NodesRequest request);
 
@@ -183,13 +186,13 @@ protected NodeResponse nodeOperation(NodeRequest request, ProtobufTask task) {
     protected void resolveRequest(NodesRequest request, ClusterState clusterState) {
         assert request.concreteNodes() == null : "request concreteNodes shouldn't be set";
         String[] nodesIds = clusterState.nodes().resolveNodes(request.nodesIds());
-        request.setConcreteNodes(Arrays.stream(nodesIds).map(clusterState.nodes()::get).toArray(ProtobufDiscoveryNode[]::new));
+        request.setConcreteNodes(Arrays.stream(nodesIds).map(clusterState.nodes()::get).toArray(DiscoveryNode[]::new));
     }
 
     /**
      * Get a backwards compatible transport action name
     */
-    protected String getTransportNodeAction(ProtobufDiscoveryNode node) {
+    protected String getTransportNodeAction(DiscoveryNode node) {
         return transportNodeAction;
     }
 
@@ -218,7 +221,7 @@ class AsyncAction {
         }
 
         void start() {
-            final ProtobufDiscoveryNode[] nodes = request.concreteNodes();
+            final DiscoveryNode[] nodes = request.concreteNodes();
             if (nodes.length == 0) {
                 // nothing to notify
                 threadPool.generic().execute(() -> listener.onResponse(newResponse(request, responses)));
@@ -230,7 +233,7 @@ void start() {
             }
             for (int i = 0; i < nodes.length; i++) {
                 final int idx = i;
-                final ProtobufDiscoveryNode node = nodes[i];
+                final DiscoveryNode node = nodes[i];
                 final String nodeId = node.getId();
                 try {
                     ProtobufTransportRequest nodeRequest = newNodeRequest(request);
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterManagerNodeChangePredicate.java b/server/src/main/java/org/opensearch/cluster/ClusterManagerNodeChangePredicate.java
index 13127640beb4f..36efc16f00930 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterManagerNodeChangePredicate.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterManagerNodeChangePredicate.java
@@ -33,7 +33,7 @@
 package org.opensearch.cluster;
 
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 
 import java.util.function.Predicate;
 
@@ -76,10 +76,10 @@ public static Predicate<ClusterState> build(ClusterState currentState) {
      */
     public static Predicate<ProtobufClusterState> buildProtobuf(ProtobufClusterState currentState) {
         final long currentVersion = currentState.version();
-        final ProtobufDiscoveryNode clusterManagerNode = currentState.nodes().getClusterManagerNode();
+        final DiscoveryNode clusterManagerNode = currentState.nodes().getClusterManagerNode();
         final String currentMasterId = clusterManagerNode == null ? null : clusterManagerNode.getEphemeralId();
         return newState -> {
-            final ProtobufDiscoveryNode newClusterManager = newState.nodes().getClusterManagerNode();
+            final DiscoveryNode newClusterManager = newState.nodes().getClusterManagerNode();
             final boolean accept;
             if (newClusterManager == null) {
                 accept = false;
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterName.java b/server/src/main/java/org/opensearch/cluster/ClusterName.java
index 440fde284afb8..b74a393bdd658 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterName.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterName.java
@@ -32,12 +32,16 @@
 
 package org.opensearch.cluster;
 
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.Objects;
 import java.util.function.Predicate;
@@ -47,7 +51,7 @@
  *
  * @opensearch.internal
  */
-public class ClusterName implements Writeable {
+public class ClusterName implements Writeable, ProtobufWriteable {
 
     public static final Setting<ClusterName> CLUSTER_NAME_SETTING = new Setting<>("cluster.name", "opensearch", (s) -> {
         if (s.isEmpty()) {
@@ -67,6 +71,10 @@ public ClusterName(StreamInput input) throws IOException {
         this(input.readString());
     }
 
+    public ClusterName(CodedInputStream input) throws IOException {
+        this(input.readString());
+    }
+
     public ClusterName(String value) {
         this.value = value.intern();
     }
@@ -80,6 +88,11 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeString(value);
     }
 
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeStringNoTag(value);
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterState.java b/server/src/main/java/org/opensearch/cluster/ClusterState.java
index bf4d7977222ab..e7c552dfdee60 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterState.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterState.java
@@ -32,6 +32,7 @@
 
 package org.opensearch.cluster;
 
+
 import org.opensearch.cluster.block.ClusterBlock;
 import org.opensearch.cluster.block.ClusterBlocks;
 import org.opensearch.cluster.coordination.CoordinationMetadata;
@@ -770,6 +771,25 @@ public static ClusterState readFrom(StreamInput in, DiscoveryNode localNode) thr
         return builder.build();
     }
 
+    // public static ClusterState readFrom(CodedInputStream in, DiscoveryNode localNode) throws IOException {
+    // ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+    // ClusterName clusterName = new ClusterName(in);
+    // Builder builder = new Builder(clusterName);
+    // builder.version = in.readInt64();
+    // builder.uuid = in.readString();
+    // builder.metadata = Metadata.readFrom(in);
+    // builder.routingTable = RoutingTable.readFrom(in);
+    // builder.nodes = ProtobufDiscoveryNodes.readFrom(in, localNode);
+    // builder.blocks = ClusterBlocks.readFrom(in);
+    // int customSize = in.readInt32();
+    // for (int i = 0; i < customSize; i++) {
+    // Custom customIndexMetadata = protobufStreamInput.readNamedWriteable(Custom.class);
+    // builder.putCustom(customIndexMetadata.getWriteableName(), customIndexMetadata);
+    // }
+    // builder.minimumClusterManagerNodesOnPublishingClusterManager = in.readInt32();
+    // return builder.build();
+    // }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         clusterName.writeTo(out);
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterName.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterName.java
deleted file mode 100644
index a7980d7cbd3ed..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/ProtobufClusterName.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
-* 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.
-*/
-
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
-package org.opensearch.cluster;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.settings.Setting;
-import org.opensearch.common.settings.Settings;
-
-import java.io.IOException;
-import java.util.function.Predicate;
-
-/**
- * Cluster Name
-*
-* @opensearch.internal
-*/
-public class ProtobufClusterName implements ProtobufWriteable {
-
-    public static final Setting<ProtobufClusterName> CLUSTER_NAME_SETTING = new Setting<>("cluster.name", "opensearch", (s) -> {
-        if (s.isEmpty()) {
-            throw new IllegalArgumentException("[cluster.name] must not be empty");
-        }
-        if (s.contains(":")) {
-            throw new IllegalArgumentException("[cluster.name] must not contain ':'");
-        }
-        return new ProtobufClusterName(s);
-    }, Setting.Property.NodeScope);
-
-    public static final ProtobufClusterName DEFAULT = CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY);
-
-    private final String value;
-
-    public ProtobufClusterName(CodedInputStream input) throws IOException {
-        this(input.readString());
-    }
-
-    public ProtobufClusterName(String value) {
-        this.value = value.intern();
-    }
-
-    public String value() {
-        return this.value;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeStringNoTag(value);
-    }
-
-    public Predicate<ProtobufClusterName> getEqualityPredicate() {
-        return new Predicate<ProtobufClusterName>() {
-            @Override
-            public boolean test(ProtobufClusterName o) {
-                return ProtobufClusterName.this.equals(o);
-            }
-
-            @Override
-            public String toString() {
-                return "local cluster name [" + ProtobufClusterName.this.value() + "]";
-            }
-        };
-    }
-}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java
index 5973eab393121..d1faa196a8dd3 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java
@@ -22,9 +22,10 @@
 import org.opensearch.cluster.coordination.CoordinationMetadata;
 import org.opensearch.cluster.coordination.CoordinationMetadata.VotingConfigExclusion;
 import org.opensearch.cluster.coordination.CoordinationMetadata.VotingConfiguration;
+import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
 import org.opensearch.cluster.routing.IndexRoutingTable;
 import org.opensearch.cluster.routing.IndexShardRoutingTable;
@@ -80,8 +81,7 @@
 */
 public class ProtobufClusterState implements ToXContentFragment, ProtobufDiffable<ProtobufClusterState> {
 
-    public static final ProtobufClusterState EMPTY_STATE = builder(ProtobufClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
-        .build();
+    public static final ProtobufClusterState EMPTY_STATE = builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).build();
 
     /**
      * An interface that implementors use when a class requires a client to maybe have a feature.
@@ -159,7 +159,7 @@ default boolean isPrivate() {
 
     private final ImmutableOpenMap<String, Custom> customs;
 
-    private final ProtobufClusterName clusterName;
+    private final ClusterName clusterName;
 
     private final boolean wasReadFromDiff;
 
@@ -184,7 +184,7 @@ public ProtobufClusterState(long version, String stateUUID, ProtobufClusterState
     }
 
     public ProtobufClusterState(
-        ProtobufClusterName clusterName,
+        ClusterName clusterName,
         long version,
         String stateUUID,
         Metadata metadata,
@@ -287,7 +287,7 @@ public <T extends Custom> T custom(String type, T defaultValue) {
         return (T) customs.getOrDefault(type, defaultValue);
     }
 
-    public ProtobufClusterName getClusterName() {
+    public ClusterName getClusterName() {
         return this.clusterName;
     }
 
@@ -426,7 +426,7 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         // nodes
         if (metrics.contains(Metric.NODES)) {
             builder.startObject("nodes");
-            for (ProtobufDiscoveryNode node : nodes) {
+            for (DiscoveryNode node : nodes) {
                 node.toXContent(builder, params);
             }
             builder.endObject();
@@ -490,7 +490,7 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         return builder;
     }
 
-    public static Builder builder(ProtobufClusterName clusterName) {
+    public static Builder builder(ClusterName clusterName) {
         return new Builder(clusterName);
     }
 
@@ -498,6 +498,74 @@ public static Builder builder(ProtobufClusterState state) {
         return new Builder(state);
     }
 
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        final String TAB = "   ";
+        sb.append("cluster uuid: ")
+            .append(metadata.clusterUUID())
+            .append(" [committed: ")
+            .append(metadata.clusterUUIDCommitted())
+            .append("]")
+            .append("\n");
+        sb.append("version: ").append(version).append("\n");
+        sb.append("state uuid: ").append(stateUUID).append("\n");
+        sb.append("from_diff: ").append(wasReadFromDiff).append("\n");
+        sb.append("meta data version: ").append(metadata.version()).append("\n");
+        sb.append(TAB).append("coordination_metadata:\n");
+        sb.append(TAB).append(TAB).append("term: ").append(coordinationMetadata().term()).append("\n");
+        sb.append(TAB)
+            .append(TAB)
+            .append("last_committed_config: ")
+            .append(coordinationMetadata().getLastCommittedConfiguration())
+            .append("\n");
+        sb.append(TAB)
+            .append(TAB)
+            .append("last_accepted_config: ")
+            .append(coordinationMetadata().getLastAcceptedConfiguration())
+            .append("\n");
+        sb.append(TAB).append(TAB).append("voting tombstones: ").append(coordinationMetadata().getVotingConfigExclusions()).append("\n");
+        for (IndexMetadata indexMetadata : metadata) {
+            sb.append(TAB).append(indexMetadata.getIndex());
+            sb.append(": v[")
+                .append(indexMetadata.getVersion())
+                .append("], mv[")
+                .append(indexMetadata.getMappingVersion())
+                .append("], sv[")
+                .append(indexMetadata.getSettingsVersion())
+                .append("], av[")
+                .append(indexMetadata.getAliasesVersion())
+                .append("]\n");
+            for (int shard = 0; shard < indexMetadata.getNumberOfShards(); shard++) {
+                sb.append(TAB).append(TAB).append(shard).append(": ");
+                sb.append("p_term [").append(indexMetadata.primaryTerm(shard)).append("], ");
+                sb.append("isa_ids ").append(indexMetadata.inSyncAllocationIds(shard)).append("\n");
+            }
+        }
+        if (metadata.customs().isEmpty() == false) {
+            sb.append("metadata customs:\n");
+            for (final Map.Entry<String, Metadata.Custom> cursor : metadata.customs().entrySet()) {
+                final String type = cursor.getKey();
+                final Metadata.Custom custom = cursor.getValue();
+                sb.append(TAB).append(type).append(": ").append(custom);
+            }
+            sb.append("\n");
+        }
+        sb.append(blocks());
+        sb.append(nodes());
+        sb.append(routingTable());
+        // sb.append(getRoutingNodes());
+        if (customs.isEmpty() == false) {
+            sb.append("customs:\n");
+            for (ObjectObjectCursor<String, Custom> cursor : customs) {
+                final String type = cursor.key;
+                final Custom custom = cursor.value;
+                sb.append(TAB).append(type).append(": ").append(custom);
+            }
+        }
+        return sb.toString();
+    }
+
     /**
      * Builder for cluster state.
     *
@@ -505,7 +573,7 @@ public static Builder builder(ProtobufClusterState state) {
     */
     public static class Builder {
 
-        private final ProtobufClusterName clusterName;
+        private final ClusterName clusterName;
         private long version = 0;
         private String uuid = UNKNOWN_UUID;
         private Metadata metadata = Metadata.EMPTY_METADATA;
@@ -529,7 +597,7 @@ public Builder(ProtobufClusterState state) {
             this.fromDiff = false;
         }
 
-        public Builder(ProtobufClusterName clusterName) {
+        public Builder(ClusterName clusterName) {
             customs = ImmutableOpenMap.builder();
             this.clusterName = clusterName;
         }
@@ -659,7 +727,7 @@ public static ProtobufDiff<ProtobufClusterState> readDiffFrom(CodedInputStream i
 
     public static ProtobufClusterState readFrom(CodedInputStream in, DiscoveryNode localNode) throws IOException {
         ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        ProtobufClusterName clusterName = new ProtobufClusterName(in);
+        ClusterName clusterName = new ClusterName(in);
         Builder builder = new Builder(clusterName);
         builder.version = in.readInt64();
         builder.uuid = in.readString();
@@ -715,7 +783,7 @@ private static class ClusterStateDiff implements ProtobufDiff<ProtobufClusterSta
 
         private final String toUuid;
 
-        private final ProtobufClusterName clusterName;
+        private final ClusterName clusterName;
 
         private final ProtobufDiff<RoutingTable> routingTable;
 
@@ -748,7 +816,7 @@ private static class ClusterStateDiff implements ProtobufDiff<ProtobufClusterSta
         }
 
         ClusterStateDiff(CodedInputStream in, DiscoveryNode localNode) throws IOException {
-            clusterName = new ProtobufClusterName(in);
+            clusterName = new ClusterName(in);
             fromUuid = in.readString();
             toUuid = in.readString();
             toVersion = in.readInt64();
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateObserver.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateObserver.java
index 828d181b37a09..ca453f239bf01 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateObserver.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateObserver.java
@@ -56,7 +56,12 @@ public ProtobufClusterStateObserver(ClusterService clusterService, Logger logger
      *                       will fail any existing or new #waitForNextChange calls. Set to null
      *                       to wait indefinitely
      */
-    public ProtobufClusterStateObserver(ClusterService clusterService, @Nullable TimeValue timeout, Logger logger, ThreadContext contextHolder) {
+    public ProtobufClusterStateObserver(
+        ClusterService clusterService,
+        @Nullable TimeValue timeout,
+        Logger logger,
+        ThreadContext contextHolder
+    ) {
         this(clusterService.protobufState(), clusterService, timeout, logger, contextHolder);
     }
 
@@ -177,8 +182,8 @@ public void waitForNextChange(Listener listener, Predicate<ProtobufClusterState>
                 throw new OpenSearchException("already waiting for a cluster state change");
             }
             // clusterApplierService.addTimeoutListener(
-            //     timeoutTimeLeftMS == null ? null : new TimeValue(timeoutTimeLeftMS),
-            //     clusterStateListener
+            // timeoutTimeLeftMS == null ? null : new TimeValue(timeoutTimeLeftMS),
+            // clusterStateListener
             // );
         }
     }
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
index 1c38e68c43466..ba2e4560beec1 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
@@ -42,6 +42,8 @@
 import org.opensearch.cluster.ClusterStateTaskConfig;
 import org.opensearch.cluster.ClusterStateUpdateTask;
 import org.opensearch.cluster.LocalClusterUpdateTask;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.ProtobufClusterState;
 import org.opensearch.cluster.block.ClusterBlocks;
 import org.opensearch.cluster.coordination.ClusterFormationFailureHelper.ClusterFormationState;
 import org.opensearch.cluster.coordination.CoordinationMetadata.VotingConfigExclusion;
@@ -52,6 +54,7 @@
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
 import org.opensearch.cluster.routing.RerouteService;
 import org.opensearch.cluster.routing.allocation.AllocationService;
 import org.opensearch.cluster.service.ClusterApplier;
@@ -80,6 +83,7 @@
 import org.opensearch.discovery.DiscoveryStats;
 import org.opensearch.discovery.HandshakingTransportAddressConnector;
 import org.opensearch.discovery.PeerFinder;
+import org.opensearch.discovery.ProtobufDiscoveryStats;
 import org.opensearch.discovery.SeedHostsProvider;
 import org.opensearch.discovery.SeedHostsResolver;
 import org.opensearch.monitor.NodeHealthService;
@@ -851,8 +855,17 @@ protected void doStart() {
                 )
                 .nodes(DiscoveryNodes.builder().add(getLocalNode()).localNodeId(getLocalNode().getId()))
                 .build();
+            ProtobufClusterState protobufInitialState = ProtobufClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.get(settings))
+                .blocks(
+                    ClusterBlocks.builder()
+                        .addGlobalBlock(STATE_NOT_RECOVERED_BLOCK)
+                        .addGlobalBlock(noClusterManagerBlockService.getNoClusterManagerBlock())
+                )
+                .nodes(ProtobufDiscoveryNodes.builder().add(getLocalNode()).localNodeId(getLocalNode().getId()))
+                .build();
             applierState = initialState;
             clusterApplier.setInitialState(initialState);
+            clusterApplier.setInitialProtobufState(protobufInitialState);
         }
     }
 
@@ -861,6 +874,11 @@ public DiscoveryStats stats() {
         return new DiscoveryStats(new PendingClusterStateStats(0, 0, 0), publicationHandler.stats());
     }
 
+    @Override
+    public ProtobufDiscoveryStats protobufStats() {
+        return new ProtobufDiscoveryStats(new ProtobufPendingClusterStateStats(0, 0, 0), publicationHandler.protobufStats());
+    }
+
     @Override
     public void startInitialJoin() {
         synchronized (mutex) {
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java b/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
index 60c931a601561..3e426ce557ba9 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
@@ -159,6 +159,14 @@ public PublishClusterStateStats stats() {
         );
     }
 
+    public ProtobufPublishClusterStateStats protobufStats() {
+        return new ProtobufPublishClusterStateStats(
+            fullClusterStateReceivedCount.get(),
+            incompatibleClusterStateDiffReceivedCount.get(),
+            compatibleClusterStateDiffReceivedCount.get()
+        );
+    }
+
     private PublishWithJoinResponse handleIncomingPublishRequest(BytesTransportRequest request) throws IOException {
         try (StreamInput in = CompressedStreamUtils.decompressBytes(request, namedWriteableRegistry)) {
             ClusterState incomingState;
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java b/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java
index 3e36a5e65bf07..7e77821521faf 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java
@@ -32,6 +32,8 @@
 
 package org.opensearch.cluster.metadata;
 
+import com.google.protobuf.CodedInputStream;
+
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.LogManager;
 import org.apache.lucene.util.CollectionUtil;
@@ -92,6 +94,7 @@
 import java.util.stream.StreamSupport;
 
 import static org.opensearch.common.settings.Settings.readSettingsFromStream;
+import static org.opensearch.common.settings.Settings.readSettingsFromStreamProtobuf;
 import static org.opensearch.common.settings.Settings.writeSettingsToStream;
 
 /**
@@ -1062,6 +1065,31 @@ public static Metadata readFrom(StreamInput in) throws IOException {
         return builder.build();
     }
 
+    public static Metadata readFrom(CodedInputStream in) throws IOException {
+        Builder builder = new Builder();
+        builder.version = in.readInt64();
+        builder.clusterUUID = in.readString();
+        builder.clusterUUIDCommitted = in.readBool();
+        // builder.coordinationMetadata(new CoordinationMetadata(in));
+        builder.transientSettings(readSettingsFromStreamProtobuf(in));
+        builder.persistentSettings(readSettingsFromStreamProtobuf(in));
+        // builder.hashesOfConsistentSettings(DiffableStringMap.readFrom(in));
+        int size = in.readInt32();
+        // for (int i = 0; i < size; i++) {
+        // builder.put(IndexMetadata.readFrom(in), false);
+        // }
+        size = in.readInt32();
+        // for (int i = 0; i < size; i++) {
+        // builder.put(IndexTemplateMetadata.readFrom(in));
+        // }
+        int customSize = in.readInt32();
+        // for (int i = 0; i < customSize; i++) {
+        // Custom customIndexMetadata = in.readNamedWriteable(Custom.class);
+        // builder.putCustom(customIndexMetadata.getWriteableName(), customIndexMetadata);
+        // }
+        return builder.build();
+    }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         out.writeLong(version);
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/ProtobufIndexNameExpressionResolver.java b/server/src/main/java/org/opensearch/cluster/metadata/ProtobufIndexNameExpressionResolver.java
index dbb1bc319575d..8a8e2b2545150 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/ProtobufIndexNameExpressionResolver.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/ProtobufIndexNameExpressionResolver.java
@@ -6,7 +6,6 @@
  * compatible open source license.
  */
 
-
 package org.opensearch.cluster.metadata;
 
 import org.opensearch.OpenSearchParseException;
@@ -130,7 +129,12 @@ public String[] concreteIndexNames(ProtobufClusterState state, IndicesOptions op
         return concreteIndexNames(context, indexExpressions);
     }
 
-    public String[] concreteIndexNames(ProtobufClusterState state, IndicesOptions options, boolean includeDataStreams, String... indexExpressions) {
+    public String[] concreteIndexNames(
+        ProtobufClusterState state,
+        IndicesOptions options,
+        boolean includeDataStreams,
+        String... indexExpressions
+    ) {
         Context context = new Context(state, options, false, false, includeDataStreams, isSystemIndexAccessAllowed());
         return concreteIndexNames(context, indexExpressions);
     }
@@ -173,7 +177,12 @@ public Index[] concreteIndices(ProtobufClusterState state, IndicesOptions option
         return concreteIndices(state, options, false, indexExpressions);
     }
 
-    public Index[] concreteIndices(ProtobufClusterState state, IndicesOptions options, boolean includeDataStreams, String... indexExpressions) {
+    public Index[] concreteIndices(
+        ProtobufClusterState state,
+        IndicesOptions options,
+        boolean includeDataStreams,
+        String... indexExpressions
+    ) {
         Context context = new Context(state, options, false, false, includeDataStreams, isSystemIndexAccessAllowed());
         return concreteIndices(context, indexExpressions);
     }
diff --git a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
index d6ba0199d193c..56cd468d3d3a4 100644
--- a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
+++ b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
@@ -34,16 +34,23 @@
 
 import org.opensearch.Version;
 import org.opensearch.common.UUIDs;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.node.Node;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.Collections;
 import java.util.HashMap;
@@ -66,7 +73,7 @@
  *
  * @opensearch.internal
  */
-public class DiscoveryNode implements Writeable, ToXContentFragment {
+public class DiscoveryNode implements Writeable, ProtobufWriteable, ToXContentFragment {
 
     static final String COORDINATING_ONLY = "coordinating_only";
 
@@ -347,6 +354,53 @@ public DiscoveryNode(StreamInput in) throws IOException {
         this.version = in.readVersion();
     }
 
+    /**
+     * Creates a new {@link DiscoveryNode} by reading from the stream provided as argument
+    * @param in the stream
+    * @throws IOException if there is an error while reading from the stream
+    */
+    public DiscoveryNode(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        this.nodeName = in.readString();
+        this.nodeId = in.readString();
+        this.ephemeralId = in.readString();
+        this.hostName = in.readString();
+        this.hostAddress = in.readString();
+        ProtobufTransportAddress protobufTransportAddress = new ProtobufTransportAddress(in);
+        this.address = new TransportAddress(protobufTransportAddress.address());
+        // this.address = new TransportAddress(in);
+        int size = in.readInt32();
+        this.attributes = new HashMap<>(size);
+        for (int i = 0; i < size; i++) {
+            this.attributes.put(in.readString(), in.readString());
+        }
+        int rolesSize = in.readInt32();
+        final Set<DiscoveryNodeRole> roles = new HashSet<>(rolesSize);
+        for (int i = 0; i < rolesSize; i++) {
+            final String roleName = in.readString();
+            final String roleNameAbbreviation = in.readString();
+            final boolean canContainData = in.readBool();
+            final DiscoveryNodeRole role = roleMap.get(roleName);
+            if (role == null) {
+                if (protobufStreamInput.getVersion().onOrAfter(Version.V_2_1_0)) {
+                    roles.add(new DiscoveryNodeRole.DynamicRole(roleName, roleNameAbbreviation, canContainData));
+                } else {
+                    roles.add(new DiscoveryNodeRole.UnknownRole(roleName, roleNameAbbreviation, canContainData));
+                }
+            } else {
+                assert roleName.equals(role.roleName()) : "role name [" + roleName + "] does not match role [" + role.roleName() + "]";
+                assert roleNameAbbreviation.equals(role.roleNameAbbreviation()) : "role name abbreviation ["
+                    + roleName
+                    + "] does not match role ["
+                    + role.roleNameAbbreviation()
+                    + "]";
+                roles.add(role);
+            }
+        }
+        this.roles = Collections.unmodifiableSortedSet(new TreeSet<>(roles));
+        this.version = Version.readVersionProtobuf(in);
+    }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         out.writeString(nodeName);
@@ -370,6 +424,32 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeVersion(version);
     }
 
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        out.writeStringNoTag(nodeName);
+        out.writeStringNoTag(nodeId);
+        out.writeStringNoTag(ephemeralId);
+        out.writeStringNoTag(hostName);
+        out.writeStringNoTag(hostAddress);
+        ProtobufTransportAddress protobufTransportAddress = new ProtobufTransportAddress(address.address());
+        protobufTransportAddress.writeTo(out);
+        // address.writeTo(out);
+        out.writeInt32NoTag(attributes.size());
+        for (Map.Entry<String, String> entry : attributes.entrySet()) {
+            out.writeStringNoTag(entry.getKey());
+            out.writeStringNoTag(entry.getValue());
+        }
+        out.writeInt32NoTag(roles.size());
+        for (final DiscoveryNodeRole role : roles) {
+            final DiscoveryNodeRole compatibleRole = role.getCompatibilityRole(protobufStreamOutput.getVersion());
+            out.writeStringNoTag(compatibleRole.roleName());
+            out.writeStringNoTag(compatibleRole.roleNameAbbreviation());
+            out.writeBoolNoTag(compatibleRole.canContainData());
+        }
+        out.writeInt32NoTag(version.id);
+    }
+
     /**
      * The address that the node can be communicated with.
      */
@@ -377,6 +457,13 @@ public TransportAddress getAddress() {
         return address;
     }
 
+    /**
+     * The address that the node can be communicated with.
+     */
+    public ProtobufTransportAddress getProtobufAddress() {
+        return new ProtobufTransportAddress(address.address());
+    }
+
     /**
      * The unique id of the node.
      */
diff --git a/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNode.java b/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNode.java
deleted file mode 100644
index a05d519744fb5..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNode.java
+++ /dev/null
@@ -1,537 +0,0 @@
-/*
-* 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.
-*/
-
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
-package org.opensearch.cluster.node;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.Version;
-import org.opensearch.common.UUIDs;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.settings.Setting;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.ProtobufTransportAddress;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.node.Node;
-
-import java.io.IOException;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.SortedSet;
-import java.util.TreeSet;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import static org.opensearch.node.NodeRoleSettings.NODE_ROLES_SETTING;
-
-/**
- * A discovery node represents a node that is part of the cluster.
-*
-* @opensearch.internal
-*/
-public class ProtobufDiscoveryNode implements ProtobufWriteable, ToXContentFragment {
-
-    static final String COORDINATING_ONLY = "coordinating_only";
-
-    public static boolean nodeRequiresLocalStorage(Settings settings) {
-        boolean localStorageEnable = Node.NODE_LOCAL_STORAGE_SETTING.get(settings);
-        if (localStorageEnable == false && (isDataNode(settings) || isClusterManagerNode(settings))) {
-            // TODO: make this a proper setting validation logic, requiring multi-settings validation
-            throw new IllegalArgumentException("storage can not be disabled for cluster-manager and data nodes");
-        }
-        return localStorageEnable;
-    }
-
-    public static boolean hasRole(final Settings settings, final DiscoveryNodeRole role) {
-        /*
-        * This method can be called before the o.e.n.NodeRoleSettings.NODE_ROLES_SETTING is initialized. We do not want to trigger
-        * initialization prematurely because that will bake the default roles before plugins have had a chance to register them. Therefore,
-        * to avoid initializing this setting prematurely, we avoid using the actual node roles setting instance here.
-        */
-        if (settings.hasValue("node.roles")) {
-            return settings.getAsList("node.roles").contains(role.roleName());
-        } else if (role.legacySetting() != null && settings.hasValue(role.legacySetting().getKey())) {
-            return role.legacySetting().get(settings);
-        } else {
-            return role.isEnabledByDefault(settings);
-        }
-    }
-
-    public static boolean isClusterManagerNode(Settings settings) {
-        return hasRole(settings, DiscoveryNodeRole.MASTER_ROLE) || hasRole(settings, DiscoveryNodeRole.CLUSTER_MANAGER_ROLE);
-    }
-
-    /** @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #isClusterManagerNode(Settings)} */
-    @Deprecated
-    public static boolean isMasterNode(Settings settings) {
-        return isClusterManagerNode(settings);
-    }
-
-    /**
-     * Due to the way that plugins may not be available when settings are being initialized,
-    * not all roles may be available from a static/initializing context such as a {@link Setting}
-    * default value function. In that case, be warned that this may not include all plugin roles.
-    */
-    public static boolean isDataNode(final Settings settings) {
-        return getRolesFromSettings(settings).stream().anyMatch(DiscoveryNodeRole::canContainData);
-    }
-
-    public static boolean isIngestNode(Settings settings) {
-        return hasRole(settings, DiscoveryNodeRole.INGEST_ROLE);
-    }
-
-    public static boolean isRemoteClusterClient(final Settings settings) {
-        return hasRole(settings, DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE);
-    }
-
-    public static boolean isSearchNode(Settings settings) {
-        return hasRole(settings, DiscoveryNodeRole.SEARCH_ROLE);
-    }
-
-    private final String nodeName;
-    private final String nodeId;
-    private final String ephemeralId;
-    private final String hostName;
-    private final String hostAddress;
-    private final ProtobufTransportAddress address;
-    private final Map<String, String> attributes;
-    private final Version version;
-    private final SortedSet<DiscoveryNodeRole> roles;
-
-    /**
-     * Creates a new {@link ProtobufDiscoveryNode}
-    * <p>
-    * <b>Note:</b> if the version of the node is unknown {@link Version#minimumCompatibilityVersion()} should be used for the current
-    * version. it corresponds to the minimum version this opensearch version can communicate with. If a higher version is used
-    * the node might not be able to communicate with the remote node. After initial handshakes node versions will be discovered
-    * and updated.
-    * </p>
-    *
-    * @param id               the nodes unique (persistent) node id. This constructor will auto generate a random ephemeral id.
-    * @param address          the nodes transport address
-    * @param version          the version of the node
-    */
-    public ProtobufDiscoveryNode(final String id, ProtobufTransportAddress address, Version version) {
-        this(id, address, Collections.emptyMap(), DiscoveryNodeRole.BUILT_IN_ROLES, version);
-    }
-
-    /**
-     * Creates a new {@link ProtobufDiscoveryNode}
-    * <p>
-    * <b>Note:</b> if the version of the node is unknown {@link Version#minimumCompatibilityVersion()} should be used for the current
-    * version. it corresponds to the minimum version this opensearch version can communicate with. If a higher version is used
-    * the node might not be able to communicate with the remote node. After initial handshakes node versions will be discovered
-    * and updated.
-    * </p>
-    *
-    * @param id               the nodes unique (persistent) node id. This constructor will auto generate a random ephemeral id.
-    * @param address          the nodes transport address
-    * @param attributes       node attributes
-    * @param roles            node roles
-    * @param version          the version of the node
-    */
-    public ProtobufDiscoveryNode(
-        String id,
-        ProtobufTransportAddress address,
-        Map<String, String> attributes,
-        Set<DiscoveryNodeRole> roles,
-        Version version
-    ) {
-        this("", id, address, attributes, roles, version);
-    }
-
-    /**
-     * Creates a new {@link ProtobufDiscoveryNode}
-    * <p>
-    * <b>Note:</b> if the version of the node is unknown {@link Version#minimumCompatibilityVersion()} should be used for the current
-    * version. it corresponds to the minimum version this opensearch version can communicate with. If a higher version is used
-    * the node might not be able to communicate with the remote node. After initial handshakes node versions will be discovered
-    * and updated.
-    * </p>
-    *
-    * @param nodeName         the nodes name
-    * @param nodeId           the nodes unique persistent id. An ephemeral id will be auto generated.
-    * @param address          the nodes transport address
-    * @param attributes       node attributes
-    * @param roles            node roles
-    * @param version          the version of the node
-    */
-    public ProtobufDiscoveryNode(
-        String nodeName,
-        String nodeId,
-        ProtobufTransportAddress address,
-        Map<String, String> attributes,
-        Set<DiscoveryNodeRole> roles,
-        Version version
-    ) {
-        this(
-            nodeName,
-            nodeId,
-            UUIDs.randomBase64UUID(),
-            address.address().getHostString(),
-            address.getAddress(),
-            address,
-            attributes,
-            roles,
-            version
-        );
-    }
-
-    /**
-     * Creates a new {@link ProtobufDiscoveryNode}.
-    * <p>
-    * <b>Note:</b> if the version of the node is unknown {@link Version#minimumCompatibilityVersion()} should be used for the current
-    * version. it corresponds to the minimum version this opensearch version can communicate with. If a higher version is used
-    * the node might not be able to communicate with the remote node. After initial handshakes node versions will be discovered
-    * and updated.
-    * </p>
-    *
-    * @param nodeName         the nodes name
-    * @param nodeId           the nodes unique persistent id
-    * @param ephemeralId      the nodes unique ephemeral id
-    * @param hostAddress      the nodes host address
-    * @param address          the nodes transport address
-    * @param attributes       node attributes
-    * @param roles            node roles
-    * @param version          the version of the node
-    */
-    public ProtobufDiscoveryNode(
-        String nodeName,
-        String nodeId,
-        String ephemeralId,
-        String hostName,
-        String hostAddress,
-        ProtobufTransportAddress address,
-        Map<String, String> attributes,
-        Set<DiscoveryNodeRole> roles,
-        Version version
-    ) {
-        if (nodeName != null) {
-            this.nodeName = nodeName.intern();
-        } else {
-            this.nodeName = "";
-        }
-        this.nodeId = nodeId.intern();
-        this.ephemeralId = ephemeralId.intern();
-        this.hostName = hostName.intern();
-        this.hostAddress = hostAddress.intern();
-        this.address = address;
-        if (version == null) {
-            this.version = Version.CURRENT;
-        } else {
-            this.version = version;
-        }
-        this.attributes = Collections.unmodifiableMap(attributes);
-        // verify that no node roles are being provided as attributes
-        Predicate<Map<String, String>> predicate = (attrs) -> {
-            boolean success = true;
-            for (final DiscoveryNodeRole role : ProtobufDiscoveryNode.roleMap.values()) {
-                success &= attrs.containsKey(role.roleName()) == false;
-                assert success : role.roleName();
-            }
-            return success;
-        };
-        assert predicate.test(attributes) : attributes;
-        this.roles = Collections.unmodifiableSortedSet(new TreeSet<>(roles));
-    }
-
-    /** Creates a ProtobufDiscoveryNode representing the local node. */
-    public static ProtobufDiscoveryNode createLocal(Settings settings, ProtobufTransportAddress publishAddress, String nodeId) {
-        Map<String, String> attributes = Node.NODE_ATTRIBUTES.getAsMap(settings);
-        Set<DiscoveryNodeRole> roles = getRolesFromSettings(settings);
-        return new ProtobufDiscoveryNode(Node.NODE_NAME_SETTING.get(settings), nodeId, publishAddress, attributes, roles, Version.CURRENT);
-    }
-
-    /** extract node roles from the given settings */
-    public static Set<DiscoveryNodeRole> getRolesFromSettings(final Settings settings) {
-        if (NODE_ROLES_SETTING.exists(settings)) {
-            validateLegacySettings(settings, roleMap);
-            return Collections.unmodifiableSet(new HashSet<>(NODE_ROLES_SETTING.get(settings)));
-        } else {
-            return roleMap.values().stream().filter(s -> s.isEnabledByDefault(settings)).collect(Collectors.toSet());
-        }
-    }
-
-    private static void validateLegacySettings(final Settings settings, final Map<String, DiscoveryNodeRole> roleMap) {
-        for (final DiscoveryNodeRole role : roleMap.values()) {
-            if (role.legacySetting() != null && role.legacySetting().exists(settings)) {
-                final String message = String.format(
-                    Locale.ROOT,
-                    "can not explicitly configure node roles and use legacy role setting [%s]=[%s]",
-                    role.legacySetting().getKey(),
-                    role.legacySetting().get(settings)
-                );
-                throw new IllegalArgumentException(message);
-            }
-        }
-    }
-
-    /**
-     * Creates a new {@link ProtobufDiscoveryNode} by reading from the stream provided as argument
-    * @param in the stream
-    * @throws IOException if there is an error while reading from the stream
-    */
-    public ProtobufDiscoveryNode(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        this.nodeName = in.readString();
-        this.nodeId = in.readString();
-        this.ephemeralId = in.readString();
-        this.hostName = in.readString();
-        this.hostAddress = in.readString();
-        this.address = new ProtobufTransportAddress(in);
-        int size = in.readInt32();
-        this.attributes = new HashMap<>(size);
-        for (int i = 0; i < size; i++) {
-            this.attributes.put(in.readString(), in.readString());
-        }
-        int rolesSize = in.readInt32();
-        final Set<DiscoveryNodeRole> roles = new HashSet<>(rolesSize);
-        for (int i = 0; i < rolesSize; i++) {
-            final String roleName = in.readString();
-            final String roleNameAbbreviation = in.readString();
-            final boolean canContainData = in.readBool();
-            final DiscoveryNodeRole role = roleMap.get(roleName);
-            if (role == null) {
-                if (protobufStreamInput.getVersion().onOrAfter(Version.V_2_1_0)) {
-                    roles.add(new DiscoveryNodeRole.DynamicRole(roleName, roleNameAbbreviation, canContainData));
-                } else {
-                    roles.add(new DiscoveryNodeRole.UnknownRole(roleName, roleNameAbbreviation, canContainData));
-                }
-            } else {
-                assert roleName.equals(role.roleName()) : "role name [" + roleName + "] does not match role [" + role.roleName() + "]";
-                assert roleNameAbbreviation.equals(role.roleNameAbbreviation()) : "role name abbreviation ["
-                    + roleName
-                    + "] does not match role ["
-                    + role.roleNameAbbreviation()
-                    + "]";
-                roles.add(role);
-            }
-        }
-        this.roles = Collections.unmodifiableSortedSet(new TreeSet<>(roles));
-        this.version = Version.readVersionProtobuf(in);
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeStringNoTag(nodeName);
-        out.writeStringNoTag(nodeId);
-        out.writeStringNoTag(ephemeralId);
-        out.writeStringNoTag(hostName);
-        out.writeStringNoTag(hostAddress);
-        address.writeTo(out);
-        out.writeInt32NoTag(attributes.size());
-        for (Map.Entry<String, String> entry : attributes.entrySet()) {
-            out.writeStringNoTag(entry.getKey());
-            out.writeStringNoTag(entry.getValue());
-        }
-        out.writeInt32NoTag(roles.size());
-        for (final DiscoveryNodeRole role : roles) {
-            final DiscoveryNodeRole compatibleRole = role.getCompatibilityRole(protobufStreamOutput.getVersion());
-            out.writeStringNoTag(compatibleRole.roleName());
-            out.writeStringNoTag(compatibleRole.roleNameAbbreviation());
-            out.writeBoolNoTag(compatibleRole.canContainData());
-        }
-        out.writeInt32NoTag(version.id);
-    }
-
-    /**
-     * The address that the node can be communicated with.
-    */
-    public ProtobufTransportAddress getAddress() {
-        return address;
-    }
-
-    /**
-     * The unique id of the node.
-    */
-    public String getId() {
-        return nodeId;
-    }
-
-    /**
-     * The unique ephemeral id of the node. Ephemeral ids are meant to be attached the life span
-    * of a node process. When ever a node is restarted, it's ephemeral id is required to change (while it's {@link #getId()}
-    * will be read from the data folder and will remain the same across restarts).
-    */
-    public String getEphemeralId() {
-        return ephemeralId;
-    }
-
-    /**
-     * The name of the node.
-    */
-    public String getName() {
-        return this.nodeName;
-    }
-
-    /**
-     * The node attributes.
-    */
-    public Map<String, String> getAttributes() {
-        return this.attributes;
-    }
-
-    /**
-     * Should this node hold data (shards) or not.
-    */
-    public boolean isDataNode() {
-        return roles.stream().anyMatch(DiscoveryNodeRole::canContainData);
-    }
-
-    /**
-     * Can this node become cluster-manager or not.
-    */
-    public boolean isClusterManagerNode() {
-        return roles.contains(DiscoveryNodeRole.MASTER_ROLE) || roles.contains(DiscoveryNodeRole.CLUSTER_MANAGER_ROLE);
-    }
-
-    /**
-     * Can this node become cluster-manager or not.
-    *
-    * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #isClusterManagerNode()}
-    */
-    @Deprecated
-    public boolean isMasterNode() {
-        return isClusterManagerNode();
-    }
-
-    /**
-     * Returns a boolean that tells whether this an ingest node or not
-    */
-    public boolean isIngestNode() {
-        return roles.contains(DiscoveryNodeRole.INGEST_ROLE);
-    }
-
-    /**
-     * Returns whether or not the node can be a remote cluster client.
-    *
-    * @return true if the node can be a remote cluster client, false otherwise
-    */
-    public boolean isRemoteClusterClient() {
-        return roles.contains(DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE);
-    }
-
-    /**
-     * Returns whether the node is dedicated to provide search capability.
-    *
-    * @return true if the node contains search role, false otherwise
-    */
-    public boolean isSearchNode() {
-        return roles.contains(DiscoveryNodeRole.SEARCH_ROLE);
-    }
-
-    /**
-     * Returns a set of all the roles that the node has. The roles are returned in sorted order by the role name.
-    * <p>
-    * If a node does not have any specific role, the returned set is empty, which means that the node is a coordinating-only node.
-    *
-    * @return the sorted set of roles
-    */
-    public Set<DiscoveryNodeRole> getRoles() {
-        return roles;
-    }
-
-    public Version getVersion() {
-        return this.version;
-    }
-
-    public String getHostName() {
-        return this.hostName;
-    }
-
-    public String getHostAddress() {
-        return this.hostAddress;
-    }
-
-    private static Map<String, DiscoveryNodeRole> rolesToMap(final Stream<DiscoveryNodeRole> roles) {
-        return Collections.unmodifiableMap(roles.collect(Collectors.toMap(DiscoveryNodeRole::roleName, Function.identity())));
-    }
-
-    private static Map<String, DiscoveryNodeRole> roleMap = rolesToMap(DiscoveryNodeRole.BUILT_IN_ROLES.stream());
-
-    public static DiscoveryNodeRole getRoleFromRoleName(final String roleName) {
-        // As we are supporting dynamic role, should make role name case-insensitive to avoid confusion of role name like "Data"/"DATA"
-        String lowerCasedRoleName = Objects.requireNonNull(roleName).toLowerCase(Locale.ROOT);
-        if (roleMap.containsKey(lowerCasedRoleName)) {
-            return roleMap.get(lowerCasedRoleName);
-        }
-        return new DiscoveryNodeRole.DynamicRole(lowerCasedRoleName, lowerCasedRoleName, false);
-    }
-
-    public static Set<DiscoveryNodeRole> getPossibleRoles() {
-        return Collections.unmodifiableSet(new HashSet<>(roleMap.values()));
-    }
-
-    public static void setAdditionalRoles(final Set<DiscoveryNodeRole> additionalRoles) {
-        assert additionalRoles.stream().allMatch(r -> r.legacySetting() == null || r.legacySetting().isDeprecated()) : additionalRoles;
-        final Map<String, DiscoveryNodeRole> roleNameToPossibleRoles = rolesToMap(
-            Stream.concat(DiscoveryNodeRole.BUILT_IN_ROLES.stream(), additionalRoles.stream())
-        );
-        // collect the abbreviation names into a map to ensure that there are not any duplicate abbreviations
-        final Map<String, DiscoveryNodeRole> roleNameAbbreviationToPossibleRoles = Collections.unmodifiableMap(
-            roleNameToPossibleRoles.values()
-                .stream()
-                .collect(Collectors.toMap(DiscoveryNodeRole::roleNameAbbreviation, Function.identity()))
-        );
-        assert roleNameToPossibleRoles.size() == roleNameAbbreviationToPossibleRoles.size() : "roles by name ["
-            + roleNameToPossibleRoles
-            + "], roles by name abbreviation ["
-            + roleNameAbbreviationToPossibleRoles
-            + "]";
-        roleMap = roleNameToPossibleRoles;
-    }
-
-    /**
-     * Load the deprecated {@link DiscoveryNodeRole#MASTER_ROLE}.
-    * Master role is not added into BUILT_IN_ROLES, because {@link #setAdditionalRoles(Set)} check role name abbreviation duplication,
-    * and CLUSTER_MANAGER_ROLE has the same abbreviation name with MASTER_ROLE.
-    */
-    public static void setDeprecatedMasterRole() {
-        final Map<String, DiscoveryNodeRole> modifiableRoleMap = new HashMap<>(roleMap);
-        modifiableRoleMap.put(DiscoveryNodeRole.MASTER_ROLE.roleName(), DiscoveryNodeRole.MASTER_ROLE);
-        roleMap = Collections.unmodifiableMap(modifiableRoleMap);
-    }
-
-    public static Set<String> getPossibleRoleNames() {
-        return roleMap.keySet();
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(getId());
-        builder.field("name", getName());
-        builder.field("ephemeral_id", getEphemeralId());
-        builder.field("transport_address", getAddress().toString());
-
-        builder.startObject("attributes");
-        for (Map.Entry<String, String> entry : attributes.entrySet()) {
-            builder.field(entry.getKey(), entry.getValue());
-        }
-        builder.endObject();
-
-        builder.endObject();
-        return builder;
-    }
-
-}
diff --git a/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java b/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java
index b2594459dd5e2..b49a286178ae1 100644
--- a/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java
+++ b/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java
@@ -37,19 +37,19 @@
 import java.util.stream.StreamSupport;
 
 /**
- * This class holds all {@link ProtobufDiscoveryNode} in the cluster and provides convenience methods to
+ * This class holds all {@link DiscoveryNode} in the cluster and provides convenience methods to
 * access, modify merge / diff discovery nodes.
 *
 * @opensearch.internal
 */
-public class ProtobufDiscoveryNodes extends ProtobufAbstractDiffable<ProtobufDiscoveryNodes> implements Iterable<ProtobufDiscoveryNode> {
+public class ProtobufDiscoveryNodes extends ProtobufAbstractDiffable<ProtobufDiscoveryNodes> implements Iterable<DiscoveryNode> {
 
     public static final ProtobufDiscoveryNodes EMPTY_NODES = builder().build();
 
-    private final ImmutableOpenMap<String, ProtobufDiscoveryNode> nodes;
-    private final ImmutableOpenMap<String, ProtobufDiscoveryNode> dataNodes;
-    private final ImmutableOpenMap<String, ProtobufDiscoveryNode> clusterManagerNodes;
-    private final ImmutableOpenMap<String, ProtobufDiscoveryNode> ingestNodes;
+    private final ImmutableOpenMap<String, DiscoveryNode> nodes;
+    private final ImmutableOpenMap<String, DiscoveryNode> dataNodes;
+    private final ImmutableOpenMap<String, DiscoveryNode> clusterManagerNodes;
+    private final ImmutableOpenMap<String, DiscoveryNode> ingestNodes;
 
     private final String clusterManagerNodeId;
     private final String localNodeId;
@@ -59,10 +59,10 @@ public class ProtobufDiscoveryNodes extends ProtobufAbstractDiffable<ProtobufDis
     private final Version minNodeVersion;
 
     private ProtobufDiscoveryNodes(
-        ImmutableOpenMap<String, ProtobufDiscoveryNode> nodes,
-        ImmutableOpenMap<String, ProtobufDiscoveryNode> dataNodes,
-        ImmutableOpenMap<String, ProtobufDiscoveryNode> clusterManagerNodes,
-        ImmutableOpenMap<String, ProtobufDiscoveryNode> ingestNodes,
+        ImmutableOpenMap<String, DiscoveryNode> nodes,
+        ImmutableOpenMap<String, DiscoveryNode> dataNodes,
+        ImmutableOpenMap<String, DiscoveryNode> clusterManagerNodes,
+        ImmutableOpenMap<String, DiscoveryNode> ingestNodes,
         String clusterManagerNodeId,
         String localNodeId,
         Version minNonClientNodeVersion,
@@ -83,7 +83,7 @@ private ProtobufDiscoveryNodes(
     }
 
     @Override
-    public Iterator<ProtobufDiscoveryNode> iterator() {
+    public Iterator<DiscoveryNode> iterator() {
         return nodes.valuesIt();
     }
 
@@ -122,7 +122,7 @@ public int getSize() {
     *
     * @return {@link Map} of the discovered nodes arranged by their ids
     */
-    public ImmutableOpenMap<String, ProtobufDiscoveryNode> getNodes() {
+    public ImmutableOpenMap<String, DiscoveryNode> getNodes() {
         return this.nodes;
     }
 
@@ -131,7 +131,7 @@ public ImmutableOpenMap<String, ProtobufDiscoveryNode> getNodes() {
     *
     * @return {@link Map} of the discovered data nodes arranged by their ids
     */
-    public ImmutableOpenMap<String, ProtobufDiscoveryNode> getDataNodes() {
+    public ImmutableOpenMap<String, DiscoveryNode> getDataNodes() {
         return this.dataNodes;
     }
 
@@ -140,7 +140,7 @@ public ImmutableOpenMap<String, ProtobufDiscoveryNode> getDataNodes() {
     *
     * @return {@link Map} of the discovered cluster-manager nodes arranged by their ids
     */
-    public ImmutableOpenMap<String, ProtobufDiscoveryNode> getClusterManagerNodes() {
+    public ImmutableOpenMap<String, DiscoveryNode> getClusterManagerNodes() {
         return this.clusterManagerNodes;
     }
 
@@ -151,14 +151,14 @@ public ImmutableOpenMap<String, ProtobufDiscoveryNode> getClusterManagerNodes()
     * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #getClusterManagerNodes()}
     */
     @Deprecated
-    public ImmutableOpenMap<String, ProtobufDiscoveryNode> getMasterNodes() {
+    public ImmutableOpenMap<String, DiscoveryNode> getMasterNodes() {
         return getClusterManagerNodes();
     }
 
     /**
      * @return All the ingest nodes arranged by their ids
     */
-    public ImmutableOpenMap<String, ProtobufDiscoveryNode> getIngestNodes() {
+    public ImmutableOpenMap<String, DiscoveryNode> getIngestNodes() {
         return ingestNodes;
     }
 
@@ -167,8 +167,8 @@ public ImmutableOpenMap<String, ProtobufDiscoveryNode> getIngestNodes() {
     *
     * @return {@link Map} of the discovered cluster-manager and data nodes arranged by their ids
     */
-    public ImmutableOpenMap<String, ProtobufDiscoveryNode> getClusterManagerAndDataNodes() {
-        ImmutableOpenMap.Builder<String, ProtobufDiscoveryNode> nodes = ImmutableOpenMap.builder(dataNodes);
+    public ImmutableOpenMap<String, DiscoveryNode> getClusterManagerAndDataNodes() {
+        ImmutableOpenMap.Builder<String, DiscoveryNode> nodes = ImmutableOpenMap.builder(dataNodes);
         nodes.putAll(clusterManagerNodes);
         return nodes.build();
     }
@@ -180,7 +180,7 @@ public ImmutableOpenMap<String, ProtobufDiscoveryNode> getClusterManagerAndDataN
     * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #getClusterManagerAndDataNodes()}
     */
     @Deprecated
-    public ImmutableOpenMap<String, ProtobufDiscoveryNode> getMasterAndDataNodes() {
+    public ImmutableOpenMap<String, DiscoveryNode> getMasterAndDataNodes() {
         return getClusterManagerAndDataNodes();
     }
 
@@ -189,8 +189,8 @@ public ImmutableOpenMap<String, ProtobufDiscoveryNode> getMasterAndDataNodes() {
     *
     * @return {@link Map} of the coordinating only nodes arranged by their ids
     */
-    public ImmutableOpenMap<String, ProtobufDiscoveryNode> getCoordinatingOnlyNodes() {
-        ImmutableOpenMap.Builder<String, ProtobufDiscoveryNode> nodes = ImmutableOpenMap.builder(this.nodes);
+    public ImmutableOpenMap<String, DiscoveryNode> getCoordinatingOnlyNodes() {
+        ImmutableOpenMap.Builder<String, DiscoveryNode> nodes = ImmutableOpenMap.builder(this.nodes);
         nodes.removeAll(clusterManagerNodes.keys());
         nodes.removeAll(dataNodes.keys());
         nodes.removeAll(ingestNodes.keys());
@@ -200,7 +200,7 @@ public ImmutableOpenMap<String, ProtobufDiscoveryNode> getCoordinatingOnlyNodes(
     /**
      * Returns a stream of all nodes, with cluster-manager nodes at the front
     */
-    public Stream<ProtobufDiscoveryNode> clusterManagersFirstStream() {
+    public Stream<DiscoveryNode> clusterManagersFirstStream() {
         return Stream.concat(
             StreamSupport.stream(clusterManagerNodes.spliterator(), false).map(cur -> cur.value),
             StreamSupport.stream(this.spliterator(), false).filter(n -> n.isClusterManagerNode() == false)
@@ -213,7 +213,7 @@ public Stream<ProtobufDiscoveryNode> clusterManagersFirstStream() {
     * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #clusterManagersFirstStream()}
     */
     @Deprecated
-    public Stream<ProtobufDiscoveryNode> mastersFirstStream() {
+    public Stream<DiscoveryNode> mastersFirstStream() {
         return clusterManagersFirstStream();
     }
 
@@ -223,7 +223,7 @@ public Stream<ProtobufDiscoveryNode> mastersFirstStream() {
     * @param nodeId id of the wanted node
     * @return wanted node if it exists. Otherwise <code>null</code>
     */
-    public ProtobufDiscoveryNode get(String nodeId) {
+    public DiscoveryNode get(String nodeId) {
         return nodes.get(nodeId);
     }
 
@@ -243,8 +243,8 @@ public boolean nodeExists(String nodeId) {
     * @param node of the node which existence should be verified
     * @return <code>true</code> if the node exists. Otherwise <code>false</code>
     */
-    public boolean nodeExists(ProtobufDiscoveryNode node) {
-        ProtobufDiscoveryNode existing = nodes.get(node.getId());
+    public boolean nodeExists(DiscoveryNode node) {
+        DiscoveryNode existing = nodes.get(node.getId());
         return existing != null && existing.equals(node);
     }
 
@@ -252,8 +252,8 @@ public boolean nodeExists(ProtobufDiscoveryNode node) {
      * Determine if the given node exists and has the right roles. Supported roles vary by version, and our local cluster state might
     * have come via an older cluster-manager, so the roles may differ even if the node is otherwise identical.
     */
-    public boolean nodeExistsWithSameRoles(ProtobufDiscoveryNode discoveryNode) {
-        final ProtobufDiscoveryNode existing = nodes.get(discoveryNode.getId());
+    public boolean nodeExistsWithSameRoles(DiscoveryNode discoveryNode) {
+        final DiscoveryNode existing = nodes.get(discoveryNode.getId());
         return existing != null && existing.equals(discoveryNode) && existing.getRoles().equals(discoveryNode.getRoles());
     }
 
@@ -291,7 +291,7 @@ public String getLocalNodeId() {
     *
     * @return local node
     */
-    public ProtobufDiscoveryNode getLocalNode() {
+    public DiscoveryNode getLocalNode() {
         return nodes.get(localNodeId);
     }
 
@@ -299,7 +299,7 @@ public ProtobufDiscoveryNode getLocalNode() {
      * Returns the cluster-manager node, or {@code null} if there is no cluster-manager node
     */
     @Nullable
-    public ProtobufDiscoveryNode getClusterManagerNode() {
+    public DiscoveryNode getClusterManagerNode() {
         if (clusterManagerNodeId != null) {
             return nodes.get(clusterManagerNodeId);
         }
@@ -313,7 +313,7 @@ public ProtobufDiscoveryNode getClusterManagerNode() {
     */
     @Deprecated
     @Nullable
-    public ProtobufDiscoveryNode getMasterNode() {
+    public DiscoveryNode getMasterNode() {
         return getClusterManagerNode();
     }
 
@@ -323,9 +323,9 @@ public ProtobufDiscoveryNode getMasterNode() {
     * @param address {@link TransportAddress} of the wanted node
     * @return node identified by the given address or <code>null</code> if no such node exists
     */
-    public ProtobufDiscoveryNode findByAddress(TransportAddress address) {
-        for (ObjectCursor<ProtobufDiscoveryNode> cursor : nodes.values()) {
-            ProtobufDiscoveryNode node = cursor.value;
+    public DiscoveryNode findByAddress(TransportAddress address) {
+        for (ObjectCursor<DiscoveryNode> cursor : nodes.values()) {
+            DiscoveryNode node = cursor.value;
             if (node.getAddress().equals(address)) {
                 return node;
             }
@@ -380,7 +380,7 @@ public Version getMaxNodeVersion() {
     * @return discovered node matching the given id
     * @throws IllegalArgumentException if more than one node matches the request or no nodes have been resolved
     */
-    public ProtobufDiscoveryNode resolveNode(String node) {
+    public DiscoveryNode resolveNode(String node) {
         String[] resolvedNodeIds = resolveNodes(node);
         if (resolvedNodeIds.length > 1) {
             throw new IllegalArgumentException(
@@ -410,7 +410,7 @@ public ProtobufDiscoveryNode resolveNode(String node) {
     */
     public String[] resolveNodes(String... nodes) {
         if (nodes == null || nodes.length == 0) {
-            return StreamSupport.stream(this.spliterator(), false).map(ProtobufDiscoveryNode::getId).toArray(String[]::new);
+            return StreamSupport.stream(this.spliterator(), false).map(DiscoveryNode::getId).toArray(String[]::new);
         } else {
             ObjectHashSet<String> resolvedNodesIds = new ObjectHashSet<>(nodes.length);
             for (String nodeId : nodes) {
@@ -431,7 +431,7 @@ public String[] resolveNodes(String... nodes) {
                 } else if (nodeExists(nodeId)) {
                     resolvedNodesIds.add(nodeId);
                 } else {
-                    for (ProtobufDiscoveryNode node : this) {
+                    for (DiscoveryNode node : this) {
                         if ("_all".equals(nodeId)
                             || Regex.simpleMatch(nodeId, node.getName())
                             || Regex.simpleMatch(nodeId, node.getHostAddress())
@@ -461,14 +461,14 @@ public String[] resolveNodes(String... nodes) {
                             } else {
                                 resolvedNodesIds.removeAll(ingestNodes.keys());
                             }
-                        } else if (ProtobufDiscoveryNode.COORDINATING_ONLY.equals(matchAttrName)) {
+                        } else if (DiscoveryNode.COORDINATING_ONLY.equals(matchAttrName)) {
                             if (Booleans.parseBoolean(matchAttrValue, true)) {
                                 resolvedNodesIds.addAll(getCoordinatingOnlyNodes().keys());
                             } else {
                                 resolvedNodesIds.removeAll(getCoordinatingOnlyNodes().keys());
                             }
                         } else {
-                            for (ProtobufDiscoveryNode node : this) {
+                            for (DiscoveryNode node : this) {
                                 for (DiscoveryNodeRole role : Sets.difference(node.getRoles(), DiscoveryNodeRole.BUILT_IN_ROLES)) {
                                     if (role.roleName().equals(matchAttrName)) {
                                         if (Booleans.parseBoolean(matchAttrValue, true)) {
@@ -479,7 +479,7 @@ public String[] resolveNodes(String... nodes) {
                                     }
                                 }
                             }
-                            for (ProtobufDiscoveryNode node : this) {
+                            for (DiscoveryNode node : this) {
                                 for (Map.Entry<String, String> entry : node.getAttributes().entrySet()) {
                                     String attrName = entry.getKey();
                                     String attrValue = entry.getValue();
@@ -496,7 +496,7 @@ public String[] resolveNodes(String... nodes) {
         }
     }
 
-    public ProtobufDiscoveryNodes newNode(ProtobufDiscoveryNode node) {
+    public ProtobufDiscoveryNodes newNode(DiscoveryNode node) {
         return new Builder(this).add(node).build();
     }
 
@@ -504,14 +504,14 @@ public ProtobufDiscoveryNodes newNode(ProtobufDiscoveryNode node) {
      * Returns the changes comparing this nodes to the provided nodes.
     */
     public Delta delta(ProtobufDiscoveryNodes other) {
-        final List<ProtobufDiscoveryNode> removed = new ArrayList<>();
-        final List<ProtobufDiscoveryNode> added = new ArrayList<>();
-        for (ProtobufDiscoveryNode node : other) {
+        final List<DiscoveryNode> removed = new ArrayList<>();
+        final List<DiscoveryNode> added = new ArrayList<>();
+        for (DiscoveryNode node : other) {
             if (this.nodeExists(node) == false) {
                 removed.add(node);
             }
         }
-        for (ProtobufDiscoveryNode node : this) {
+        for (DiscoveryNode node : this) {
             if (other.nodeExists(node) == false) {
                 added.add(node);
             }
@@ -530,7 +530,7 @@ public Delta delta(ProtobufDiscoveryNodes other) {
     public String toString() {
         StringBuilder sb = new StringBuilder();
         sb.append("nodes: \n");
-        for (ProtobufDiscoveryNode node : this) {
+        for (DiscoveryNode node : this) {
             sb.append("   ").append(node);
             if (node == getLocalNode()) {
                 sb.append(", local");
@@ -552,18 +552,18 @@ public static class Delta {
 
         private final String localNodeId;
         @Nullable
-        private final ProtobufDiscoveryNode previousClusterManagerNode;
+        private final DiscoveryNode previousClusterManagerNode;
         @Nullable
-        private final ProtobufDiscoveryNode newClusterManagerNode;
-        private final List<ProtobufDiscoveryNode> removed;
-        private final List<ProtobufDiscoveryNode> added;
+        private final DiscoveryNode newClusterManagerNode;
+        private final List<DiscoveryNode> removed;
+        private final List<DiscoveryNode> added;
 
         private Delta(
-            @Nullable ProtobufDiscoveryNode previousClusterManagerNode,
-            @Nullable ProtobufDiscoveryNode newClusterManagerNode,
+            @Nullable DiscoveryNode previousClusterManagerNode,
+            @Nullable DiscoveryNode newClusterManagerNode,
             String localNodeId,
-            List<ProtobufDiscoveryNode> removed,
-            List<ProtobufDiscoveryNode> added
+            List<DiscoveryNode> removed,
+            List<DiscoveryNode> added
         ) {
             this.previousClusterManagerNode = previousClusterManagerNode;
             this.newClusterManagerNode = newClusterManagerNode;
@@ -587,26 +587,26 @@ public boolean masterNodeChanged() {
         }
 
         @Nullable
-        public ProtobufDiscoveryNode previousClusterManagerNode() {
+        public DiscoveryNode previousClusterManagerNode() {
             return previousClusterManagerNode;
         }
 
         /** @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #previousClusterManagerNode()} */
         @Deprecated
         @Nullable
-        public ProtobufDiscoveryNode previousMasterNode() {
+        public DiscoveryNode previousMasterNode() {
             return previousClusterManagerNode();
         }
 
         @Nullable
-        public ProtobufDiscoveryNode newClusterManagerNode() {
+        public DiscoveryNode newClusterManagerNode() {
             return newClusterManagerNode;
         }
 
         /** @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #newClusterManagerNode()} */
         @Deprecated
         @Nullable
-        public ProtobufDiscoveryNode newMasterNode() {
+        public DiscoveryNode newMasterNode() {
             return newClusterManagerNode();
         }
 
@@ -614,7 +614,7 @@ public boolean removed() {
             return !removed.isEmpty();
         }
 
-        public List<ProtobufDiscoveryNode> removedNodes() {
+        public List<DiscoveryNode> removedNodes() {
             return removed;
         }
 
@@ -622,7 +622,7 @@ public boolean added() {
             return !added.isEmpty();
         }
 
-        public List<ProtobufDiscoveryNode> addedNodes() {
+        public List<DiscoveryNode> addedNodes() {
             return added;
         }
 
@@ -648,7 +648,7 @@ public String shortSummary() {
             if (added()) {
                 final String addedNodesExceptLocalNode = addedNodes().stream()
                     .filter(node -> node.getId().equals(localNodeId) == false)
-                    .map(ProtobufDiscoveryNode::toString)
+                    .map(DiscoveryNode::toString)
                     .collect(Collectors.joining(","));
                 if (addedNodesExceptLocalNode.length() > 0) {
                     // ignore ourselves when reporting on nodes being added
@@ -671,12 +671,12 @@ public void writeTo(CodedOutputStream out) throws IOException {
             out.writeStringNoTag(clusterManagerNodeId);
         }
         out.writeInt32NoTag(nodes.size());
-        for (ProtobufDiscoveryNode node : this) {
+        for (DiscoveryNode node : this) {
             node.writeTo(out);
         }
     }
 
-    public static ProtobufDiscoveryNodes readFrom(CodedInputStream in, ProtobufDiscoveryNode localNode) throws IOException {
+    public static ProtobufDiscoveryNodes readFrom(CodedInputStream in, DiscoveryNode localNode) throws IOException {
         Builder builder = new Builder();
         if (in.readBool()) {
             builder.clusterManagerNodeId(in.readString());
@@ -686,7 +686,7 @@ public static ProtobufDiscoveryNodes readFrom(CodedInputStream in, ProtobufDisco
         }
         int size = in.readInt32();
         for (int i = 0; i < size; i++) {
-            ProtobufDiscoveryNode node = new ProtobufDiscoveryNode(in);
+            DiscoveryNode node = new DiscoveryNode(in);
             if (localNode != null && node.getId().equals(localNode.getId())) {
                 // reuse the same instance of our address and local node id for faster equality
                 node = localNode;
@@ -699,8 +699,7 @@ public static ProtobufDiscoveryNodes readFrom(CodedInputStream in, ProtobufDisco
         return builder.build();
     }
 
-    public static ProtobufDiff<ProtobufDiscoveryNodes> readDiffFrom(CodedInputStream in, ProtobufDiscoveryNode localNode)
-        throws IOException {
+    public static ProtobufDiff<ProtobufDiscoveryNodes> readDiffFrom(CodedInputStream in, DiscoveryNode localNode) throws IOException {
         return ProtobufAbstractDiffable.readDiffFrom(in1 -> readFrom(in1, localNode), in);
     }
 
@@ -719,7 +718,7 @@ public static Builder builder(ProtobufDiscoveryNodes nodes) {
     */
     public static class Builder {
 
-        private final ImmutableOpenMap.Builder<String, ProtobufDiscoveryNode> nodes;
+        private final ImmutableOpenMap.Builder<String, DiscoveryNode> nodes;
         private String clusterManagerNodeId;
         private String localNodeId;
 
@@ -735,9 +734,9 @@ public Builder(ProtobufDiscoveryNodes nodes) {
 
         /**
          * adds a disco node to the builder. Will throw an {@link IllegalArgumentException} if
-        * the supplied node doesn't pass the pre-flight checks performed by {@link #validateAdd(ProtobufDiscoveryNode)}
+        * the supplied node doesn't pass the pre-flight checks performed by {@link #validateAdd(DiscoveryNode)}
         */
-        public Builder add(ProtobufDiscoveryNode node) {
+        public Builder add(DiscoveryNode node) {
             final String preflight = validateAdd(node);
             if (preflight != null) {
                 throw new IllegalArgumentException(preflight);
@@ -753,11 +752,11 @@ public Builder add(ProtobufDiscoveryNode node) {
         * @return wanted node if it exists. Otherwise <code>null</code>
         */
         @Nullable
-        public ProtobufDiscoveryNode get(String nodeId) {
+        public DiscoveryNode get(String nodeId) {
             return nodes.get(nodeId);
         }
 
-        private void putUnsafe(ProtobufDiscoveryNode node) {
+        private void putUnsafe(DiscoveryNode node) {
             nodes.put(node.getId(), node);
         }
 
@@ -766,7 +765,7 @@ public Builder remove(String nodeId) {
             return this;
         }
 
-        public Builder remove(ProtobufDiscoveryNode node) {
+        public Builder remove(DiscoveryNode node) {
             if (node.equals(nodes.get(node.getId()))) {
                 nodes.remove(node.getId());
             }
@@ -794,12 +793,12 @@ public Builder localNodeId(String localNodeId) {
         *
         * @return null if all is OK or an error message explaining why a node can not be added.
         *
-        * Note: if this method returns a non-null value, calling {@link #add(ProtobufDiscoveryNode)} will fail with an
+        * Note: if this method returns a non-null value, calling {@link #add(DiscoveryNode)} will fail with an
         * exception
         */
-        private String validateAdd(ProtobufDiscoveryNode node) {
-            for (ObjectCursor<ProtobufDiscoveryNode> cursor : nodes.values()) {
-                final ProtobufDiscoveryNode existingNode = cursor.value;
+        private String validateAdd(DiscoveryNode node) {
+            for (ObjectCursor<DiscoveryNode> cursor : nodes.values()) {
+                final DiscoveryNode existingNode = cursor.value;
                 if (node.getAddress().equals(existingNode.getAddress()) && node.getId().equals(existingNode.getId()) == false) {
                     return "can't add node " + node + ", found existing node " + existingNode + " with same address";
                 }
@@ -815,14 +814,14 @@ private String validateAdd(ProtobufDiscoveryNode node) {
         }
 
         public ProtobufDiscoveryNodes build() {
-            ImmutableOpenMap.Builder<String, ProtobufDiscoveryNode> dataNodesBuilder = ImmutableOpenMap.builder();
-            ImmutableOpenMap.Builder<String, ProtobufDiscoveryNode> clusterManagerNodesBuilder = ImmutableOpenMap.builder();
-            ImmutableOpenMap.Builder<String, ProtobufDiscoveryNode> ingestNodesBuilder = ImmutableOpenMap.builder();
+            ImmutableOpenMap.Builder<String, DiscoveryNode> dataNodesBuilder = ImmutableOpenMap.builder();
+            ImmutableOpenMap.Builder<String, DiscoveryNode> clusterManagerNodesBuilder = ImmutableOpenMap.builder();
+            ImmutableOpenMap.Builder<String, DiscoveryNode> ingestNodesBuilder = ImmutableOpenMap.builder();
             Version minNodeVersion = null;
             Version maxNodeVersion = null;
             Version minNonClientNodeVersion = null;
             Version maxNonClientNodeVersion = null;
-            for (ObjectObjectCursor<String, ProtobufDiscoveryNode> nodeEntry : nodes) {
+            for (ObjectObjectCursor<String, DiscoveryNode> nodeEntry : nodes) {
                 if (nodeEntry.value.isDataNode()) {
                     dataNodesBuilder.put(nodeEntry.key, nodeEntry.value);
                 }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/AllocationId.java b/server/src/main/java/org/opensearch/cluster/routing/AllocationId.java
index 0bc434090b719..3965f1f72f668 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/AllocationId.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/AllocationId.java
@@ -38,11 +38,17 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.xcontent.ObjectParser;
 import org.opensearch.core.xcontent.ToXContentObject;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.Objects;
 
@@ -57,7 +63,7 @@
  *
  * @opensearch.internal
  */
-public class AllocationId implements ToXContentObject, Writeable {
+public class AllocationId implements ToXContentObject, Writeable, ProtobufWriteable {
     private static final String ID_KEY = "id";
     private static final String RELOCATION_ID_KEY = "relocation_id";
 
@@ -94,12 +100,25 @@ public AllocationId build() {
         this.relocationId = in.readOptionalString();
     }
 
+    AllocationId(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        this.id = in.readString();
+        this.relocationId = protobufStreamInput.readOptionalString();
+    }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         out.writeString(this.id);
         out.writeOptionalString(this.relocationId);
     }
 
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        out.writeStringNoTag(this.id);
+        protobufStreamOutput.writeOptionalString(this.relocationId);
+    }
+
     private AllocationId(String id, String relocationId) {
         Objects.requireNonNull(id, "Argument [id] must be non-null");
         this.id = id;
diff --git a/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java b/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java
index 781ca5bb2255a..bbb3ee61d719d 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java
@@ -32,6 +32,8 @@
 
 package org.opensearch.cluster.routing;
 
+import com.google.protobuf.CodedInputStream;
+
 import org.apache.lucene.util.CollectionUtil;
 import org.opensearch.cluster.AbstractDiffable;
 import org.opensearch.cluster.Diff;
@@ -347,6 +349,18 @@ public static IndexRoutingTable readFrom(StreamInput in) throws IOException {
         return builder.build();
     }
 
+    public static IndexRoutingTable readFrom(CodedInputStream in) throws IOException {
+        Index index = new Index(in);
+        Builder builder = new Builder(index);
+
+        int size = in.readInt32();
+        for (int i = 0; i < size; i++) {
+            builder.addIndexShard(IndexShardRoutingTable.Builder.readFromThin(in, index));
+        }
+
+        return builder.build();
+    }
+
     public static Diff<IndexRoutingTable> readDiffFrom(StreamInput in) throws IOException {
         return readDiffFrom(IndexRoutingTable::readFrom, in);
     }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java b/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java
index f9f57eeda4e98..423b841f0939d 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java
@@ -47,6 +47,8 @@
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.node.ResponseCollectorService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -1050,6 +1052,20 @@ public static IndexShardRoutingTable readFromThin(StreamInput in, Index index) t
             return builder.build();
         }
 
+        public static IndexShardRoutingTable readFromThin(CodedInputStream in, Index index) throws IOException {
+            int iShardId = in.readInt32();
+            ShardId shardId = new ShardId(index, iShardId);
+            Builder builder = new Builder(shardId);
+
+            int size = in.readInt32();
+            for (int i = 0; i < size; i++) {
+                ShardRouting shard = new ShardRouting(shardId, in);
+                builder.addShard(shard);
+            }
+
+            return builder.build();
+        }
+
         public static void writeTo(IndexShardRoutingTable indexShard, StreamOutput out) throws IOException {
             indexShard.shardId().getIndex().writeTo(out);
             writeToThin(indexShard, out);
diff --git a/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java b/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java
index d6a67bc714689..9c8328f5a529c 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java
@@ -32,6 +32,8 @@
 
 package org.opensearch.cluster.routing;
 
+import com.google.protobuf.CodedInputStream;
+
 import org.opensearch.cluster.Diff;
 import org.opensearch.cluster.Diffable;
 import org.opensearch.cluster.DiffableUtils;
@@ -382,6 +384,18 @@ public static RoutingTable readFrom(StreamInput in) throws IOException {
         return builder.build();
     }
 
+    public static RoutingTable readFrom(CodedInputStream in) throws IOException {
+        Builder builder = new Builder();
+        builder.version = in.readInt64();
+        int size = in.readInt32();
+        for (int i = 0; i < size; i++) {
+            IndexRoutingTable index = IndexRoutingTable.readFrom(in);
+            builder.add(index);
+        }
+
+        return builder.build();
+    }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         out.writeLong(version);
diff --git a/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java b/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java
index aa893ec735bac..f047ad4d60310 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java
@@ -36,6 +36,9 @@
 import org.opensearch.cluster.routing.RecoverySource.PeerRecoverySource;
 import org.opensearch.cluster.routing.allocation.allocator.BalancedShardsAllocator;
 import org.opensearch.common.Nullable;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
@@ -44,6 +47,9 @@
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
@@ -54,7 +60,7 @@
  *
  * @opensearch.internal
  */
-public class ShardRouting implements Writeable, ToXContentObject {
+public class ShardRouting implements Writeable, ToXContentObject, ProtobufWriteable {
 
     /**
      * Used if shard size is not available
@@ -323,10 +329,35 @@ public ShardRouting(ShardId shardId, StreamInput in) throws IOException {
         targetRelocatingShard = initializeTargetRelocatingShard();
     }
 
+    public ShardRouting(ShardId shardId, CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        this.shardId = shardId;
+        currentNodeId = protobufStreamInput.readOptionalString();
+        relocatingNodeId = protobufStreamInput.readOptionalString();
+        primary = in.readBool();
+        state = ShardRoutingState.fromValue(in.readRawByte());
+        recoverySource = null;
+        unassignedInfo = protobufStreamInput.readOptionalWriteable(UnassignedInfo::new);
+        allocationId = protobufStreamInput.readOptionalWriteable(AllocationId::new);
+        final long shardSize;
+        if (state == ShardRoutingState.RELOCATING || state == ShardRoutingState.INITIALIZING) {
+            shardSize = in.readInt64();
+        } else {
+            shardSize = UNAVAILABLE_EXPECTED_SHARD_SIZE;
+        }
+        expectedShardSize = shardSize;
+        asList = Collections.singletonList(this);
+        targetRelocatingShard = initializeTargetRelocatingShard();
+    }
+
     public ShardRouting(StreamInput in) throws IOException {
         this(new ShardId(in), in);
     }
 
+    public ShardRouting(CodedInputStream in) throws IOException {
+        this(new ShardId(in), in);
+    }
+
     /**
      * Writes shard information to {@link StreamOutput} without writing index name and shard id
      *
@@ -348,12 +379,40 @@ public void writeToThin(StreamOutput out) throws IOException {
         }
     }
 
+    /**
+     * Writes shard information to without writing index name and shard id
+     *
+     * @param out to write shard information to
+     * @throws IOException if something happens during write
+     */
+    public void writeToThin(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        protobufStreamOutput.writeOptionalString(currentNodeId);
+        protobufStreamOutput.writeOptionalString(relocatingNodeId);
+        out.writeBoolNoTag(primary);
+        out.write(state.value());
+        // if (state == ShardRoutingState.UNASSIGNED || state == ShardRoutingState.INITIALIZING) {
+        // recoverySource.writeTo(out);
+        // }
+        protobufStreamOutput.writeOptionalWriteable(unassignedInfo);
+        protobufStreamOutput.writeOptionalWriteable(allocationId);
+        if (state == ShardRoutingState.RELOCATING || state == ShardRoutingState.INITIALIZING) {
+            out.writeInt64NoTag(expectedShardSize);
+        }
+    }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         shardId.writeTo(out);
         writeToThin(out);
     }
 
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        shardId.writeTo(out);
+        writeToThin(out);
+    }
+
     public ShardRouting updateUnassigned(UnassignedInfo unassignedInfo, RecoverySource recoverySource) {
         assert this.unassignedInfo != null : "can only update unassign info if they are already set";
         assert this.unassignedInfo.isDelayed() || (unassignedInfo.isDelayed() == false) : "cannot transition from non-delayed to delayed";
diff --git a/server/src/main/java/org/opensearch/cluster/routing/UnassignedInfo.java b/server/src/main/java/org/opensearch/cluster/routing/UnassignedInfo.java
index a4ecbadc34702..3de86101e3de3 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/UnassignedInfo.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/UnassignedInfo.java
@@ -38,6 +38,9 @@
 import org.opensearch.cluster.routing.allocation.RoutingAllocation;
 import org.opensearch.cluster.routing.allocation.decider.Decision;
 import org.opensearch.common.Nullable;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
@@ -49,10 +52,14 @@
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.time.Instant;
 import java.time.ZoneOffset;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
@@ -64,7 +71,7 @@
  *
  * @opensearch.internal
  */
-public final class UnassignedInfo implements ToXContentFragment, Writeable {
+public final class UnassignedInfo implements ToXContentFragment, Writeable, ProtobufWriteable {
 
     public static final DateFormatter DATE_TIME_FORMATTER = DateFormatter.forPattern("date_optional_time").withZone(ZoneOffset.UTC);
 
@@ -159,7 +166,7 @@ public enum Reason {
      *
      * @opensearch.internal
      */
-    public enum AllocationStatus implements Writeable {
+    public enum AllocationStatus implements Writeable, ProtobufWriteable {
         /**
          * The shard was denied allocation to a node because the allocation deciders all returned a NO decision
          */
@@ -197,6 +204,11 @@ public void writeTo(StreamOutput out) throws IOException {
             out.writeByte(id);
         }
 
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.write(id);
+        }
+
         public static AllocationStatus readFrom(StreamInput in) throws IOException {
             byte id = in.readByte();
             switch (id) {
@@ -217,6 +229,26 @@ public static AllocationStatus readFrom(StreamInput in) throws IOException {
             }
         }
 
+        public static AllocationStatus readFrom(CodedInputStream in) throws IOException {
+            byte id = in.readRawByte();
+            switch (id) {
+                case 0:
+                    return DECIDERS_NO;
+                case 1:
+                    return NO_VALID_SHARD_COPY;
+                case 2:
+                    return DECIDERS_THROTTLED;
+                case 3:
+                    return FETCHING_SHARD_DATA;
+                case 4:
+                    return DELAYED_ALLOCATION;
+                case 5:
+                    return NO_ATTEMPT;
+                default:
+                    throw new IllegalArgumentException("Unknown AllocationStatus value [" + id + "]");
+            }
+        }
+
         public static AllocationStatus fromDecision(Decision.Type decision) {
             Objects.requireNonNull(decision);
             switch (decision) {
@@ -316,6 +348,21 @@ public UnassignedInfo(StreamInput in) throws IOException {
         this.failedNodeIds = Collections.unmodifiableSet(in.readSet(StreamInput::readString));
     }
 
+    public UnassignedInfo(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        this.reason = Reason.values()[(int) in.readRawByte()];
+        this.unassignedTimeMillis = in.readInt64();
+        // As System.nanoTime() cannot be compared across different JVMs, reset it to now.
+        // This means that in cluster-manager fail-over situations, elapsed delay time is forgotten.
+        this.unassignedTimeNanos = System.nanoTime();
+        this.delayed = in.readBool();
+        this.message = protobufStreamInput.readOptionalString();
+        this.failure = protobufStreamInput.readException();
+        this.failedAllocations = in.readInt32();
+        this.lastAllocationStatus = AllocationStatus.readFrom(in);
+        this.failedNodeIds = protobufStreamInput.readCollection(CodedInputStream::readString, HashSet::new, Collections.emptySet());
+    }
+
     public void writeTo(StreamOutput out) throws IOException {
         out.writeByte((byte) reason.ordinal());
         out.writeLong(unassignedTimeMillis);
@@ -328,6 +375,19 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeCollection(failedNodeIds, StreamOutput::writeString);
     }
 
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        out.write((byte) reason.ordinal());
+        out.writeInt64NoTag(unassignedTimeMillis);
+        // Do not serialize unassignedTimeNanos as System.nanoTime() cannot be compared across different JVMs
+        out.writeBoolNoTag(delayed);
+        protobufStreamOutput.writeOptionalString(message);
+        protobufStreamOutput.writeException(failure);
+        out.writeInt32NoTag(failedAllocations);
+        lastAllocationStatus.writeTo(out);
+        protobufStreamOutput.writeCollection(failedNodeIds, CodedOutputStream::writeStringNoTag);
+    }
+
     /**
      * Returns the number of previously failed allocations of this shard.
      */
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterApplier.java b/server/src/main/java/org/opensearch/cluster/service/ClusterApplier.java
index 939feb89b6054..bb03e04568116 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterApplier.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterApplier.java
@@ -33,6 +33,7 @@
 package org.opensearch.cluster.service;
 
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.ProtobufClusterState;
 
 import java.util.function.Supplier;
 
@@ -48,6 +49,12 @@ public interface ClusterApplier {
      */
     void setInitialState(ClusterState initialState);
 
+    /**
+     * Sets the initial state for this applier. Should only be called once.
+     * @param initialState the initial state to set
+     */
+    void setInitialProtobufState(ProtobufClusterState initialState);
+
     /**
      * Method to invoke when a new cluster state is available to be applied
      *
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java b/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
index 57db883a337e8..2b3067b804820 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
@@ -153,6 +153,15 @@ public void setInitialState(ClusterState initialState) {
         state.set(initialState);
     }
 
+    @Override
+    public void setInitialProtobufState(ProtobufClusterState initialState) {
+        if (lifecycle.started()) {
+            throw new IllegalStateException("can't set initial state when started");
+        }
+        assert protobufState.get() == null : "state is already set";
+        protobufState.set(initialState);
+    }
+
     @Override
     protected synchronized void doStart() {
         Objects.requireNonNull(nodeConnectionsService, "please set the node connection service before starting");
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java
index 7742e4578744c..4caed83b07941 100644
--- a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java
+++ b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java
@@ -290,7 +290,7 @@ public <T> List<T> readList(final ProtobufWriteable.Reader<T> reader) throws IOE
     /**
      * Reads a collection of objects
      */
-    private <T, C extends Collection<? super T>> C readCollection(ProtobufWriteable.Reader<T> reader, IntFunction<C> constructor, C empty)
+    public <T, C extends Collection<? super T>> C readCollection(ProtobufWriteable.Reader<T> reader, IntFunction<C> constructor, C empty)
         throws IOException {
         int count = readArraySize();
         if (count == 0) {
diff --git a/server/src/main/java/org/opensearch/common/logging/ProtobufNodeAndClusterIdStateListener.java b/server/src/main/java/org/opensearch/common/logging/ProtobufNodeAndClusterIdStateListener.java
index 4b1be0914747d..a2d9aae67db6c 100644
--- a/server/src/main/java/org/opensearch/common/logging/ProtobufNodeAndClusterIdStateListener.java
+++ b/server/src/main/java/org/opensearch/common/logging/ProtobufNodeAndClusterIdStateListener.java
@@ -36,7 +36,10 @@ public static void getAndSetNodeIdAndClusterId(ClusterService clusterService, Th
         ProtobufClusterState clusterState = clusterService.protobufState();
         ProtobufClusterStateObserver observer = new ProtobufClusterStateObserver(clusterState, clusterService, null, logger, threadContext);
 
-        observer.waitForNextChange(new ProtobufNodeAndClusterIdStateListener(), ProtobufNodeAndClusterIdStateListener::isNodeAndClusterIdPresent);
+        observer.waitForNextChange(
+            new ProtobufNodeAndClusterIdStateListener(),
+            ProtobufNodeAndClusterIdStateListener::isNodeAndClusterIdPresent
+        );
     }
 
     private static boolean isNodeAndClusterIdPresent(ProtobufClusterState clusterState) {
diff --git a/server/src/main/java/org/opensearch/common/network/NetworkModule.java b/server/src/main/java/org/opensearch/common/network/NetworkModule.java
index c9ed9d59cda05..ba348e89ed73b 100644
--- a/server/src/main/java/org/opensearch/common/network/NetworkModule.java
+++ b/server/src/main/java/org/opensearch/common/network/NetworkModule.java
@@ -304,9 +304,9 @@ public AsyncSender interceptSender(AsyncSender sender) {
         }
     }
 
-     /**
-     * Registers a new {@link TransportInterceptor}
-     */
+    /**
+    * Registers a new {@link TransportInterceptor}
+    */
     private void registerProtobufTransportInterceptor(ProtobufTransportInterceptor interceptor) {
         this.protobufTransportInterceptors.add(Objects.requireNonNull(interceptor, "interceptor must not be null"));
     }
diff --git a/server/src/main/java/org/opensearch/common/settings/SettingsModule.java b/server/src/main/java/org/opensearch/common/settings/SettingsModule.java
index 4308e1c3e98fa..dd5502054684a 100644
--- a/server/src/main/java/org/opensearch/common/settings/SettingsModule.java
+++ b/server/src/main/java/org/opensearch/common/settings/SettingsModule.java
@@ -233,7 +233,6 @@ public boolean registerDynamicSetting(Setting<?> setting) {
      * the setting during startup.
      */
     private void registerSetting(Setting<?> setting) {
-        System.out.println("Registering setting: " + setting.getKey());
         if (setting.isFiltered()) {
             if (settingsFilterPattern.contains(setting.getKey()) == false) {
                 registerSettingsFilter(setting.getKey());
diff --git a/server/src/main/java/org/opensearch/common/transport/ProtobufBoundTransportAddress.java b/server/src/main/java/org/opensearch/common/transport/ProtobufBoundTransportAddress.java
index 97de0d42b5592..96ca6719491f7 100644
--- a/server/src/main/java/org/opensearch/common/transport/ProtobufBoundTransportAddress.java
+++ b/server/src/main/java/org/opensearch/common/transport/ProtobufBoundTransportAddress.java
@@ -16,6 +16,7 @@
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
 import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.network.InetAddresses;
 
 import java.io.IOException;
 
@@ -65,4 +66,27 @@ public void writeTo(CodedOutputStream out) throws IOException {
         }
         publishAddress.writeTo(out);
     }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder("publish_address {");
+        String hostString = publishAddress.address().getHostString();
+        String publishAddressString = publishAddress.toString();
+        if (InetAddresses.isInetAddress(hostString) == false) {
+            publishAddressString = hostString + '/' + publishAddress.toString();
+        }
+        builder.append(publishAddressString);
+        builder.append("}, bound_addresses ");
+        boolean firstAdded = false;
+        for (ProtobufTransportAddress address : boundAddresses) {
+            if (firstAdded) {
+                builder.append(", ");
+            } else {
+                firstAdded = true;
+            }
+
+            builder.append("{").append(address).append("}");
+        }
+        return builder.toString();
+    }
 }
diff --git a/server/src/main/java/org/opensearch/common/transport/ProtobufTransportAddress.java b/server/src/main/java/org/opensearch/common/transport/ProtobufTransportAddress.java
index 274c8404e11af..aa34a2f0ec99f 100644
--- a/server/src/main/java/org/opensearch/common/transport/ProtobufTransportAddress.java
+++ b/server/src/main/java/org/opensearch/common/transport/ProtobufTransportAddress.java
@@ -16,6 +16,9 @@
 import com.google.protobuf.CodedOutputStream;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.network.NetworkAddress;
+import org.opensearch.core.xcontent.ToXContent.Params;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
 
 import java.io.IOException;
 import java.net.InetAddress;
@@ -27,7 +30,7 @@
 *
 * @opensearch.internal
 */
-public final class ProtobufTransportAddress implements ProtobufWriteable {
+public final class ProtobufTransportAddress implements ProtobufWriteable, ToXContentFragment {
 
     /**
      * A <a href="https://en.wikipedia.org/wiki/0.0.0.0">non-routeable v4 meta transport address</a> that can be used for
@@ -105,4 +108,27 @@ public int getPort() {
     public InetSocketAddress address() {
         return this.address;
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ProtobufTransportAddress address1 = (ProtobufTransportAddress) o;
+        return address.equals(address1.address);
+    }
+
+    @Override
+    public int hashCode() {
+        return address != null ? address.hashCode() : 0;
+    }
+
+    @Override
+    public String toString() {
+        return NetworkAddress.format(address);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        return builder.value(toString());
+    }
 }
diff --git a/server/src/main/java/org/opensearch/discovery/Discovery.java b/server/src/main/java/org/opensearch/discovery/Discovery.java
index 9d6807b6522c9..9418632d52e1f 100644
--- a/server/src/main/java/org/opensearch/discovery/Discovery.java
+++ b/server/src/main/java/org/opensearch/discovery/Discovery.java
@@ -49,6 +49,11 @@ public interface Discovery extends LifecycleComponent, ClusterStatePublisher {
      */
     DiscoveryStats stats();
 
+    /**
+     * @return stats about the discovery
+     */
+    ProtobufDiscoveryStats protobufStats();
+
     /**
      * Triggers the first join cycle
      */
diff --git a/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java b/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java
index 1d967d9fb135a..f82f380f5858b 100644
--- a/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java
+++ b/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java
@@ -46,6 +46,8 @@
 import org.opensearch.common.transport.BoundTransportAddress;
 import org.opensearch.common.transport.NetworkExceptionHelper;
 import org.opensearch.common.transport.PortsRange;
+import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.common.util.BigArrays;
@@ -155,11 +157,35 @@ public HttpInfo info() {
         return new HttpInfo(boundTransportAddress, maxContentLength.getBytes());
     }
 
+    @Override
+    public ProtobufHttpInfo protobufInfo() {
+        BoundTransportAddress boundTransportAddress = boundAddress();
+        if (boundTransportAddress == null) {
+            return null;
+        }
+        TransportAddress[] transportAddress = boundTransportAddress.boundAddresses();
+        TransportAddress publishAddress = boundTransportAddress.publishAddress();
+        ProtobufTransportAddress[] protobufTransportAddresses = new ProtobufTransportAddress[transportAddress.length];
+        for (int i = 0; i < transportAddress.length; i++) {
+            protobufTransportAddresses[i] = new ProtobufTransportAddress(transportAddress[i].address());
+        }
+        ProtobufBoundTransportAddress protobufBoundTransportAddress = new ProtobufBoundTransportAddress(
+            protobufTransportAddresses,
+            new ProtobufTransportAddress(publishAddress.address())
+        );
+        return new ProtobufHttpInfo(protobufBoundTransportAddress, maxContentLength.getBytes());
+    }
+
     @Override
     public HttpStats stats() {
         return new HttpStats(httpChannels.size(), totalChannelsAccepted.get());
     }
 
+    @Override
+    public ProtobufHttpStats protobufStats() {
+        return new ProtobufHttpStats(httpChannels.size(), totalChannelsAccepted.get());
+    }
+
     protected void bindServer() {
         // Bind and start to accept incoming connections.
         InetAddress hostAddresses[];
@@ -368,7 +394,6 @@ void dispatchRequest(final RestRequest restRequest, final RestChannel channel, f
     }
 
     private void handleIncomingRequest(final HttpRequest httpRequest, final HttpChannel httpChannel, final Exception exception) {
-        System.out.println("HttpServerTransport.handleIncomingRequest");
         if (exception == null) {
             HttpResponse earlyResponse = corsHandler.handleInbound(httpRequest);
             if (earlyResponse != null) {
@@ -442,7 +467,6 @@ private void handleIncomingRequest(final HttpRequest httpRequest, final HttpChan
             channel = innerChannel;
         }
 
-        System.out.println("RestRequest " + restRequest);
         dispatchRequest(restRequest, channel, badRequestCause);
     }
 
diff --git a/server/src/main/java/org/opensearch/http/HttpServerTransport.java b/server/src/main/java/org/opensearch/http/HttpServerTransport.java
index 6549f0786fcda..0d4ac79535c25 100644
--- a/server/src/main/java/org/opensearch/http/HttpServerTransport.java
+++ b/server/src/main/java/org/opensearch/http/HttpServerTransport.java
@@ -35,6 +35,7 @@
 import org.opensearch.common.lifecycle.LifecycleComponent;
 import org.opensearch.common.transport.BoundTransportAddress;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.node.ReportingService;
 import org.opensearch.rest.RestChannel;
 import org.opensearch.rest.RestRequest;
@@ -44,7 +45,7 @@
  *
  * @opensearch.internal
  */
-public interface HttpServerTransport extends LifecycleComponent, ReportingService<HttpInfo> {
+public interface HttpServerTransport extends LifecycleComponent, ReportingService<HttpInfo>, ProtobufReportingService<ProtobufHttpInfo> {
 
     String HTTP_SERVER_WORKER_THREAD_NAME_PREFIX = "http_server_worker";
 
@@ -53,8 +54,13 @@ public interface HttpServerTransport extends LifecycleComponent, ReportingServic
     @Override
     HttpInfo info();
 
+    @Override
+    ProtobufHttpInfo protobufInfo();
+
     HttpStats stats();
 
+    ProtobufHttpStats protobufStats();
+
     /**
      * Dispatches HTTP requests.
      */
diff --git a/server/src/main/java/org/opensearch/http/ProtobufHttpInfo.java b/server/src/main/java/org/opensearch/http/ProtobufHttpInfo.java
index 612c98e7df7e8..fb893000f68ff 100644
--- a/server/src/main/java/org/opensearch/http/ProtobufHttpInfo.java
+++ b/server/src/main/java/org/opensearch/http/ProtobufHttpInfo.java
@@ -15,8 +15,13 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
+
+import org.opensearch.common.logging.DeprecationLogger;
+import org.opensearch.common.network.InetAddresses;
 import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.node.ProtobufReportingService;
 
 import java.io.IOException;
@@ -28,6 +33,11 @@
 */
 public class ProtobufHttpInfo implements ProtobufReportingService.ProtobufInfo {
 
+    private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(ProtobufHttpInfo.class);
+
+    /** Deprecated property, just here for deprecation logging in 7.x. */
+    private static final boolean CNAME_IN_PUBLISH_HOST = System.getProperty("opensearch.http.cname_in_publish_address") != null;
+
     private final ProtobufBoundTransportAddress address;
     private final long maxContentLength;
 
@@ -61,4 +71,35 @@ public ByteSizeValue maxContentLength() {
     public ByteSizeValue getMaxContentLength() {
         return maxContentLength();
     }
+
+    static final class Fields {
+        static final String HTTP = "http";
+        static final String BOUND_ADDRESS = "bound_address";
+        static final String PUBLISH_ADDRESS = "publish_address";
+        static final String MAX_CONTENT_LENGTH = "max_content_length";
+        static final String MAX_CONTENT_LENGTH_IN_BYTES = "max_content_length_in_bytes";
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.HTTP);
+        builder.array(Fields.BOUND_ADDRESS, (Object[]) address.boundAddresses());
+        ProtobufTransportAddress publishAddress = address.publishAddress();
+        String publishAddressString = publishAddress.toString();
+        String hostString = publishAddress.address().getHostString();
+        if (CNAME_IN_PUBLISH_HOST) {
+            deprecationLogger.deprecate(
+                "cname_in_publish_address",
+                "opensearch.http.cname_in_publish_address system property is deprecated and no longer affects http.publish_address "
+                    + "formatting. Remove this property to get rid of this deprecation warning."
+            );
+        }
+        if (InetAddresses.isInetAddress(hostString) == false) {
+            publishAddressString = hostString + '/' + publishAddress.toString();
+        }
+        builder.field(Fields.PUBLISH_ADDRESS, publishAddressString);
+        builder.humanReadableField(Fields.MAX_CONTENT_LENGTH_IN_BYTES, Fields.MAX_CONTENT_LENGTH, maxContentLength());
+        builder.endObject();
+        return builder;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/index/cache/request/ShardRequestCache.java b/server/src/main/java/org/opensearch/index/cache/request/ShardRequestCache.java
index c3c552b5f732d..20724474e5fb5 100644
--- a/server/src/main/java/org/opensearch/index/cache/request/ShardRequestCache.java
+++ b/server/src/main/java/org/opensearch/index/cache/request/ShardRequestCache.java
@@ -52,6 +52,10 @@ public RequestCacheStats stats() {
         return new RequestCacheStats(totalMetric.count(), evictionsMetric.count(), hitCount.count(), missCount.count());
     }
 
+    public ProtobufRequestCacheStats protobufStats() {
+        return new ProtobufRequestCacheStats(totalMetric.count(), evictionsMetric.count(), hitCount.count(), missCount.count());
+    }
+
     public void onHit() {
         hitCount.inc();
     }
diff --git a/server/src/main/java/org/opensearch/index/engine/CommitStats.java b/server/src/main/java/org/opensearch/index/engine/CommitStats.java
index 2c78f675c5154..d52342742a442 100644
--- a/server/src/main/java/org/opensearch/index/engine/CommitStats.java
+++ b/server/src/main/java/org/opensearch/index/engine/CommitStats.java
@@ -33,6 +33,9 @@
 
 import org.apache.lucene.index.SegmentInfos;
 import org.opensearch.common.collect.MapBuilder;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
@@ -40,6 +43,9 @@
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.Base64;
 import java.util.Map;
@@ -49,7 +55,7 @@
  *
  * @opensearch.internal
  */
-public final class CommitStats implements Writeable, ToXContentFragment {
+public final class CommitStats implements Writeable, ToXContentFragment, ProtobufWriteable {
 
     private final Map<String, String> userData;
     private final long generation;
@@ -76,10 +82,27 @@ public CommitStats(SegmentInfos segmentInfos) {
         numDocs = in.readInt();
     }
 
+    CommitStats(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        MapBuilder<String, String> builder = MapBuilder.newMapBuilder();
+        for (int i = in.readInt32(); i > 0; i--) {
+            builder.put(in.readString(), in.readString());
+        }
+        userData = builder.immutableMap();
+        generation = in.readInt64();
+        id = protobufStreamInput.readOptionalString();
+        numDocs = in.readInt32();
+    }
+
     public static CommitStats readOptionalCommitStatsFrom(StreamInput in) throws IOException {
         return in.readOptionalWriteable(CommitStats::new);
     }
 
+    public static CommitStats readOptionalCommitStatsFromProtobuf(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        return protobufStreamInput.readOptionalWriteable(CommitStats::new);
+    }
+
     public Map<String, String> getUserData() {
         return userData;
     }
@@ -112,6 +135,19 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeInt(numDocs);
     }
 
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        out.writeInt32NoTag(userData.size());
+        for (Map.Entry<String, String> entry : userData.entrySet()) {
+            out.writeStringNoTag(entry.getKey());
+            out.writeStringNoTag(entry.getValue());
+        }
+        out.writeInt64NoTag(generation);
+        protobufStreamOutput.writeOptionalString(id);
+        out.writeInt32NoTag(numDocs);
+    }
+
     /**
      * Fields used for parsing and toXContent
      *
diff --git a/server/src/main/java/org/opensearch/index/engine/Engine.java b/server/src/main/java/org/opensearch/index/engine/Engine.java
index 74c9c25dc4c1f..1c878a4a78238 100644
--- a/server/src/main/java/org/opensearch/index/engine/Engine.java
+++ b/server/src/main/java/org/opensearch/index/engine/Engine.java
@@ -81,10 +81,12 @@
 import org.opensearch.index.mapper.ParsedDocument;
 import org.opensearch.index.mapper.SeqNoFieldMapper;
 import org.opensearch.index.merge.MergeStats;
+import org.opensearch.index.merge.ProtobufMergeStats;
 import org.opensearch.index.seqno.SeqNoStats;
 import org.opensearch.index.seqno.SequenceNumbers;
 import org.opensearch.index.shard.DocsStats;
 import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.index.shard.ProtobufDocsStats;
 import org.opensearch.index.store.Store;
 import org.opensearch.index.translog.Translog;
 import org.opensearch.index.translog.TranslogManager;
@@ -205,6 +207,10 @@ public MergeStats getMergeStats() {
         return new MergeStats();
     }
 
+    public ProtobufMergeStats getProtobufMergeStats() {
+        return new ProtobufMergeStats();
+    }
+
     /** returns the history uuid for the engine */
     public abstract String getHistoryUUID();
 
@@ -262,6 +268,41 @@ protected final DocsStats docsStats(IndexReader indexReader) {
         return new DocsStats(numDocs, numDeletedDocs, sizeInBytes);
     }
 
+    /**
+     * Returns the {@link DocsStats} for this engine
+     */
+    public ProtobufDocsStats protobufDocsStats() {
+        // we calculate the doc stats based on the internal searcher that is more up-to-date and not subject
+        // to external refreshes. For instance we don't refresh an external searcher if we flush and indices with
+        // index.refresh_interval=-1 won't see any doc stats updates at all. This change will give more accurate statistics
+        // when indexing but not refreshing in general. Yet, if a refresh happens the internal searcher is refresh as well so we are
+        // safe here.
+        try (Searcher searcher = acquireSearcher("docStats", SearcherScope.INTERNAL)) {
+            return protobufDocsStats(searcher.getIndexReader());
+        }
+    }
+
+    protected final ProtobufDocsStats protobufDocsStats(IndexReader indexReader) {
+        long numDocs = 0;
+        long numDeletedDocs = 0;
+        long sizeInBytes = 0;
+        // we don't wait for a pending refreshes here since it's a stats call instead we mark it as accessed only which will cause
+        // the next scheduled refresh to go through and refresh the stats as well
+        for (LeafReaderContext readerContext : indexReader.leaves()) {
+            // we go on the segment level here to get accurate numbers
+            final SegmentReader segmentReader = Lucene.segmentReader(readerContext.reader());
+            SegmentCommitInfo info = segmentReader.getSegmentInfo();
+            numDocs += readerContext.reader().numDocs();
+            numDeletedDocs += readerContext.reader().numDeletedDocs();
+            try {
+                sizeInBytes += info.sizeInBytes();
+            } catch (IOException e) {
+                logger.trace(() -> new ParameterizedMessage("failed to get size for [{}]", info.info.name), e);
+            }
+        }
+        return new ProtobufDocsStats(numDocs, numDeletedDocs, sizeInBytes);
+    }
+
     /**
      * Performs the pre-closing checks on the {@link Engine}.
      *
@@ -926,6 +967,34 @@ public SegmentsStats segmentsStats(boolean includeSegmentFileSizes, boolean incl
         return stats;
     }
 
+    /**
+     * Global stats on segments.
+     */
+    public ProtobufSegmentsStats protobufSegmentsStats(boolean includeSegmentFileSizes, boolean includeUnloadedSegments) {
+        ensureOpen();
+        Set<String> segmentName = new HashSet<>();
+        ProtobufSegmentsStats stats = new ProtobufSegmentsStats();
+        try (Searcher searcher = acquireSearcher("segments_stats", SearcherScope.INTERNAL)) {
+            for (LeafReaderContext ctx : searcher.getIndexReader().getContext().leaves()) {
+                SegmentReader segmentReader = Lucene.segmentReader(ctx.reader());
+                protobufFillSegmentStats(segmentReader, includeSegmentFileSizes, stats);
+                segmentName.add(segmentReader.getSegmentName());
+            }
+        }
+
+        try (Searcher searcher = acquireSearcher("segments_stats", SearcherScope.EXTERNAL)) {
+            for (LeafReaderContext ctx : searcher.getIndexReader().getContext().leaves()) {
+                SegmentReader segmentReader = Lucene.segmentReader(ctx.reader());
+                if (segmentName.contains(segmentReader.getSegmentName()) == false) {
+                    protobufFillSegmentStats(segmentReader, includeSegmentFileSizes, stats);
+                }
+            }
+        }
+        stats.addVersionMapMemoryInBytes(0);
+        stats.addIndexWriterMemoryInBytes(0);
+        return stats;
+    }
+
     protected TranslogDeletionPolicy getTranslogDeletionPolicy(EngineConfig engineConfig) {
         TranslogDeletionPolicy customTranslogDeletionPolicy = null;
         if (engineConfig.getCustomTranslogDeletionPolicyFactory() != null) {
@@ -950,6 +1019,14 @@ protected void fillSegmentStats(SegmentReader segmentReader, boolean includeSegm
         }
     }
 
+    protected void protobufFillSegmentStats(SegmentReader segmentReader, boolean includeSegmentFileSizes, ProtobufSegmentsStats stats) {
+        stats.add(1);
+        if (includeSegmentFileSizes) {
+            // TODO: consider moving this to StoreStats
+            stats.addFileSizes(getSegmentFileSizes(segmentReader));
+        }
+    }
+
     private Map<String, Long> getSegmentFileSizes(SegmentReader segmentReader) {
         Directory directory = null;
         SegmentCommitInfo segmentCommitInfo = segmentReader.getSegmentInfo();
diff --git a/server/src/main/java/org/opensearch/index/fielddata/ShardFieldData.java b/server/src/main/java/org/opensearch/index/fielddata/ShardFieldData.java
index 138b417571784..b786e625228a6 100644
--- a/server/src/main/java/org/opensearch/index/fielddata/ShardFieldData.java
+++ b/server/src/main/java/org/opensearch/index/fielddata/ShardFieldData.java
@@ -34,6 +34,7 @@
 
 import org.apache.lucene.util.Accountable;
 import org.opensearch.common.FieldMemoryStats;
+import org.opensearch.common.ProtobufFieldMemoryStats;
 import org.opensearch.common.metrics.CounterMetric;
 import org.opensearch.common.regex.Regex;
 import org.opensearch.common.util.CollectionUtils;
@@ -72,6 +73,23 @@ public FieldDataStats stats(String... fields) {
         );
     }
 
+    public ProtobufFieldDataStats protobufStats(String... fields) {
+        ObjectLongHashMap<String> fieldTotals = null;
+        if (CollectionUtils.isEmpty(fields) == false) {
+            fieldTotals = new ObjectLongHashMap<>();
+            for (Map.Entry<String, CounterMetric> entry : perFieldTotals.entrySet()) {
+                if (Regex.simpleMatch(fields, entry.getKey())) {
+                    fieldTotals.put(entry.getKey(), entry.getValue().count());
+                }
+            }
+        }
+        return new ProtobufFieldDataStats(
+            totalMetric.count(),
+            evictionsMetric.count(),
+            fieldTotals == null ? null : new ProtobufFieldMemoryStats(fieldTotals)
+        );
+    }
+
     @Override
     public void onCache(ShardId shardId, String fieldName, Accountable ramUsage) {
         totalMetric.inc(ramUsage.ramBytesUsed());
diff --git a/server/src/main/java/org/opensearch/index/get/ShardGetService.java b/server/src/main/java/org/opensearch/index/get/ShardGetService.java
index 8f81e704ef2d4..86df8a72ab18c 100644
--- a/server/src/main/java/org/opensearch/index/get/ShardGetService.java
+++ b/server/src/main/java/org/opensearch/index/get/ShardGetService.java
@@ -113,6 +113,16 @@ public GetStats stats() {
         );
     }
 
+    public ProtobufGetStats protobufStats() {
+        return new ProtobufGetStats(
+            existsMetric.count(),
+            TimeUnit.NANOSECONDS.toMillis(existsMetric.sum()),
+            missingMetric.count(),
+            TimeUnit.NANOSECONDS.toMillis(missingMetric.sum()),
+            currentMetric.count()
+        );
+    }
+
     public GetResult get(
         String id,
         String[] gFields,
diff --git a/server/src/main/java/org/opensearch/index/search/stats/ShardSearchStats.java b/server/src/main/java/org/opensearch/index/search/stats/ShardSearchStats.java
index 6d0eb3a5949ca..a1a96a367e4f2 100644
--- a/server/src/main/java/org/opensearch/index/search/stats/ShardSearchStats.java
+++ b/server/src/main/java/org/opensearch/index/search/stats/ShardSearchStats.java
@@ -84,6 +84,31 @@ public SearchStats stats(String... groups) {
         return new SearchStats(total, openContexts.count(), groupsSt);
     }
 
+    /**
+     * Returns the stats, including group specific stats. If the groups are null/0 length, then nothing
+     * is returned for them. If they are set, then only groups provided will be returned, or
+     * {@code _all} for all groups.
+     */
+    public ProtobufSearchStats protobufStats(String... groups) {
+        ProtobufSearchStats.Stats total = totalStats.protobufStats();
+        Map<String, ProtobufSearchStats.Stats> groupsSt = null;
+        if (CollectionUtils.isEmpty(groups) == false) {
+            groupsSt = new HashMap<>(groupsStats.size());
+            if (groups.length == 1 && groups[0].equals("_all")) {
+                for (Map.Entry<String, StatsHolder> entry : groupsStats.entrySet()) {
+                    groupsSt.put(entry.getKey(), entry.getValue().protobufStats());
+                }
+            } else {
+                for (Map.Entry<String, StatsHolder> entry : groupsStats.entrySet()) {
+                    if (Regex.simpleMatch(groups, entry.getKey())) {
+                        groupsSt.put(entry.getKey(), entry.getValue().protobufStats());
+                    }
+                }
+            }
+        }
+        return new ProtobufSearchStats(total, openContexts.count(), groupsSt);
+    }
+
     @Override
     public void onPreQueryPhase(SearchContext searchContext) {
         computeStats(searchContext, statsHolder -> {
@@ -242,5 +267,25 @@ SearchStats.Stats stats() {
                 suggestCurrent.count()
             );
         }
+
+        ProtobufSearchStats.Stats protobufStats() {
+            return new ProtobufSearchStats.Stats(
+                queryMetric.count(),
+                TimeUnit.NANOSECONDS.toMillis(queryMetric.sum()),
+                queryCurrent.count(),
+                fetchMetric.count(),
+                TimeUnit.NANOSECONDS.toMillis(fetchMetric.sum()),
+                fetchCurrent.count(),
+                scrollMetric.count(),
+                TimeUnit.MICROSECONDS.toMillis(scrollMetric.sum()),
+                scrollCurrent.count(),
+                pitMetric.count(),
+                TimeUnit.MICROSECONDS.toMillis(pitMetric.sum()),
+                pitCurrent.count(),
+                suggestMetric.count(),
+                TimeUnit.NANOSECONDS.toMillis(suggestMetric.sum()),
+                suggestCurrent.count()
+            );
+        }
     }
 }
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java
index 5d4483e4a2930..27e4aa2285e6e 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java
@@ -33,6 +33,7 @@
 package org.opensearch.index.seqno;
 
 import org.opensearch.core.ParseField;
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
@@ -40,6 +41,10 @@
 import org.opensearch.core.xcontent.ToXContentObject;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import org.opensearch.core.xcontent.XContent;
 
 import java.io.IOException;
@@ -53,7 +58,7 @@
  *
  * @opensearch.internal
  */
-public final class RetentionLease implements ToXContentObject, Writeable {
+public final class RetentionLease implements ToXContentObject, Writeable, ProtobufWriteable {
 
     private final String id;
 
@@ -156,6 +161,33 @@ public void writeTo(final StreamOutput out) throws IOException {
         out.writeString(source);
     }
 
+    /**
+     * Constructs a new retention lease from a stream. The retention lease should have been written.
+     *
+     * @param in the stream to construct the retention lease from
+     * @throws IOException if an I/O exception occurs reading from the stream
+     */
+    public RetentionLease(final CodedInputStream in) throws IOException {
+        id = in.readString();
+        retainingSequenceNumber = in.readInt64();
+        timestamp = in.readInt64();
+        source = in.readString();
+    }
+
+    /**
+     * Writes a retention lease to a stream in a manner suitable for later reconstruction.
+     *
+     * @param out the stream to write the retention lease to
+     * @throws IOException if an I/O exception occurs writing to the stream
+     */
+    @Override
+    public void writeTo(final CodedOutputStream out) throws IOException {
+        out.writeStringNoTag(id);
+        out.writeInt64NoTag(retainingSequenceNumber);
+        out.writeInt64NoTag(timestamp);
+        out.writeStringNoTag(source);
+    }
+
     private static final ParseField ID_FIELD = new ParseField("id");
     private static final ParseField RETAINING_SEQUENCE_NUMBER_FIELD = new ParseField("retaining_sequence_number");
     private static final ParseField TIMESTAMP_FIELD = new ParseField("timestamp");
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java
index a1ed615b83a14..845900a86d31d 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java
@@ -32,11 +32,16 @@
 
 package org.opensearch.index.seqno;
 
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import org.opensearch.core.xcontent.XContent;
 
 import java.io.IOException;
@@ -47,7 +52,7 @@
  *
  * @opensearch.internal
  */
-public final class RetentionLeaseStats implements ToXContentFragment, Writeable {
+public final class RetentionLeaseStats implements ToXContentFragment, Writeable, ProtobufWriteable {
 
     private final RetentionLeases retentionLeases;
 
@@ -92,6 +97,27 @@ public void writeTo(final StreamOutput out) throws IOException {
         retentionLeases.writeTo(out);
     }
 
+    /**
+     * Constructs a new retention lease stats object from a stream. The retention lease stats should have been written.
+     *
+     * @param in the stream to construct the retention lease stats from
+     * @throws IOException if an I/O exception occurs reading from the stream
+     */
+    public RetentionLeaseStats(final CodedInputStream in) throws IOException {
+        retentionLeases = new RetentionLeases(in);
+    }
+
+    /**
+     * Writes a retention lease stats object to a stream in a manner suitable for later reconstruction.
+     *
+     * @param out the stream to write the retention lease stats to
+     * @throws IOException if an I/O exception occurs writing to the stream
+     */
+    @Override
+    public void writeTo(final CodedOutputStream out) throws IOException {
+        retentionLeases.writeTo(out);
+    }
+
     /**
      * Converts the retention lease stats to {@link XContent} using the specified builder and pararms.
      *
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeases.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeases.java
index a764ca3e7a581..753ab4eb81d2d 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeases.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeases.java
@@ -33,6 +33,9 @@
 package org.opensearch.index.seqno;
 
 import org.opensearch.core.ParseField;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
@@ -44,6 +47,9 @@
 import org.opensearch.core.xcontent.XContent;
 import org.opensearch.gateway.MetadataStateFormat;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.Collection;
 import java.util.Collections;
@@ -59,7 +65,7 @@
  *
  * @opensearch.internal
  */
-public class RetentionLeases implements ToXContentFragment, Writeable {
+public class RetentionLeases implements ToXContentFragment, Writeable, ProtobufWriteable {
 
     private final long primaryTerm;
 
@@ -193,6 +199,33 @@ public void writeTo(final StreamOutput out) throws IOException {
         out.writeCollection(leases.values());
     }
 
+    /**
+     * Constructs a new retention lease collection from a stream. The retention lease collection should have been written.
+     *
+     * @param in the stream to construct the retention lease collection from
+     * @throws IOException if an I/O exception occurs reading from the stream
+     */
+    public RetentionLeases(final CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        primaryTerm = in.readInt64();
+        version = in.readInt64();
+        leases = Collections.unmodifiableMap(toMap(protobufStreamInput.readList(RetentionLease::new)));
+    }
+
+    /**
+     * Writes a retention lease collection to a stream in a manner suitable for later reconstruction.
+     *
+     * @param out the stream to write the retention lease collection to
+     * @throws IOException if an I/O exception occurs writing to the stream
+     */
+    @Override
+    public void writeTo(final CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        out.writeInt64NoTag(primaryTerm);
+        out.writeInt64NoTag(version);
+        protobufStreamOutput.writeCollection(leases.values(), (o, v) -> v.writeTo(o));
+    }
+
     private static final ParseField PRIMARY_TERM_FIELD = new ParseField("primary_term");
     private static final ParseField VERSION_FIELD = new ParseField("version");
     private static final ParseField LEASES_FIELD = new ParseField("leases");
diff --git a/server/src/main/java/org/opensearch/index/seqno/SeqNoStats.java b/server/src/main/java/org/opensearch/index/seqno/SeqNoStats.java
index be7888ada2801..01a05263851e7 100644
--- a/server/src/main/java/org/opensearch/index/seqno/SeqNoStats.java
+++ b/server/src/main/java/org/opensearch/index/seqno/SeqNoStats.java
@@ -32,12 +32,16 @@
 
 package org.opensearch.index.seqno;
 
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.Objects;
 
@@ -46,7 +50,7 @@
  *
  * @opensearch.internal
  */
-public class SeqNoStats implements ToXContentFragment, Writeable {
+public class SeqNoStats implements ToXContentFragment, Writeable, ProtobufWriteable {
 
     private static final String SEQ_NO = "seq_no";
     private static final String MAX_SEQ_NO = "max_seq_no";
@@ -70,6 +74,10 @@ public SeqNoStats(StreamInput in) throws IOException {
         this(in.readZLong(), in.readZLong(), in.readZLong());
     }
 
+    public SeqNoStats(CodedInputStream in) throws IOException {
+        this(in.readInt64(), in.readInt64(), in.readInt64());
+    }
+
     /** the maximum sequence number seen so far */
     public long getMaxSeqNo() {
         return maxSeqNo;
@@ -91,6 +99,13 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeZLong(globalCheckpoint);
     }
 
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt64NoTag(maxSeqNo);
+        out.writeInt64NoTag(localCheckpoint);
+        out.writeInt64NoTag(globalCheckpoint);
+    }
+
     @Override
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
         builder.startObject(SEQ_NO);
diff --git a/server/src/main/java/org/opensearch/index/shard/IndexShard.java b/server/src/main/java/org/opensearch/index/shard/IndexShard.java
index 2b85193275a13..316f6c37d1cd3 100644
--- a/server/src/main/java/org/opensearch/index/shard/IndexShard.java
+++ b/server/src/main/java/org/opensearch/index/shard/IndexShard.java
@@ -123,15 +123,19 @@
 import org.opensearch.index.engine.EngineException;
 import org.opensearch.index.engine.EngineFactory;
 import org.opensearch.index.engine.NRTReplicationEngine;
+import org.opensearch.index.engine.ProtobufSegmentsStats;
 import org.opensearch.index.engine.ReadOnlyEngine;
 import org.opensearch.index.engine.RefreshFailedEngineException;
 import org.opensearch.index.engine.SafeCommitInfo;
 import org.opensearch.index.engine.Segment;
 import org.opensearch.index.engine.SegmentsStats;
 import org.opensearch.index.fielddata.FieldDataStats;
+import org.opensearch.index.fielddata.ProtobufFieldDataStats;
 import org.opensearch.index.fielddata.ShardFieldData;
 import org.opensearch.index.flush.FlushStats;
+import org.opensearch.index.flush.ProtobufFlushStats;
 import org.opensearch.index.get.GetStats;
+import org.opensearch.index.get.ProtobufGetStats;
 import org.opensearch.index.get.ShardGetService;
 import org.opensearch.index.mapper.DocumentMapper;
 import org.opensearch.index.mapper.DocumentMapperForType;
@@ -143,8 +147,12 @@
 import org.opensearch.index.mapper.SourceToParse;
 import org.opensearch.index.mapper.Uid;
 import org.opensearch.index.merge.MergeStats;
+import org.opensearch.index.merge.ProtobufMergeStats;
+import org.opensearch.index.recovery.ProtobufRecoveryStats;
 import org.opensearch.index.recovery.RecoveryStats;
+import org.opensearch.index.refresh.ProtobufRefreshStats;
 import org.opensearch.index.refresh.RefreshStats;
+import org.opensearch.index.search.stats.ProtobufSearchStats;
 import org.opensearch.index.remote.RemoteRefreshSegmentPressureService;
 import org.opensearch.index.search.stats.SearchStats;
 import org.opensearch.index.search.stats.ShardSearchStats;
@@ -157,6 +165,7 @@
 import org.opensearch.index.seqno.SequenceNumbers;
 import org.opensearch.index.shard.PrimaryReplicaSyncer.ResyncTask;
 import org.opensearch.index.similarity.SimilarityService;
+import org.opensearch.index.store.ProtobufStoreStats;
 import org.opensearch.index.store.RemoteSegmentStoreDirectory;
 import org.opensearch.index.store.Store;
 import org.opensearch.index.store.Store.MetadataSnapshot;
@@ -170,6 +179,7 @@
 import org.opensearch.index.translog.TranslogFactory;
 import org.opensearch.index.translog.TranslogRecoveryRunner;
 import org.opensearch.index.translog.TranslogStats;
+import org.opensearch.index.warmer.ProtobufWarmerStats;
 import org.opensearch.index.warmer.ShardIndexWarmerService;
 import org.opensearch.index.warmer.WarmerStats;
 import org.opensearch.indices.IndexingMemoryController;
@@ -290,6 +300,7 @@ Runnable getGlobalCheckpointSyncer() {
     private volatile RecoveryState recoveryState;
 
     private final RecoveryStats recoveryStats = new RecoveryStats();
+    private final ProtobufRecoveryStats protobufRecoveryStats = new ProtobufRecoveryStats();
     private final MeanMetric refreshMetric = new MeanMetric();
     private final MeanMetric externalRefreshMetric = new MeanMetric();
     private final MeanMetric flushMetric = new MeanMetric();
@@ -1292,15 +1303,35 @@ public RefreshStats refreshStats() {
         );
     }
 
+    public ProtobufRefreshStats protobufRefreshStats() {
+        int listeners = refreshListeners.pendingCount();
+        return new ProtobufRefreshStats(
+            refreshMetric.count(),
+            TimeUnit.NANOSECONDS.toMillis(refreshMetric.sum()),
+            externalRefreshMetric.count(),
+            TimeUnit.NANOSECONDS.toMillis(externalRefreshMetric.sum()),
+            listeners
+        );
+    }
+
     public FlushStats flushStats() {
         return new FlushStats(flushMetric.count(), periodicFlushMetric.count(), TimeUnit.NANOSECONDS.toMillis(flushMetric.sum()));
     }
 
+    public ProtobufFlushStats protobufFlushStats() {
+        return new ProtobufFlushStats(flushMetric.count(), periodicFlushMetric.count(), TimeUnit.NANOSECONDS.toMillis(flushMetric.sum()));
+    }
+
     public DocsStats docStats() {
         readAllowed();
         return getEngine().docStats();
     }
 
+    public ProtobufDocsStats protobufDocsStats() {
+        readAllowed();
+        return getEngine().protobufDocsStats();
+    }
+
     /**
      * @return {@link CommitStats}
      * @throws AlreadyClosedException if shard is closed
@@ -1331,14 +1362,36 @@ public IndexingStats indexingStats() {
         return internalIndexingStats.stats(throttled, throttleTimeInMillis);
     }
 
+    public ProtobufIndexingStats protobufIndexingStats() {
+        Engine engine = getEngineOrNull();
+        final boolean throttled;
+        final long throttleTimeInMillis;
+        if (engine == null) {
+            throttled = false;
+            throttleTimeInMillis = 0;
+        } else {
+            throttled = engine.isThrottled();
+            throttleTimeInMillis = engine.getIndexThrottleTimeInMillis();
+        }
+        return internalIndexingStats.protobufStats(throttled, throttleTimeInMillis);
+    }
+
     public SearchStats searchStats(String... groups) {
         return searchStats.stats(groups);
     }
 
+    public ProtobufSearchStats protobufSearchStats(String... groups) {
+        return searchStats.protobufStats(groups);
+    }
+
     public GetStats getStats() {
         return getService.stats();
     }
 
+    public ProtobufGetStats getProtobufStats() {
+        return getService.protobufStats();
+    }
+
     public StoreStats storeStats() {
         try {
             final RecoveryState recoveryState = this.recoveryState;
@@ -1350,6 +1403,17 @@ public StoreStats storeStats() {
         }
     }
 
+    public ProtobufStoreStats protobufStoreStats() {
+        try {
+            final RecoveryState recoveryState = this.recoveryState;
+            final long bytesStillToRecover = recoveryState == null ? -1L : recoveryState.getIndex().bytesStillToRecover();
+            return store.protobufStats(bytesStillToRecover == -1 ? StoreStats.UNKNOWN_RESERVED_BYTES : bytesStillToRecover);
+        } catch (IOException e) {
+            failShard("Failing shard because of exception during storeStats", e);
+            throw new OpenSearchException("io exception while building 'store stats'", e);
+        }
+    }
+
     public MergeStats mergeStats() {
         final Engine engine = getEngineOrNull();
         if (engine == null) {
@@ -1358,20 +1422,42 @@ public MergeStats mergeStats() {
         return engine.getMergeStats();
     }
 
+    public ProtobufMergeStats protobufMergeStats() {
+        final Engine engine = getEngineOrNull();
+        if (engine == null) {
+            return new ProtobufMergeStats();
+        }
+        return engine.getProtobufMergeStats();
+    }
+
     public SegmentsStats segmentStats(boolean includeSegmentFileSizes, boolean includeUnloadedSegments) {
         SegmentsStats segmentsStats = getEngine().segmentsStats(includeSegmentFileSizes, includeUnloadedSegments);
         segmentsStats.addBitsetMemoryInBytes(shardBitsetFilterCache.getMemorySizeInBytes());
         return segmentsStats;
     }
 
+    public ProtobufSegmentsStats protobufSegmentStats(boolean includeSegmentFileSizes, boolean includeUnloadedSegments) {
+        ProtobufSegmentsStats segmentsStats = getEngine().protobufSegmentsStats(includeSegmentFileSizes, includeUnloadedSegments);
+        segmentsStats.addBitsetMemoryInBytes(shardBitsetFilterCache.getMemorySizeInBytes());
+        return segmentsStats;
+    }
+
     public WarmerStats warmerStats() {
         return shardWarmerService.stats();
     }
 
+    public ProtobufWarmerStats protobufWarmerStats() {
+        return shardWarmerService.protobufStats();
+    }
+
     public FieldDataStats fieldDataStats(String... fields) {
         return shardFieldData.stats(fields);
     }
 
+    public ProtobufFieldDataStats protobufFieldDataStats(String... fields) {
+        return shardFieldData.protobufStats(fields);
+    }
+
     public TranslogStats translogStats() {
         return getEngine().translogManager().getTranslogStats();
     }
@@ -2413,6 +2499,13 @@ public RecoveryStats recoveryStats() {
         return recoveryStats;
     }
 
+    /**
+     * returns stats about ongoing recoveries, both source and target
+     */
+    public ProtobufRecoveryStats protobufRecoveryStats() {
+        return protobufRecoveryStats;
+    }
+
     /**
      * Returns the current {@link RecoveryState} if this shard is recovering or has been recovering.
      * Returns null if the recovery has not yet started or shard was not recovered (created via an API).
diff --git a/server/src/main/java/org/opensearch/index/shard/InternalIndexingStats.java b/server/src/main/java/org/opensearch/index/shard/InternalIndexingStats.java
index d7e15dd3e40f5..19beb43ee5111 100644
--- a/server/src/main/java/org/opensearch/index/shard/InternalIndexingStats.java
+++ b/server/src/main/java/org/opensearch/index/shard/InternalIndexingStats.java
@@ -58,6 +58,16 @@ IndexingStats stats(boolean isThrottled, long currentThrottleInMillis) {
         return new IndexingStats(total);
     }
 
+    /**
+     * Returns the stats, including type specific stats. If the types are null/0 length, then nothing
+     * is returned for them. If they are set, then only types provided will be returned, or
+     * {@code _all} for all types.
+     */
+    ProtobufIndexingStats protobufStats(boolean isThrottled, long currentThrottleInMillis) {
+        ProtobufIndexingStats.Stats total = totalStats.protobufStats(isThrottled, currentThrottleInMillis);
+        return new ProtobufIndexingStats(total);
+    }
+
     @Override
     public Engine.Index preIndex(ShardId shardId, Engine.Index operation) {
         if (operation.origin().isRecovery() == false) {
@@ -157,5 +167,20 @@ IndexingStats.Stats stats(boolean isThrottled, long currentThrottleMillis) {
                 TimeUnit.MILLISECONDS.toMillis(currentThrottleMillis)
             );
         }
+
+        ProtobufIndexingStats.Stats protobufStats(boolean isThrottled, long currentThrottleMillis) {
+            return new ProtobufIndexingStats.Stats(
+                indexMetric.count(),
+                TimeUnit.NANOSECONDS.toMillis(indexMetric.sum()),
+                indexCurrent.count(),
+                indexFailed.count(),
+                deleteMetric.count(),
+                TimeUnit.NANOSECONDS.toMillis(deleteMetric.sum()),
+                deleteCurrent.count(),
+                noopUpdates.count(),
+                isThrottled,
+                TimeUnit.MILLISECONDS.toMillis(currentThrottleMillis)
+            );
+        }
     }
 }
diff --git a/server/src/main/java/org/opensearch/index/store/Store.java b/server/src/main/java/org/opensearch/index/store/Store.java
index 921deae41946a..e31b87348b4e9 100644
--- a/server/src/main/java/org/opensearch/index/store/Store.java
+++ b/server/src/main/java/org/opensearch/index/store/Store.java
@@ -482,6 +482,14 @@ public StoreStats stats(long reservedBytes) throws IOException {
         return new StoreStats(directory.estimateSize(), reservedBytes);
     }
 
+    /**
+     * @param reservedBytes a prediction of how much larger the store is expected to grow, or {@link StoreStats#UNKNOWN_RESERVED_BYTES}.
+     */
+    public ProtobufStoreStats protobufStats(long reservedBytes) throws IOException {
+        ensureOpen();
+        return new ProtobufStoreStats(directory.estimateSize(), reservedBytes);
+    }
+
     /**
      * Increments the refCount of this Store instance.  RefCounts are used to determine when a
      * Store can be closed safely, i.e. as soon as there are no more references. Be sure to always call a
diff --git a/server/src/main/java/org/opensearch/index/warmer/ShardIndexWarmerService.java b/server/src/main/java/org/opensearch/index/warmer/ShardIndexWarmerService.java
index ff8f31297d47d..af842da0618f8 100644
--- a/server/src/main/java/org/opensearch/index/warmer/ShardIndexWarmerService.java
+++ b/server/src/main/java/org/opensearch/index/warmer/ShardIndexWarmerService.java
@@ -71,4 +71,8 @@ public void onPostWarm(long tookInNanos) {
     public WarmerStats stats() {
         return new WarmerStats(current.count(), warmerMetric.count(), TimeUnit.NANOSECONDS.toMillis(warmerMetric.sum()));
     }
+
+    public ProtobufWarmerStats protobufStats() {
+        return new ProtobufWarmerStats(current.count(), warmerMetric.count(), TimeUnit.NANOSECONDS.toMillis(warmerMetric.sum()));
+    }
 }
diff --git a/server/src/main/java/org/opensearch/indices/IndicesQueryCache.java b/server/src/main/java/org/opensearch/indices/IndicesQueryCache.java
index 8f7df5157d673..9015f1498ae5e 100644
--- a/server/src/main/java/org/opensearch/indices/IndicesQueryCache.java
+++ b/server/src/main/java/org/opensearch/indices/IndicesQueryCache.java
@@ -49,6 +49,7 @@
 import org.opensearch.common.settings.Setting.Property;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.common.unit.ByteSizeValue;
+import org.opensearch.index.cache.query.ProtobufQueryCacheStats;
 import org.opensearch.index.cache.query.QueryCacheStats;
 import org.opensearch.core.index.shard.ShardId;
 
@@ -142,6 +143,35 @@ public QueryCacheStats getStats(ShardId shard) {
         return shardStats;
     }
 
+    /** Get usage statistics for the given shard. */
+    public ProtobufQueryCacheStats getProtobufStats(ShardId shard) {
+        final Map<ShardId, ProtobufQueryCacheStats> stats = new HashMap<>();
+        for (Map.Entry<ShardId, Stats> entry : shardStats.entrySet()) {
+            stats.put(entry.getKey(), entry.getValue().toProtobufQueryCacheStats());
+        }
+        ProtobufQueryCacheStats shardStats = new ProtobufQueryCacheStats();
+        ProtobufQueryCacheStats info = stats.get(shard);
+        if (info == null) {
+            info = new ProtobufQueryCacheStats();
+        }
+        shardStats.add(info);
+
+        // We also have some shared ram usage that we try to distribute to
+        // proportionally to their number of cache entries of each shard
+        if (stats.isEmpty()) {
+            shardStats.add(new ProtobufQueryCacheStats(sharedRamBytesUsed, 0, 0, 0, 0));
+        } else {
+            long totalSize = 0;
+            for (ProtobufQueryCacheStats s : stats.values()) {
+                totalSize += s.getCacheSize();
+            }
+            final double weight = totalSize == 0 ? 1d / stats.size() : ((double) shardStats.getCacheSize()) / totalSize;
+            final long additionalRamBytesUsed = Math.round(weight * sharedRamBytesUsed);
+            shardStats.add(new ProtobufQueryCacheStats(additionalRamBytesUsed, 0, 0, 0, 0));
+        }
+        return shardStats;
+    }
+
     @Override
     public Weight doCache(Weight weight, QueryCachingPolicy policy) {
         while (weight instanceof CachingWeightWrapper) {
@@ -242,6 +272,10 @@ QueryCacheStats toQueryCacheStats() {
             return new QueryCacheStats(ramBytesUsed, hitCount, missCount, cacheCount, cacheSize);
         }
 
+        ProtobufQueryCacheStats toProtobufQueryCacheStats() {
+            return new ProtobufQueryCacheStats(ramBytesUsed, hitCount, missCount, cacheCount, cacheSize);
+        }
+
         @Override
         public String toString() {
             return "{shardId="
diff --git a/server/src/main/java/org/opensearch/indices/IndicesService.java b/server/src/main/java/org/opensearch/indices/IndicesService.java
index 7be824d95b421..2b89024b6a46b 100644
--- a/server/src/main/java/org/opensearch/indices/IndicesService.java
+++ b/server/src/main/java/org/opensearch/indices/IndicesService.java
@@ -46,6 +46,9 @@
 import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
 import org.opensearch.action.admin.indices.stats.CommonStatsFlags.Flag;
 import org.opensearch.action.admin.indices.stats.IndexShardStats;
+import org.opensearch.action.admin.indices.stats.ProtobufCommonStats;
+import org.opensearch.action.admin.indices.stats.ProtobufIndexShardStats;
+import org.opensearch.action.admin.indices.stats.ProtobufShardStats;
 import org.opensearch.action.admin.indices.stats.ShardStats;
 import org.opensearch.action.search.SearchType;
 import org.opensearch.client.Client;
@@ -112,14 +115,20 @@
 import org.opensearch.index.engine.ReadOnlyEngine;
 import org.opensearch.index.fielddata.IndexFieldDataCache;
 import org.opensearch.index.flush.FlushStats;
+import org.opensearch.index.flush.ProtobufFlushStats;
 import org.opensearch.index.get.GetStats;
+import org.opensearch.index.get.ProtobufGetStats;
 import org.opensearch.index.mapper.IdFieldMapper;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.merge.MergeStats;
+import org.opensearch.index.merge.ProtobufMergeStats;
 import org.opensearch.index.query.QueryBuilder;
 import org.opensearch.index.query.QueryRewriteContext;
+import org.opensearch.index.recovery.ProtobufRecoveryStats;
 import org.opensearch.index.recovery.RecoveryStats;
+import org.opensearch.index.refresh.ProtobufRefreshStats;
 import org.opensearch.index.refresh.RefreshStats;
+import org.opensearch.index.search.stats.ProtobufSearchStats;
 import org.opensearch.index.remote.RemoteRefreshSegmentPressureService;
 import org.opensearch.index.search.stats.SearchStats;
 import org.opensearch.index.seqno.RetentionLeaseStats;
@@ -131,6 +140,7 @@
 import org.opensearch.index.shard.IndexShardState;
 import org.opensearch.index.shard.IndexingOperationListener;
 import org.opensearch.index.shard.IndexingStats;
+import org.opensearch.index.shard.ProtobufIndexingStats;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.store.remote.filecache.FileCacheCleaner;
 import org.opensearch.index.translog.InternalTranslogFactory;
@@ -296,6 +306,7 @@ public class IndicesService extends AbstractLifecycleComponent
     private final Map<Index, List<PendingDelete>> pendingDeletes = new HashMap<>();
     private final AtomicInteger numUncompletedDeletes = new AtomicInteger();
     private final OldShardsStats oldShardsStats = new OldShardsStats();
+    private final ProtobufOldShardsStats protobufOldShardsStats = new ProtobufOldShardsStats();
     private final MapperRegistry mapperRegistry;
     private final NamedWriteableRegistry namedWriteableRegistry;
     private final IndexingMemoryController indexingMemoryController;
@@ -542,6 +553,38 @@ public NodeIndicesStats stats(CommonStatsFlags flags) {
         return new NodeIndicesStats(commonStats, statsByShard(this, flags));
     }
 
+    public ProtobufNodeIndicesStats protobufStats(CommonStatsFlags flags) {
+        ProtobufCommonStats commonStats = new ProtobufCommonStats(flags);
+        // the cumulative statistics also account for shards that are no longer on this node, which is tracked by oldShardsStats
+        for (Flag flag : flags.getFlags()) {
+            switch (flag) {
+                case Get:
+                    commonStats.get.add(protobufOldShardsStats.getStats);
+                    break;
+                case Indexing:
+                    commonStats.indexing.add(protobufOldShardsStats.indexingStats);
+                    break;
+                case Search:
+                    commonStats.search.add(protobufOldShardsStats.searchStats);
+                    break;
+                case Merge:
+                    commonStats.merge.add(protobufOldShardsStats.mergeStats);
+                    break;
+                case Refresh:
+                    commonStats.refresh.add(protobufOldShardsStats.refreshStats);
+                    break;
+                case Recovery:
+                    commonStats.recoveryStats.add(protobufOldShardsStats.recoveryStats);
+                    break;
+                case Flush:
+                    commonStats.flush.add(protobufOldShardsStats.flushStats);
+                    break;
+            }
+        }
+
+        return new ProtobufNodeIndicesStats(commonStats, statsByShardProtobuf(this, flags));
+    }
+
     Map<Index, List<IndexShardStats>> statsByShard(final IndicesService indicesService, final CommonStatsFlags flags) {
         final Map<Index, List<IndexShardStats>> statsByShard = new HashMap<>();
 
@@ -569,6 +612,37 @@ Map<Index, List<IndexShardStats>> statsByShard(final IndicesService indicesServi
         return statsByShard;
     }
 
+    Map<Index, List<ProtobufIndexShardStats>> statsByShardProtobuf(final IndicesService indicesService, final CommonStatsFlags flags) {
+        final Map<Index, List<ProtobufIndexShardStats>> statsByShard = new HashMap<>();
+
+        for (final IndexService indexService : indicesService) {
+            for (final IndexShard indexShard : indexService) {
+                try {
+                    final ProtobufIndexShardStats indexShardStats = indicesService.indexShardStatsProtobuf(
+                        indicesService,
+                        indexShard,
+                        flags
+                    );
+
+                    if (indexShardStats == null) {
+                        continue;
+                    }
+
+                    if (statsByShard.containsKey(indexService.index()) == false) {
+                        statsByShard.put(indexService.index(), arrayAsArrayList(indexShardStats));
+                    } else {
+                        statsByShard.get(indexService.index()).add(indexShardStats);
+                    }
+                } catch (IllegalIndexShardStateException | AlreadyClosedException e) {
+                    // we can safely ignore illegal state on ones that are closing for example
+                    logger.trace(() -> new ParameterizedMessage("{} ignoring shard stats", indexShard.shardId()), e);
+                }
+            }
+        }
+
+        return statsByShard;
+    }
+
     IndexShardStats indexShardStats(final IndicesService indicesService, final IndexShard indexShard, final CommonStatsFlags flags) {
         if (indexShard.routingEntry() == null) {
             return null;
@@ -602,6 +676,43 @@ IndexShardStats indexShardStats(final IndicesService indicesService, final Index
         );
     }
 
+    ProtobufIndexShardStats indexShardStatsProtobuf(
+        final IndicesService indicesService,
+        final IndexShard indexShard,
+        final CommonStatsFlags flags
+    ) {
+        if (indexShard.routingEntry() == null) {
+            return null;
+        }
+
+        CommitStats commitStats;
+        SeqNoStats seqNoStats;
+        RetentionLeaseStats retentionLeaseStats;
+        try {
+            commitStats = indexShard.commitStats();
+            seqNoStats = indexShard.seqNoStats();
+            retentionLeaseStats = indexShard.getRetentionLeaseStats();
+        } catch (AlreadyClosedException e) {
+            // shard is closed - no stats is fine
+            commitStats = null;
+            seqNoStats = null;
+            retentionLeaseStats = null;
+        }
+
+        return new ProtobufIndexShardStats(
+            indexShard.shardId(),
+            new ProtobufShardStats[] {
+                new ProtobufShardStats(
+                    indexShard.routingEntry(),
+                    indexShard.shardPath(),
+                    new ProtobufCommonStats(indicesService.getIndicesQueryCache(), indexShard, flags),
+                    commitStats,
+                    seqNoStats,
+                    retentionLeaseStats
+                ) }
+        );
+    }
+
     /**
      * Checks if changes (adding / removing) indices, shards and so on are allowed.
      *
@@ -1032,6 +1143,36 @@ public synchronized void beforeIndexShardClosed(ShardId shardId, @Nullable Index
         }
     }
 
+    /**
+     * Statistics for old shards
+     *
+     * @opensearch.internal
+     */
+    static class ProtobufOldShardsStats implements IndexEventListener {
+
+        final ProtobufSearchStats searchStats = new ProtobufSearchStats();
+        final ProtobufGetStats getStats = new ProtobufGetStats();
+        final ProtobufIndexingStats indexingStats = new ProtobufIndexingStats();
+        final ProtobufMergeStats mergeStats = new ProtobufMergeStats();
+        final ProtobufRefreshStats refreshStats = new ProtobufRefreshStats();
+        final ProtobufFlushStats flushStats = new ProtobufFlushStats();
+        final ProtobufRecoveryStats recoveryStats = new ProtobufRecoveryStats();
+
+        @Override
+        public synchronized void beforeIndexShardClosed(ShardId shardId, @Nullable IndexShard indexShard, Settings indexSettings) {
+            if (indexShard != null) {
+                getStats.addTotals(indexShard.getProtobufStats());
+                indexingStats.addTotals(indexShard.protobufIndexingStats());
+                // if this index was closed or deleted, we should eliminate the effect of the current scroll for this shard
+                searchStats.addTotalsForClosingShard(indexShard.protobufSearchStats());
+                mergeStats.addTotals(indexShard.protobufMergeStats());
+                refreshStats.addTotals(indexShard.protobufRefreshStats());
+                flushStats.addTotals(indexShard.protobufFlushStats());
+                recoveryStats.addTotals(indexShard.protobufRecoveryStats());
+            }
+        }
+    }
+
     /**
      * Deletes an index that is not assigned to this node. This method cleans up all disk folders relating to the index
      * but does not deal with in-memory structures. For those call {@link #removeIndex(Index, IndexRemovalReason, String)}
diff --git a/server/src/main/java/org/opensearch/indices/ProtobufNodeIndicesStats.java b/server/src/main/java/org/opensearch/indices/ProtobufNodeIndicesStats.java
index 296dfb89bba05..27269cb02626a 100644
--- a/server/src/main/java/org/opensearch/indices/ProtobufNodeIndicesStats.java
+++ b/server/src/main/java/org/opensearch/indices/ProtobufNodeIndicesStats.java
@@ -10,11 +10,15 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
+
+import org.opensearch.action.admin.indices.stats.ProtobufIndexShardStats;
 import org.opensearch.action.admin.indices.stats.ProtobufCommonStats;
+import org.opensearch.action.admin.indices.stats.ProtobufShardStats;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.Index;
 import org.opensearch.index.cache.query.ProtobufQueryCacheStats;
 import org.opensearch.index.cache.request.ProtobufRequestCacheStats;
 import org.opensearch.index.engine.ProtobufSegmentsStats;
@@ -33,6 +37,8 @@
 import org.opensearch.search.suggest.completion.ProtobufCompletionStats;
 
 import java.io.IOException;
+import java.util.List;
+import java.util.Map;
 
 /**
  * Global information on indices stats running on a specific node.
@@ -42,14 +48,25 @@
 public class ProtobufNodeIndicesStats implements ProtobufWriteable, ToXContentFragment {
 
     private ProtobufCommonStats stats;
+    private Map<Index, List<ProtobufIndexShardStats>> statsByShard;
 
     public ProtobufNodeIndicesStats(CodedInputStream in) throws IOException {
         stats = new ProtobufCommonStats(in);
     }
 
-    public ProtobufNodeIndicesStats(ProtobufCommonStats oldStats) {
+    public ProtobufNodeIndicesStats(ProtobufCommonStats oldStats, Map<Index, List<ProtobufIndexShardStats>> statsByShard) {
+        // this.stats = stats;
+        this.statsByShard = statsByShard;
+
         // make a total common stats from old ones and current ones
         this.stats = oldStats;
+        for (List<ProtobufIndexShardStats> shardStatsList : statsByShard.values()) {
+            for (ProtobufIndexShardStats indexShardStats : shardStatsList) {
+                for (ProtobufShardStats shardStats : indexShardStats.getShards()) {
+                    stats.add(shardStats.getStats());
+                }
+            }
+        }
     }
 
     @Nullable
diff --git a/server/src/main/java/org/opensearch/indices/breaker/HierarchyCircuitBreakerService.java b/server/src/main/java/org/opensearch/indices/breaker/HierarchyCircuitBreakerService.java
index 34cadd2c828d0..b05832b61a405 100644
--- a/server/src/main/java/org/opensearch/indices/breaker/HierarchyCircuitBreakerService.java
+++ b/server/src/main/java/org/opensearch/indices/breaker/HierarchyCircuitBreakerService.java
@@ -344,6 +344,39 @@ public CircuitBreakerStats stats(String name) {
         );
     }
 
+    @Override
+    public ProtobufAllCircuitBreakerStats protobufStats() {
+        List<ProtobufCircuitBreakerStats> allStats = new ArrayList<>(this.breakers.size());
+        // Gather the "estimated" count for the parent breaker by adding the
+        // estimations for each individual breaker
+        for (CircuitBreaker breaker : this.breakers.values()) {
+            allStats.add(protobufStats(breaker.getName()));
+        }
+        // Manually add the parent breaker settings since they aren't part of the breaker map
+        allStats.add(
+            new ProtobufCircuitBreakerStats(
+                CircuitBreaker.PARENT,
+                parentSettings.getLimit(),
+                memoryUsed(0L).totalUsage,
+                1.0,
+                parentTripCount.get()
+            )
+        );
+        return new ProtobufAllCircuitBreakerStats(allStats.toArray(new ProtobufCircuitBreakerStats[0]));
+    }
+
+    @Override
+    public ProtobufCircuitBreakerStats protobufStats(String name) {
+        CircuitBreaker breaker = this.breakers.get(name);
+        return new ProtobufCircuitBreakerStats(
+            breaker.getName(),
+            breaker.getLimit(),
+            breaker.getUsed(),
+            breaker.getOverhead(),
+            breaker.getTrippedCount()
+        );
+    }
+
     /**
      * Tracks memory usage
      *
diff --git a/server/src/main/java/org/opensearch/ingest/IngestService.java b/server/src/main/java/org/opensearch/ingest/IngestService.java
index 52ced9c051d14..3d6446c72e90d 100644
--- a/server/src/main/java/org/opensearch/ingest/IngestService.java
+++ b/server/src/main/java/org/opensearch/ingest/IngestService.java
@@ -71,6 +71,7 @@
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.VersionType;
 import org.opensearch.index.analysis.AnalysisRegistry;
+import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.node.ReportingService;
 import org.opensearch.plugins.IngestPlugin;
 import org.opensearch.script.ScriptService;
@@ -98,7 +99,7 @@
  *
  * @opensearch.internal
  */
-public class IngestService implements ClusterStateApplier, ReportingService<IngestInfo> {
+public class IngestService implements ClusterStateApplier, ReportingService<IngestInfo>, ProtobufReportingService<ProtobufIngestInfo> {
 
     public static final String NOOP_PIPELINE_NAME = "_none";
 
@@ -433,6 +434,16 @@ public IngestInfo info() {
         return new IngestInfo(processorInfoList);
     }
 
+    @Override
+    public ProtobufIngestInfo protobufInfo() {
+        Map<String, Processor.Factory> processorFactories = getProcessorFactories();
+        List<ProtobufProcessorInfo> processorInfoList = new ArrayList<>(processorFactories.size());
+        for (Map.Entry<String, Processor.Factory> entry : processorFactories.entrySet()) {
+            processorInfoList.add(new ProtobufProcessorInfo(entry.getKey()));
+        }
+        return new ProtobufIngestInfo(processorInfoList);
+    }
+
     Map<String, PipelineHolder> pipelines() {
         return pipelines;
     }
@@ -692,6 +703,24 @@ public IngestStats stats() {
         return statsBuilder.build();
     }
 
+    public ProtobufIngestStats protobufStats() {
+        ProtobufIngestStats.Builder statsBuilder = new ProtobufIngestStats.Builder();
+        statsBuilder.addTotalMetrics(totalMetrics);
+        pipelines.forEach((id, holder) -> {
+            Pipeline pipeline = holder.pipeline;
+            CompoundProcessor rootProcessor = pipeline.getCompoundProcessor();
+            statsBuilder.addPipelineMetrics(id, pipeline.getMetrics());
+            List<Tuple<Processor, IngestMetric>> processorMetrics = new ArrayList<>();
+            getProcessorMetrics(rootProcessor, processorMetrics);
+            processorMetrics.forEach(t -> {
+                Processor processor = t.v1();
+                IngestMetric processorMetric = t.v2();
+                statsBuilder.addProcessorMetrics(id, getProcessorName(processor), processor.getType(), processorMetric);
+            });
+        });
+        return statsBuilder.build();
+    }
+
     /**
      * Adds a listener that gets invoked with the current cluster state before processor factories
      * get invoked.
diff --git a/server/src/main/java/org/opensearch/ingest/ProtobufIngestInfo.java b/server/src/main/java/org/opensearch/ingest/ProtobufIngestInfo.java
index d7a72cb078219..52d26218e61d5 100644
--- a/server/src/main/java/org/opensearch/ingest/ProtobufIngestInfo.java
+++ b/server/src/main/java/org/opensearch/ingest/ProtobufIngestInfo.java
@@ -10,6 +10,8 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
+
+import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.node.ProtobufReportingService;
 
 import java.io.IOException;
@@ -56,4 +58,16 @@ public Iterable<ProtobufProcessorInfo> getProcessors() {
     public boolean containsProcessor(String type) {
         return processors.contains(new ProtobufProcessorInfo(type));
     }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject("ingest");
+        builder.startArray("processors");
+        for (ProtobufProcessorInfo info : processors) {
+            info.toXContent(builder, params);
+        }
+        builder.endArray();
+        builder.endObject();
+        return builder;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/ingest/ProtobufProcessorInfo.java b/server/src/main/java/org/opensearch/ingest/ProtobufProcessorInfo.java
index debfcc669921c..199f21aab12af 100644
--- a/server/src/main/java/org/opensearch/ingest/ProtobufProcessorInfo.java
+++ b/server/src/main/java/org/opensearch/ingest/ProtobufProcessorInfo.java
@@ -11,6 +11,9 @@
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
 import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.xcontent.ToXContent.Params;
+import org.opensearch.core.xcontent.ToXContentObject;
+import org.opensearch.core.xcontent.XContentBuilder;
 
 import java.io.IOException;
 
@@ -19,7 +22,7 @@
 *
 * @opensearch.internal
 */
-public class ProtobufProcessorInfo implements ProtobufWriteable {
+public class ProtobufProcessorInfo implements ProtobufWriteable, ToXContentObject {
 
     private final String type;
 
@@ -45,4 +48,12 @@ public void writeTo(CodedOutputStream out) throws IOException {
     public String getType() {
         return type;
     }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        builder.field("type", type);
+        builder.endObject();
+        return null;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/monitor/ProtobufMonitorService.java b/server/src/main/java/org/opensearch/monitor/ProtobufMonitorService.java
new file mode 100644
index 0000000000000..067ef7c193d0d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/monitor/ProtobufMonitorService.java
@@ -0,0 +1,77 @@
+/*
+ * 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.
+ */
+
+package org.opensearch.monitor;
+
+import org.opensearch.common.component.AbstractLifecycleComponent;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.env.NodeEnvironment;
+import org.opensearch.index.store.remote.filecache.FileCache;
+import org.opensearch.monitor.fs.ProtobufFsService;
+import org.opensearch.monitor.jvm.JvmGcMonitorService;
+import org.opensearch.monitor.jvm.ProtobufJvmService;
+import org.opensearch.monitor.os.ProtobufOsService;
+import org.opensearch.monitor.process.ProtobufProcessService;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.IOException;
+
+/**
+ * The resource monitoring service
+ *
+ * @opensearch.internal
+ */
+public class ProtobufMonitorService extends AbstractLifecycleComponent {
+
+    private final JvmGcMonitorService jvmGcMonitorService;
+    private final ProtobufOsService osService;
+    private final ProtobufProcessService processService;
+    private final ProtobufJvmService jvmService;
+    private final ProtobufFsService fsService;
+
+    public ProtobufMonitorService(Settings settings, NodeEnvironment nodeEnvironment, ThreadPool threadPool, FileCache fileCache)
+        throws IOException {
+        this.jvmGcMonitorService = new JvmGcMonitorService(settings, threadPool);
+        this.osService = new ProtobufOsService(settings);
+        this.processService = new ProtobufProcessService(settings);
+        this.jvmService = new ProtobufJvmService(settings);
+        this.fsService = new ProtobufFsService(settings, nodeEnvironment, fileCache);
+    }
+
+    public ProtobufOsService osService() {
+        return this.osService;
+    }
+
+    public ProtobufProcessService processService() {
+        return this.processService;
+    }
+
+    public ProtobufJvmService jvmService() {
+        return this.jvmService;
+    }
+
+    public ProtobufFsService fsService() {
+        return this.fsService;
+    }
+
+    @Override
+    protected void doStart() {
+        jvmGcMonitorService.start();
+    }
+
+    @Override
+    protected void doStop() {
+        jvmGcMonitorService.stop();
+    }
+
+    @Override
+    protected void doClose() {
+        jvmGcMonitorService.close();
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/monitor/fs/FsProbe.java b/server/src/main/java/org/opensearch/monitor/fs/FsProbe.java
index e20d84cd9763e..c2a31f8a4be8c 100644
--- a/server/src/main/java/org/opensearch/monitor/fs/FsProbe.java
+++ b/server/src/main/java/org/opensearch/monitor/fs/FsProbe.java
@@ -97,6 +97,33 @@ public FsInfo stats(FsInfo previous) throws IOException {
         return new FsInfo(System.currentTimeMillis(), ioStats, paths);
     }
 
+    public ProtobufFsInfo protobufStats(ProtobufFsInfo previous) throws IOException {
+        if (!nodeEnv.hasNodeFile()) {
+            return new ProtobufFsInfo(System.currentTimeMillis(), null, new ProtobufFsInfo.Path[0]);
+        }
+        NodePath[] dataLocations = nodeEnv.nodePaths();
+        ProtobufFsInfo.Path[] paths = new ProtobufFsInfo.Path[dataLocations.length];
+        for (int i = 0; i < dataLocations.length; i++) {
+            paths[i] = getProtobufFsInfo(dataLocations[i]);
+            if (fileCache != null && dataLocations[i].fileCacheReservedSize != ByteSizeValue.ZERO) {
+                paths[i].fileCacheReserved = adjustForHugeFilesystems(dataLocations[i].fileCacheReservedSize.getBytes());
+                paths[i].fileCacheUtilized = adjustForHugeFilesystems(fileCache.usage().usage());
+                paths[i].available -= (paths[i].fileCacheReserved - paths[i].fileCacheUtilized);
+            }
+        }
+        ProtobufFsInfo.IoStats ioStats = null;
+        if (Constants.LINUX) {
+            Set<Tuple<Integer, Integer>> devicesNumbers = new HashSet<>();
+            for (NodePath dataLocation : dataLocations) {
+                if (dataLocation.majorDeviceNumber != -1 && dataLocation.minorDeviceNumber != -1) {
+                    devicesNumbers.add(Tuple.tuple(dataLocation.majorDeviceNumber, dataLocation.minorDeviceNumber));
+                }
+            }
+            ioStats = protobufIoStats(devicesNumbers, previous);
+        }
+        return new ProtobufFsInfo(System.currentTimeMillis(), ioStats, paths);
+    }
+
     final FsInfo.IoStats ioStats(final Set<Tuple<Integer, Integer>> devicesNumbers, final FsInfo previous) {
         try {
             final Map<Tuple<Integer, Integer>, FsInfo.DeviceStats> deviceMap = new HashMap<>();
@@ -149,6 +176,58 @@ final FsInfo.IoStats ioStats(final Set<Tuple<Integer, Integer>> devicesNumbers,
         }
     }
 
+    final ProtobufFsInfo.IoStats protobufIoStats(final Set<Tuple<Integer, Integer>> devicesNumbers, final ProtobufFsInfo previous) {
+        try {
+            final Map<Tuple<Integer, Integer>, ProtobufFsInfo.DeviceStats> deviceMap = new HashMap<>();
+            if (previous != null && previous.getIoStats() != null && previous.getIoStats().devicesStats != null) {
+                for (int i = 0; i < previous.getIoStats().devicesStats.length; i++) {
+                    ProtobufFsInfo.DeviceStats deviceStats = previous.getIoStats().devicesStats[i];
+                    deviceMap.put(Tuple.tuple(deviceStats.majorDeviceNumber, deviceStats.minorDeviceNumber), deviceStats);
+                }
+            }
+
+            List<ProtobufFsInfo.DeviceStats> devicesStats = new ArrayList<>();
+
+            List<String> lines = readProcDiskStats();
+            if (!lines.isEmpty()) {
+                for (String line : lines) {
+                    String fields[] = line.trim().split("\\s+");
+                    final int majorDeviceNumber = Integer.parseInt(fields[0]);
+                    final int minorDeviceNumber = Integer.parseInt(fields[1]);
+                    if (!devicesNumbers.contains(Tuple.tuple(majorDeviceNumber, minorDeviceNumber))) {
+                        continue;
+                    }
+                    final String deviceName = fields[2];
+                    final long readsCompleted = Long.parseLong(fields[3]);
+                    final long sectorsRead = Long.parseLong(fields[5]);
+                    final long writesCompleted = Long.parseLong(fields[7]);
+                    final long sectorsWritten = Long.parseLong(fields[9]);
+                    final ProtobufFsInfo.DeviceStats deviceStats = new ProtobufFsInfo.DeviceStats(
+                        majorDeviceNumber,
+                        minorDeviceNumber,
+                        deviceName,
+                        readsCompleted,
+                        sectorsRead,
+                        writesCompleted,
+                        sectorsWritten,
+                        deviceMap.get(Tuple.tuple(majorDeviceNumber, minorDeviceNumber))
+                    );
+                    devicesStats.add(deviceStats);
+                }
+            }
+
+            return new ProtobufFsInfo.IoStats(devicesStats.toArray(new ProtobufFsInfo.DeviceStats[0]));
+        } catch (Exception e) {
+            // do not fail Elasticsearch if something unexpected
+            // happens here
+            logger.debug(
+                () -> new ParameterizedMessage("unexpected exception processing /proc/diskstats for devices {}", devicesNumbers),
+                e
+            );
+            return null;
+        }
+    }
+
     @SuppressForbidden(reason = "read /proc/diskstats")
     List<String> readProcDiskStats() throws IOException {
         return Files.readAllLines(PathUtils.get("/proc/diskstats"));
@@ -182,4 +261,20 @@ public static FsInfo.Path getFSInfo(NodePath nodePath) throws IOException {
         return fsPath;
     }
 
+    public static ProtobufFsInfo.Path getProtobufFsInfo(NodePath nodePath) throws IOException {
+        ProtobufFsInfo.Path fsPath = new ProtobufFsInfo.Path();
+        fsPath.path = nodePath.path.toString();
+
+        // NOTE: we use already cached (on node startup) FileStore and spins
+        // since recomputing these once per second (default) could be costly,
+        // and they should not change:
+        fsPath.total = adjustForHugeFilesystems(nodePath.fileStore.getTotalSpace());
+        fsPath.free = adjustForHugeFilesystems(nodePath.fileStore.getUnallocatedSpace());
+        fsPath.available = adjustForHugeFilesystems(nodePath.fileStore.getUsableSpace());
+        fsPath.fileCacheReserved = adjustForHugeFilesystems(nodePath.fileCacheReservedSize.getBytes());
+        fsPath.type = nodePath.fileStore.type();
+        fsPath.mount = nodePath.fileStore.toString();
+        return fsPath;
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/monitor/fs/ProtobufFsService.java b/server/src/main/java/org/opensearch/monitor/fs/ProtobufFsService.java
new file mode 100644
index 0000000000000..e959d2a46293b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/monitor/fs/ProtobufFsService.java
@@ -0,0 +1,94 @@
+/*
+ * 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.
+ */
+
+package org.opensearch.monitor.fs;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Setting.Property;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.SingleObjectCache;
+import org.opensearch.env.NodeEnvironment;
+import org.opensearch.index.store.remote.filecache.FileCache;
+
+import java.io.IOException;
+import java.util.function.Supplier;
+
+/**
+ * FileSystem service
+ *
+ * @opensearch.internal
+ */
+public class ProtobufFsService {
+
+    private static final Logger logger = LogManager.getLogger(ProtobufFsService.class);
+
+    private final Supplier<ProtobufFsInfo> fsInfoSupplier;
+
+    public static final Setting<TimeValue> REFRESH_INTERVAL_SETTING = Setting.timeSetting(
+        "monitor.fs.refresh_interval",
+        TimeValue.timeValueSeconds(1),
+        TimeValue.timeValueSeconds(1),
+        Property.NodeScope
+    );
+
+    // permits tests to bypass the refresh interval on the cache; deliberately unregistered since it is only for use in tests
+    public static final Setting<Boolean> ALWAYS_REFRESH_SETTING = Setting.boolSetting(
+        "monitor.fs.always_refresh",
+        false,
+        Property.NodeScope
+    );
+
+    public ProtobufFsService(final Settings settings, final NodeEnvironment nodeEnvironment, FileCache fileCache) {
+        final FsProbe probe = new FsProbe(nodeEnvironment, fileCache);
+        final ProtobufFsInfo initialValue = stats(probe, null);
+        if (ALWAYS_REFRESH_SETTING.get(settings)) {
+            assert REFRESH_INTERVAL_SETTING.exists(settings) == false;
+            logger.debug("bypassing refresh_interval");
+            fsInfoSupplier = () -> stats(probe, initialValue);
+        } else {
+            final TimeValue refreshInterval = REFRESH_INTERVAL_SETTING.get(settings);
+            logger.debug("using refresh_interval [{}]", refreshInterval);
+            fsInfoSupplier = new FsInfoCache(refreshInterval, initialValue, probe)::getOrRefresh;
+        }
+    }
+
+    public ProtobufFsInfo stats() {
+        return fsInfoSupplier.get();
+    }
+
+    private static ProtobufFsInfo stats(FsProbe probe, ProtobufFsInfo initialValue) {
+        try {
+            return probe.protobufStats(initialValue);
+        } catch (IOException e) {
+            logger.debug("unexpected exception reading filesystem info", e);
+            return null;
+        }
+    }
+
+    private static class FsInfoCache extends SingleObjectCache<ProtobufFsInfo> {
+
+        private final ProtobufFsInfo initialValue;
+        private final FsProbe probe;
+
+        FsInfoCache(TimeValue interval, ProtobufFsInfo initialValue, FsProbe probe) {
+            super(interval, initialValue);
+            this.initialValue = initialValue;
+            this.probe = probe;
+        }
+
+        @Override
+        protected ProtobufFsInfo refresh() {
+            return stats(probe, initialValue);
+        }
+
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/monitor/jvm/JvmInfo.java b/server/src/main/java/org/opensearch/monitor/jvm/JvmInfo.java
index 9eafd80203a87..5ca0ff8ed1809 100644
--- a/server/src/main/java/org/opensearch/monitor/jvm/JvmInfo.java
+++ b/server/src/main/java/org/opensearch/monitor/jvm/JvmInfo.java
@@ -36,13 +36,20 @@
 import org.opensearch.common.Booleans;
 import org.opensearch.common.SuppressForbidden;
 import org.opensearch.common.io.PathUtils;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.node.ReportingService;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.lang.management.GarbageCollectorMXBean;
 import java.lang.management.ManagementFactory;
@@ -61,7 +68,7 @@
  *
  * @opensearch.internal
  */
-public class JvmInfo implements ReportingService.Info {
+public class JvmInfo implements ReportingService.Info, ProtobufReportingService.ProtobufInfo {
 
     private static JvmInfo INSTANCE;
 
@@ -356,6 +363,65 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeString(useCompressedOops);
     }
 
+    public JvmInfo(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        pid = in.readInt64();
+        version = in.readString();
+        vmName = in.readString();
+        vmVersion = in.readString();
+        vmVendor = in.readString();
+        bundledJdk = in.readBool();
+        usingBundledJdk = protobufStreamInput.readOptionalBoolean();
+        startTime = in.readInt64();
+        inputArguments = new String[in.readInt32()];
+        for (int i = 0; i < inputArguments.length; i++) {
+            inputArguments[i] = in.readString();
+        }
+        bootClassPath = in.readString();
+        classPath = in.readString();
+        systemProperties = protobufStreamInput.readMap(CodedInputStream::readString, CodedInputStream::readString);
+        mem = new Mem(in);
+        gcCollectors = protobufStreamInput.readStringArray();
+        memoryPools = protobufStreamInput.readStringArray();
+        useCompressedOops = in.readString();
+        // the following members are only used locally for bootstrap checks, never serialized nor printed out
+        this.configuredMaxHeapSize = -1;
+        this.configuredInitialHeapSize = -1;
+        this.onError = null;
+        this.onOutOfMemoryError = null;
+        this.useG1GC = "unknown";
+        this.useSerialGC = "unknown";
+        this.g1RegionSize = -1;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        out.writeInt64NoTag(pid);
+        out.writeStringNoTag(version);
+        out.writeStringNoTag(vmName);
+        out.writeStringNoTag(vmVersion);
+        out.writeStringNoTag(vmVendor);
+        out.writeBoolNoTag(bundledJdk);
+        protobufStreamOutput.writeOptionalBoolean(usingBundledJdk);
+        out.writeInt64NoTag(startTime);
+        out.writeInt32NoTag(inputArguments.length);
+        for (String inputArgument : inputArguments) {
+            out.writeStringNoTag(inputArgument);
+        }
+        out.writeStringNoTag(bootClassPath);
+        out.writeStringNoTag(classPath);
+        out.writeInt32NoTag(this.systemProperties.size());
+        for (Map.Entry<String, String> entry : systemProperties.entrySet()) {
+            out.writeStringNoTag(entry.getKey());
+            out.writeStringNoTag(entry.getValue());
+        }
+        mem.writeTo(out);
+        protobufStreamOutput.writeStringArray(gcCollectors);
+        protobufStreamOutput.writeStringArray(memoryPools);
+        out.writeStringNoTag(useCompressedOops);
+    }
+
     /**
      * The process id.
      */
@@ -597,7 +663,7 @@ static final class Fields {
      *
      * @opensearch.internal
      */
-    public static class Mem implements Writeable {
+    public static class Mem implements Writeable, ProtobufWriteable {
 
         private final long heapInit;
         private final long heapMax;
@@ -630,6 +696,23 @@ public void writeTo(StreamOutput out) throws IOException {
             out.writeVLong(directMemoryMax);
         }
 
+        public Mem(CodedInputStream in) throws IOException {
+            this.heapInit = in.readInt64();
+            this.heapMax = in.readInt64();
+            this.nonHeapInit = in.readInt64();
+            this.nonHeapMax = in.readInt64();
+            this.directMemoryMax = in.readInt64();
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeInt64NoTag(heapInit);
+            out.writeInt64NoTag(heapMax);
+            out.writeInt64NoTag(nonHeapInit);
+            out.writeInt64NoTag(nonHeapMax);
+            out.writeInt64NoTag(directMemoryMax);
+        }
+
         public ByteSizeValue getHeapInit() {
             return new ByteSizeValue(heapInit);
         }
diff --git a/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java b/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java
deleted file mode 100644
index 6216248191550..0000000000000
--- a/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java
+++ /dev/null
@@ -1,571 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.monitor.jvm;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.apache.lucene.util.Constants;
-import org.opensearch.common.Booleans;
-import org.opensearch.common.SuppressForbidden;
-import org.opensearch.common.io.PathUtils;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.node.ProtobufReportingService;
-
-import java.io.IOException;
-import java.lang.management.GarbageCollectorMXBean;
-import java.lang.management.ManagementFactory;
-import java.lang.management.ManagementPermission;
-import java.lang.management.MemoryMXBean;
-import java.lang.management.MemoryPoolMXBean;
-import java.lang.management.PlatformManagedObject;
-import java.lang.management.RuntimeMXBean;
-import java.lang.reflect.Method;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Holds information about the JVM
-*
-* @opensearch.internal
-*/
-public class ProtobufJvmInfo implements ProtobufReportingService.ProtobufInfo {
-
-    private static ProtobufJvmInfo INSTANCE;
-
-    static {
-        RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
-        MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
-
-        long heapInit = memoryMXBean.getHeapMemoryUsage().getInit() < 0 ? 0 : memoryMXBean.getHeapMemoryUsage().getInit();
-        long heapMax = memoryMXBean.getHeapMemoryUsage().getMax() < 0 ? 0 : memoryMXBean.getHeapMemoryUsage().getMax();
-        long nonHeapInit = memoryMXBean.getNonHeapMemoryUsage().getInit() < 0 ? 0 : memoryMXBean.getNonHeapMemoryUsage().getInit();
-        long nonHeapMax = memoryMXBean.getNonHeapMemoryUsage().getMax() < 0 ? 0 : memoryMXBean.getNonHeapMemoryUsage().getMax();
-        long directMemoryMax = 0;
-        try {
-            Class<?> vmClass = Class.forName("sun.misc.VM");
-            directMemoryMax = (Long) vmClass.getMethod("maxDirectMemory").invoke(null);
-        } catch (Exception t) {
-            // ignore
-        }
-        String[] inputArguments = runtimeMXBean.getInputArguments().toArray(new String[0]);
-        Mem mem = new Mem(heapInit, heapMax, nonHeapInit, nonHeapMax, directMemoryMax);
-
-        String bootClassPath;
-        try {
-            bootClassPath = runtimeMXBean.getBootClassPath();
-        } catch (UnsupportedOperationException e) {
-            // oracle java 9
-            bootClassPath = System.getProperty("sun.boot.class.path");
-            if (bootClassPath == null) {
-                // something else
-                bootClassPath = "<unknown>";
-            }
-        }
-        String classPath = runtimeMXBean.getClassPath();
-        Map<String, String> systemProperties = Collections.unmodifiableMap(runtimeMXBean.getSystemProperties());
-
-        List<GarbageCollectorMXBean> gcMxBeans = ManagementFactory.getGarbageCollectorMXBeans();
-        String[] gcCollectors = new String[gcMxBeans.size()];
-        for (int i = 0; i < gcMxBeans.size(); i++) {
-            GarbageCollectorMXBean gcMxBean = gcMxBeans.get(i);
-            gcCollectors[i] = gcMxBean.getName();
-        }
-
-        List<MemoryPoolMXBean> memoryPoolMXBeans = ManagementFactory.getMemoryPoolMXBeans();
-        String[] memoryPools = new String[memoryPoolMXBeans.size()];
-        for (int i = 0; i < memoryPoolMXBeans.size(); i++) {
-            MemoryPoolMXBean memoryPoolMXBean = memoryPoolMXBeans.get(i);
-            memoryPools[i] = memoryPoolMXBean.getName();
-        }
-
-        String onError = null;
-        String onOutOfMemoryError = null;
-        String useCompressedOops = "unknown";
-        String useG1GC = "unknown";
-        long g1RegisionSize = -1;
-        String useSerialGC = "unknown";
-        long configuredInitialHeapSize = -1;
-        long configuredMaxHeapSize = -1;
-        try {
-            @SuppressWarnings("unchecked")
-            Class<? extends PlatformManagedObject> clazz = (Class<? extends PlatformManagedObject>) Class.forName(
-                "com.sun.management.HotSpotDiagnosticMXBean"
-            );
-            Class<?> vmOptionClazz = Class.forName("com.sun.management.VMOption");
-            PlatformManagedObject hotSpotDiagnosticMXBean = ManagementFactory.getPlatformMXBean(clazz);
-            Method vmOptionMethod = clazz.getMethod("getVMOption", String.class);
-            Method valueMethod = vmOptionClazz.getMethod("getValue");
-
-            try {
-                Object onErrorObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "OnError");
-                onError = (String) valueMethod.invoke(onErrorObject);
-            } catch (Exception ignored) {}
-
-            try {
-                Object onOutOfMemoryErrorObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "OnOutOfMemoryError");
-                onOutOfMemoryError = (String) valueMethod.invoke(onOutOfMemoryErrorObject);
-            } catch (Exception ignored) {}
-
-            try {
-                Object useCompressedOopsVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "UseCompressedOops");
-                useCompressedOops = (String) valueMethod.invoke(useCompressedOopsVmOptionObject);
-            } catch (Exception ignored) {}
-
-            try {
-                Object useG1GCVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "UseG1GC");
-                useG1GC = (String) valueMethod.invoke(useG1GCVmOptionObject);
-                Object regionSizeVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "G1HeapRegionSize");
-                g1RegisionSize = Long.parseLong((String) valueMethod.invoke(regionSizeVmOptionObject));
-            } catch (Exception ignored) {}
-
-            try {
-                Object initialHeapSizeVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "InitialHeapSize");
-                configuredInitialHeapSize = Long.parseLong((String) valueMethod.invoke(initialHeapSizeVmOptionObject));
-            } catch (Exception ignored) {}
-
-            try {
-                Object maxHeapSizeVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "MaxHeapSize");
-                configuredMaxHeapSize = Long.parseLong((String) valueMethod.invoke(maxHeapSizeVmOptionObject));
-            } catch (Exception ignored) {}
-
-            try {
-                Object useSerialGCVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "UseSerialGC");
-                useSerialGC = (String) valueMethod.invoke(useSerialGCVmOptionObject);
-            } catch (Exception ignored) {}
-
-        } catch (Exception ignored) {
-
-        }
-
-        final boolean bundledJdk = Booleans.parseBoolean(System.getProperty("opensearch.bundled_jdk", Boolean.FALSE.toString()));
-        final Boolean usingBundledJdk = bundledJdk ? usingBundledJdk() : null;
-
-        INSTANCE = new ProtobufJvmInfo(
-            JvmPid.getPid(),
-            System.getProperty("java.version"),
-            runtimeMXBean.getVmName(),
-            runtimeMXBean.getVmVersion(),
-            runtimeMXBean.getVmVendor(),
-            bundledJdk,
-            usingBundledJdk,
-            runtimeMXBean.getStartTime(),
-            configuredInitialHeapSize,
-            configuredMaxHeapSize,
-            mem,
-            inputArguments,
-            bootClassPath,
-            classPath,
-            systemProperties,
-            gcCollectors,
-            memoryPools,
-            onError,
-            onOutOfMemoryError,
-            useCompressedOops,
-            useG1GC,
-            useSerialGC,
-            g1RegisionSize
-        );
-    }
-
-    @SuppressForbidden(reason = "PathUtils#get")
-    private static boolean usingBundledJdk() {
-        /*
-        * We are using the bundled JDK if java.home is the jdk sub-directory of our working directory. This is because we always set
-        * the working directory of Elasticsearch to home, and the bundled JDK is in the jdk sub-directory there.
-        */
-        final String javaHome = System.getProperty("java.home");
-        final String userDir = System.getProperty("user.dir");
-        if (Constants.MAC_OS_X) {
-            return PathUtils.get(javaHome).equals(PathUtils.get(userDir).resolve("jdk.app/Contents/Home").toAbsolutePath());
-        } else {
-            return PathUtils.get(javaHome).equals(PathUtils.get(userDir).resolve("jdk").toAbsolutePath());
-        }
-    }
-
-    public static ProtobufJvmInfo jvmInfo() {
-        SecurityManager sm = System.getSecurityManager();
-        if (sm != null) {
-            sm.checkPermission(new ManagementPermission("monitor"));
-            sm.checkPropertyAccess("*");
-        }
-        return INSTANCE;
-    }
-
-    private final long pid;
-    private final String version;
-    private final String vmName;
-    private final String vmVersion;
-    private final String vmVendor;
-    private final boolean bundledJdk;
-    private final Boolean usingBundledJdk;
-    private final long startTime;
-    private final long configuredInitialHeapSize;
-    private final long configuredMaxHeapSize;
-    private final Mem mem;
-    private final String[] inputArguments;
-    private final String bootClassPath;
-    private final String classPath;
-    private final Map<String, String> systemProperties;
-    private final String[] gcCollectors;
-    private final String[] memoryPools;
-    private final String onError;
-    private final String onOutOfMemoryError;
-    private final String useCompressedOops;
-    private final String useG1GC;
-    private final String useSerialGC;
-    private final long g1RegionSize;
-
-    private ProtobufJvmInfo(
-        long pid,
-        String version,
-        String vmName,
-        String vmVersion,
-        String vmVendor,
-        boolean bundledJdk,
-        Boolean usingBundledJdk,
-        long startTime,
-        long configuredInitialHeapSize,
-        long configuredMaxHeapSize,
-        Mem mem,
-        String[] inputArguments,
-        String bootClassPath,
-        String classPath,
-        Map<String, String> systemProperties,
-        String[] gcCollectors,
-        String[] memoryPools,
-        String onError,
-        String onOutOfMemoryError,
-        String useCompressedOops,
-        String useG1GC,
-        String useSerialGC,
-        long g1RegionSize
-    ) {
-        this.pid = pid;
-        this.version = version;
-        this.vmName = vmName;
-        this.vmVersion = vmVersion;
-        this.vmVendor = vmVendor;
-        this.bundledJdk = bundledJdk;
-        this.usingBundledJdk = usingBundledJdk;
-        this.startTime = startTime;
-        this.configuredInitialHeapSize = configuredInitialHeapSize;
-        this.configuredMaxHeapSize = configuredMaxHeapSize;
-        this.mem = mem;
-        this.inputArguments = inputArguments;
-        this.bootClassPath = bootClassPath;
-        this.classPath = classPath;
-        this.systemProperties = systemProperties;
-        this.gcCollectors = gcCollectors;
-        this.memoryPools = memoryPools;
-        this.onError = onError;
-        this.onOutOfMemoryError = onOutOfMemoryError;
-        this.useCompressedOops = useCompressedOops;
-        this.useG1GC = useG1GC;
-        this.useSerialGC = useSerialGC;
-        this.g1RegionSize = g1RegionSize;
-    }
-
-    public ProtobufJvmInfo(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        pid = in.readInt64();
-        version = in.readString();
-        vmName = in.readString();
-        vmVersion = in.readString();
-        vmVendor = in.readString();
-        bundledJdk = in.readBool();
-        usingBundledJdk = protobufStreamInput.readOptionalBoolean();
-        startTime = in.readInt64();
-        inputArguments = new String[in.readInt32()];
-        for (int i = 0; i < inputArguments.length; i++) {
-            inputArguments[i] = in.readString();
-        }
-        bootClassPath = in.readString();
-        classPath = in.readString();
-        systemProperties = protobufStreamInput.readMap(CodedInputStream::readString, CodedInputStream::readString);
-        mem = new Mem(in);
-        gcCollectors = protobufStreamInput.readStringArray();
-        memoryPools = protobufStreamInput.readStringArray();
-        useCompressedOops = in.readString();
-        // the following members are only used locally for bootstrap checks, never serialized nor printed out
-        this.configuredMaxHeapSize = -1;
-        this.configuredInitialHeapSize = -1;
-        this.onError = null;
-        this.onOutOfMemoryError = null;
-        this.useG1GC = "unknown";
-        this.useSerialGC = "unknown";
-        this.g1RegionSize = -1;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeInt64NoTag(pid);
-        out.writeStringNoTag(version);
-        out.writeStringNoTag(vmName);
-        out.writeStringNoTag(vmVersion);
-        out.writeStringNoTag(vmVendor);
-        out.writeBoolNoTag(bundledJdk);
-        protobufStreamOutput.writeOptionalBoolean(usingBundledJdk);
-        out.writeInt64NoTag(startTime);
-        out.writeInt32NoTag(inputArguments.length);
-        for (String inputArgument : inputArguments) {
-            out.writeStringNoTag(inputArgument);
-        }
-        out.writeStringNoTag(bootClassPath);
-        out.writeStringNoTag(classPath);
-        out.writeInt32NoTag(this.systemProperties.size());
-        for (Map.Entry<String, String> entry : systemProperties.entrySet()) {
-            out.writeStringNoTag(entry.getKey());
-            out.writeStringNoTag(entry.getValue());
-        }
-        mem.writeTo(out);
-        protobufStreamOutput.writeStringArray(gcCollectors);
-        protobufStreamOutput.writeStringArray(memoryPools);
-        out.writeStringNoTag(useCompressedOops);
-    }
-
-    /**
-     * The process id.
-    */
-    public long pid() {
-        return this.pid;
-    }
-
-    /**
-     * The process id.
-    */
-    public long getPid() {
-        return pid;
-    }
-
-    public String version() {
-        return this.version;
-    }
-
-    public String getVersion() {
-        return this.version;
-    }
-
-    public int versionAsInteger() {
-        try {
-            int i = 0;
-            StringBuilder sVersion = new StringBuilder();
-            for (; i < version.length(); i++) {
-                if (!Character.isDigit(version.charAt(i)) && version.charAt(i) != '.') {
-                    break;
-                }
-                if (version.charAt(i) != '.') {
-                    sVersion.append(version.charAt(i));
-                }
-            }
-            if (i == 0) {
-                return -1;
-            }
-            return Integer.parseInt(sVersion.toString());
-        } catch (Exception e) {
-            return -1;
-        }
-    }
-
-    public int versionUpdatePack() {
-        try {
-            int i = 0;
-            StringBuilder sVersion = new StringBuilder();
-            for (; i < version.length(); i++) {
-                if (!Character.isDigit(version.charAt(i)) && version.charAt(i) != '.') {
-                    break;
-                }
-                if (version.charAt(i) != '.') {
-                    sVersion.append(version.charAt(i));
-                }
-            }
-            if (i == 0) {
-                return -1;
-            }
-            Integer.parseInt(sVersion.toString());
-            int from;
-            if (version.charAt(i) == '_') {
-                // 1.7.0_4
-                from = ++i;
-            } else if (version.charAt(i) == '-' && version.charAt(i + 1) == 'u') {
-                // 1.7.0-u2-b21
-                i = i + 2;
-                from = i;
-            } else {
-                return -1;
-            }
-            for (; i < version.length(); i++) {
-                if (!Character.isDigit(version.charAt(i)) && version.charAt(i) != '.') {
-                    break;
-                }
-            }
-            if (from == i) {
-                return -1;
-            }
-            return Integer.parseInt(version.substring(from, i));
-        } catch (Exception e) {
-            return -1;
-        }
-    }
-
-    public String getVmName() {
-        return this.vmName;
-    }
-
-    public String getVmVersion() {
-        return this.vmVersion;
-    }
-
-    public String getVmVendor() {
-        return this.vmVendor;
-    }
-
-    public boolean getBundledJdk() {
-        return bundledJdk;
-    }
-
-    public Boolean getUsingBundledJdk() {
-        return usingBundledJdk;
-    }
-
-    public long getStartTime() {
-        return this.startTime;
-    }
-
-    public Mem getMem() {
-        return this.mem;
-    }
-
-    public String[] getInputArguments() {
-        return this.inputArguments;
-    }
-
-    public String getBootClassPath() {
-        return this.bootClassPath;
-    }
-
-    public String getClassPath() {
-        return this.classPath;
-    }
-
-    public Map<String, String> getSystemProperties() {
-        return this.systemProperties;
-    }
-
-    public long getConfiguredInitialHeapSize() {
-        return configuredInitialHeapSize;
-    }
-
-    public long getConfiguredMaxHeapSize() {
-        return configuredMaxHeapSize;
-    }
-
-    public String onError() {
-        return onError;
-    }
-
-    public String onOutOfMemoryError() {
-        return onOutOfMemoryError;
-    }
-
-    /**
-     * The value of the JVM flag UseCompressedOops, if available otherwise
-    * "unknown". The value "unknown" indicates that an attempt was
-    * made to obtain the value of the flag on this JVM and the attempt
-    * failed.
-    *
-    * @return the value of the JVM flag UseCompressedOops or "unknown"
-    */
-    public String useCompressedOops() {
-        return this.useCompressedOops;
-    }
-
-    public String useG1GC() {
-        return this.useG1GC;
-    }
-
-    public String useSerialGC() {
-        return this.useSerialGC;
-    }
-
-    public long getG1RegionSize() {
-        return g1RegionSize;
-    }
-
-    public String[] getGcCollectors() {
-        return gcCollectors;
-    }
-
-    public String[] getMemoryPools() {
-        return memoryPools;
-    }
-
-    /**
-     * Memory information.
-    *
-    * @opensearch.internal
-    */
-    public static class Mem implements ProtobufWriteable {
-
-        private final long heapInit;
-        private final long heapMax;
-        private final long nonHeapInit;
-        private final long nonHeapMax;
-        private final long directMemoryMax;
-
-        public Mem(long heapInit, long heapMax, long nonHeapInit, long nonHeapMax, long directMemoryMax) {
-            this.heapInit = heapInit;
-            this.heapMax = heapMax;
-            this.nonHeapInit = nonHeapInit;
-            this.nonHeapMax = nonHeapMax;
-            this.directMemoryMax = directMemoryMax;
-        }
-
-        public Mem(CodedInputStream in) throws IOException {
-            this.heapInit = in.readInt64();
-            this.heapMax = in.readInt64();
-            this.nonHeapInit = in.readInt64();
-            this.nonHeapMax = in.readInt64();
-            this.directMemoryMax = in.readInt64();
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeInt64NoTag(heapInit);
-            out.writeInt64NoTag(heapMax);
-            out.writeInt64NoTag(nonHeapInit);
-            out.writeInt64NoTag(nonHeapMax);
-            out.writeInt64NoTag(directMemoryMax);
-        }
-
-        public ByteSizeValue getHeapInit() {
-            return new ByteSizeValue(heapInit);
-        }
-
-        public ByteSizeValue getHeapMax() {
-            return new ByteSizeValue(heapMax);
-        }
-
-        public ByteSizeValue getNonHeapInit() {
-            return new ByteSizeValue(nonHeapInit);
-        }
-
-        public ByteSizeValue getNonHeapMax() {
-            return new ByteSizeValue(nonHeapMax);
-        }
-
-        public ByteSizeValue getDirectMemoryMax() {
-            return new ByteSizeValue(directMemoryMax);
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmService.java b/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmService.java
new file mode 100644
index 0000000000000..63d3428086621
--- /dev/null
+++ b/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmService.java
@@ -0,0 +1,61 @@
+/*
+ * 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.
+ */
+
+package org.opensearch.monitor.jvm;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Setting.Property;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.node.ProtobufReportingService;
+
+/**
+ * Service for monitoring the JVM
+ *
+ * @opensearch.internal
+ */
+public class ProtobufJvmService implements ProtobufReportingService<JvmInfo> {
+
+    private static final Logger logger = LogManager.getLogger(ProtobufJvmService.class);
+
+    private final JvmInfo jvmInfo;
+
+    private final TimeValue refreshInterval;
+
+    private ProtobufJvmStats jvmStats;
+
+    public static final Setting<TimeValue> REFRESH_INTERVAL_SETTING = Setting.timeSetting(
+        "monitor.jvm.refresh_interval",
+        TimeValue.timeValueSeconds(1),
+        TimeValue.timeValueSeconds(1),
+        Property.NodeScope
+    );
+
+    public ProtobufJvmService(Settings settings) {
+        this.jvmInfo = JvmInfo.jvmInfo();
+        this.jvmStats = ProtobufJvmStats.jvmStats();
+
+        this.refreshInterval = REFRESH_INTERVAL_SETTING.get(settings);
+
+        logger.debug("using refresh_interval [{}]", refreshInterval);
+    }
+
+    @Override
+    public JvmInfo protobufInfo() {
+        return this.jvmInfo;
+    }
+
+    public synchronized ProtobufJvmStats stats() {
+        if ((System.currentTimeMillis() - jvmStats.getTimestamp()) > refreshInterval.millis()) {
+            jvmStats = ProtobufJvmStats.jvmStats();
+        }
+        return jvmStats;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/monitor/os/OsProbe.java b/server/src/main/java/org/opensearch/monitor/os/OsProbe.java
index 98229941252ba..b2393a346db2e 100644
--- a/server/src/main/java/org/opensearch/monitor/os/OsProbe.java
+++ b/server/src/main/java/org/opensearch/monitor/os/OsProbe.java
@@ -433,6 +433,40 @@ private OsStats.Cgroup.CpuStat getCgroupCpuAcctCpuStat(final String controlGroup
         return new OsStats.Cgroup.CpuStat(numberOfPeriods, numberOfTimesThrottled, timeThrottledNanos);
     }
 
+    private ProtobufOsStats.Cgroup.CpuStat getProtobufCgroupCpuAcctCpuStat(final String controlGroup) throws IOException {
+        final List<String> lines = readSysFsCgroupCpuAcctCpuStat(controlGroup);
+        long numberOfPeriods = -1;
+        long numberOfTimesThrottled = -1;
+        long timeThrottledNanos = -1;
+
+        for (final String line : lines) {
+            final String[] fields = line.split("\\s+");
+            switch (fields[0]) {
+                case "nr_periods":
+                    numberOfPeriods = Long.parseLong(fields[1]);
+                    break;
+                case "nr_throttled":
+                    numberOfTimesThrottled = Long.parseLong(fields[1]);
+                    break;
+                case "throttled_time":
+                    timeThrottledNanos = Long.parseLong(fields[1]);
+                    break;
+            }
+        }
+        if (isCpuStatWarningsLogged.getAndSet(true) == false) {
+            if (numberOfPeriods == -1) {
+                logger.warn("Expected to see nr_periods filed but found nothing");
+            }
+            if (numberOfTimesThrottled == -1) {
+                logger.warn("Expected to see nr_throttled filed but found nothing");
+            }
+            if (timeThrottledNanos == -1) {
+                logger.warn("Expected to see throttled_time filed but found nothing");
+            }
+        }
+        return new ProtobufOsStats.Cgroup.CpuStat(numberOfPeriods, numberOfTimesThrottled, timeThrottledNanos);
+    }
+
     /**
      * Returns the lines from {@code cpu.stat} for the control group to which the OpenSearch process belongs for the {@code cpu}
      * subsystem. These lines represent the CPU time statistics and have the form
@@ -592,6 +626,61 @@ private OsStats.Cgroup getCgroup() {
         }
     }
 
+    /**
+     * Basic cgroup stats.
+     *
+     * @return basic cgroup stats, or {@code null} if an I/O exception occurred reading the cgroup stats
+     */
+    private ProtobufOsStats.Cgroup getProtobufCgroup() {
+        try {
+            if (!areCgroupStatsAvailable()) {
+                return null;
+            } else {
+                final Map<String, String> controllerMap = getControlGroups();
+                assert !controllerMap.isEmpty();
+
+                final String cpuAcctControlGroup = controllerMap.get("cpuacct");
+                if (cpuAcctControlGroup == null) {
+                    logger.debug("no [cpuacct] data found in cgroup stats");
+                    return null;
+                }
+                final long cgroupCpuAcctUsageNanos = getCgroupCpuAcctUsageNanos(cpuAcctControlGroup);
+
+                final String cpuControlGroup = controllerMap.get("cpu");
+                if (cpuControlGroup == null) {
+                    logger.debug("no [cpu] data found in cgroup stats");
+                    return null;
+                }
+                final long cgroupCpuAcctCpuCfsPeriodMicros = getCgroupCpuAcctCpuCfsPeriodMicros(cpuControlGroup);
+                final long cgroupCpuAcctCpuCfsQuotaMicros = getCgroupCpuAcctCpuCfsQuotaMicros(cpuControlGroup);
+                final ProtobufOsStats.Cgroup.CpuStat cpuStat = getProtobufCgroupCpuAcctCpuStat(cpuControlGroup);
+
+                final String memoryControlGroup = controllerMap.get("memory");
+                if (memoryControlGroup == null) {
+                    logger.debug("no [memory] data found in cgroup stats");
+                    return null;
+                }
+                final String cgroupMemoryLimitInBytes = getCgroupMemoryLimitInBytes(memoryControlGroup);
+                final String cgroupMemoryUsageInBytes = getCgroupMemoryUsageInBytes(memoryControlGroup);
+
+                return new ProtobufOsStats.Cgroup(
+                    cpuAcctControlGroup,
+                    cgroupCpuAcctUsageNanos,
+                    cpuControlGroup,
+                    cgroupCpuAcctCpuCfsPeriodMicros,
+                    cgroupCpuAcctCpuCfsQuotaMicros,
+                    cpuStat,
+                    memoryControlGroup,
+                    cgroupMemoryLimitInBytes,
+                    cgroupMemoryUsageInBytes
+                );
+            }
+        } catch (final IOException e) {
+            logger.debug("error reading control group stats", e);
+            return null;
+        }
+    }
+
     private static class OsProbeHolder {
         private static final OsProbe INSTANCE = new OsProbe();
     }
@@ -625,6 +714,18 @@ OsInfo osInfo(long refreshInterval, int allocatedProcessors) throws IOException
         );
     }
 
+    ProtobufOsInfo protobufOsInfo(long refreshInterval, int allocatedProcessors) throws IOException {
+        return new ProtobufOsInfo(
+            refreshInterval,
+            Runtime.getRuntime().availableProcessors(),
+            allocatedProcessors,
+            Constants.OS_NAME,
+            getPrettyName(),
+            Constants.OS_ARCH,
+            Constants.OS_VERSION
+        );
+    }
+
     private String getPrettyName() throws IOException {
         // TODO: return a prettier name on non-Linux OS
         if (Constants.LINUX) {
@@ -696,6 +797,14 @@ public OsStats osStats() {
         return new OsStats(System.currentTimeMillis(), cpu, mem, swap, cgroup);
     }
 
+    public ProtobufOsStats protobufOsStats() {
+        final ProtobufOsStats.Cpu cpu = new ProtobufOsStats.Cpu(getSystemCpuPercent(), getSystemLoadAverage());
+        final ProtobufOsStats.Mem mem = new ProtobufOsStats.Mem(getTotalPhysicalMemorySize(), getFreePhysicalMemorySize());
+        final ProtobufOsStats.Swap swap = new ProtobufOsStats.Swap(getTotalSwapSpaceSize(), getFreeSwapSpaceSize());
+        final ProtobufOsStats.Cgroup cgroup = Constants.LINUX ? getProtobufCgroup() : null;
+        return new ProtobufOsStats(System.currentTimeMillis(), cpu, mem, swap, cgroup);
+    }
+
     /**
      * Returns a given method of the OperatingSystemMXBean, or null if the method is not found or unavailable.
      */
diff --git a/server/src/main/java/org/opensearch/monitor/os/ProtobufOsInfo.java b/server/src/main/java/org/opensearch/monitor/os/ProtobufOsInfo.java
index dc898d991626d..ff029fe223cc7 100644
--- a/server/src/main/java/org/opensearch/monitor/os/ProtobufOsInfo.java
+++ b/server/src/main/java/org/opensearch/monitor/os/ProtobufOsInfo.java
@@ -13,6 +13,9 @@
 
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.xcontent.ToXContent.Params;
+import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.node.ProtobufReportingService;
 
 import java.io.IOException;
@@ -100,4 +103,38 @@ public String getArch() {
     public String getVersion() {
         return version;
     }
+
+    static final class Fields {
+        static final String OS = "os";
+        static final String NAME = "name";
+        static final String PRETTY_NAME = "pretty_name";
+        static final String ARCH = "arch";
+        static final String VERSION = "version";
+        static final String REFRESH_INTERVAL = "refresh_interval";
+        static final String REFRESH_INTERVAL_IN_MILLIS = "refresh_interval_in_millis";
+        static final String AVAILABLE_PROCESSORS = "available_processors";
+        static final String ALLOCATED_PROCESSORS = "allocated_processors";
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.OS);
+        builder.humanReadableField(Fields.REFRESH_INTERVAL_IN_MILLIS, Fields.REFRESH_INTERVAL, new TimeValue(refreshInterval));
+        if (name != null) {
+            builder.field(Fields.NAME, name);
+        }
+        if (prettyName != null) {
+            builder.field(Fields.PRETTY_NAME, prettyName);
+        }
+        if (arch != null) {
+            builder.field(Fields.ARCH, arch);
+        }
+        if (version != null) {
+            builder.field(Fields.VERSION, version);
+        }
+        builder.field(Fields.AVAILABLE_PROCESSORS, availableProcessors);
+        builder.field(Fields.ALLOCATED_PROCESSORS, allocatedProcessors);
+        builder.endObject();
+        return builder;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/monitor/os/ProtobufOsService.java b/server/src/main/java/org/opensearch/monitor/os/ProtobufOsService.java
new file mode 100644
index 0000000000000..37ecaf2b5269f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/monitor/os/ProtobufOsService.java
@@ -0,0 +1,70 @@
+/*
+ * 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.
+ */
+
+package org.opensearch.monitor.os;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Setting.Property;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.SingleObjectCache;
+import org.opensearch.common.util.concurrent.OpenSearchExecutors;
+import org.opensearch.node.ProtobufReportingService;
+
+import java.io.IOException;
+
+/**
+ * Service for the Operating System
+ *
+ * @opensearch.internal
+ */
+public class ProtobufOsService implements ProtobufReportingService<ProtobufOsInfo> {
+
+    private static final Logger logger = LogManager.getLogger(ProtobufOsService.class);
+
+    private final OsProbe probe;
+    private final ProtobufOsInfo info;
+    private final SingleObjectCache<ProtobufOsStats> osStatsCache;
+
+    public static final Setting<TimeValue> REFRESH_INTERVAL_SETTING = Setting.timeSetting(
+        "monitor.os.refresh_interval",
+        TimeValue.timeValueSeconds(1),
+        TimeValue.timeValueSeconds(1),
+        Property.NodeScope
+    );
+
+    public ProtobufOsService(Settings settings) throws IOException {
+        this.probe = OsProbe.getInstance();
+        TimeValue refreshInterval = REFRESH_INTERVAL_SETTING.get(settings);
+        this.info = probe.protobufOsInfo(refreshInterval.millis(), OpenSearchExecutors.allocatedProcessors(settings));
+        this.osStatsCache = new OsStatsCache(refreshInterval, probe.protobufOsStats());
+        logger.debug("using refresh_interval [{}]", refreshInterval);
+    }
+
+    @Override
+    public ProtobufOsInfo protobufInfo() {
+        return this.info;
+    }
+
+    public synchronized ProtobufOsStats stats() {
+        return osStatsCache.getOrRefresh();
+    }
+
+    private class OsStatsCache extends SingleObjectCache<ProtobufOsStats> {
+        OsStatsCache(TimeValue interval, ProtobufOsStats initValue) {
+            super(interval, initValue);
+        }
+
+        @Override
+        protected ProtobufOsStats refresh() {
+            return probe.protobufOsStats();
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/monitor/process/ProcessProbe.java b/server/src/main/java/org/opensearch/monitor/process/ProcessProbe.java
index c2f83003d2c04..aa3b535cf0d30 100644
--- a/server/src/main/java/org/opensearch/monitor/process/ProcessProbe.java
+++ b/server/src/main/java/org/opensearch/monitor/process/ProcessProbe.java
@@ -147,12 +147,22 @@ public ProcessInfo processInfo(long refreshInterval) {
         return new ProcessInfo(jvmInfo().pid(), BootstrapInfo.isMemoryLocked(), refreshInterval);
     }
 
+    public ProtobufProcessInfo protobufProcessInfo(long refreshInterval) {
+        return new ProtobufProcessInfo(jvmInfo().pid(), BootstrapInfo.isMemoryLocked(), refreshInterval);
+    }
+
     public ProcessStats processStats() {
         ProcessStats.Cpu cpu = new ProcessStats.Cpu(getProcessCpuPercent(), getProcessCpuTotalTime());
         ProcessStats.Mem mem = new ProcessStats.Mem(getTotalVirtualMemorySize());
         return new ProcessStats(System.currentTimeMillis(), getOpenFileDescriptorCount(), getMaxFileDescriptorCount(), cpu, mem);
     }
 
+    public ProtobufProcessStats processProtobufStats() {
+        ProtobufProcessStats.Cpu cpu = new ProtobufProcessStats.Cpu(getProcessCpuPercent(), getProcessCpuTotalTime());
+        ProtobufProcessStats.Mem mem = new ProtobufProcessStats.Mem(getTotalVirtualMemorySize());
+        return new ProtobufProcessStats(System.currentTimeMillis(), getOpenFileDescriptorCount(), getMaxFileDescriptorCount(), cpu, mem);
+    }
+
     /**
      * Returns a given method of the OperatingSystemMXBean,
      * or null if the method is not found or unavailable.
diff --git a/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessInfo.java b/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessInfo.java
index ea7b1960c0372..7c9895411fbd1 100644
--- a/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessInfo.java
+++ b/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessInfo.java
@@ -10,6 +10,9 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
+
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.node.ProtobufReportingService;
 
 import java.io.IOException;
@@ -62,4 +65,22 @@ public long getId() {
     public boolean isMlockall() {
         return mlockall;
     }
+
+    static final class Fields {
+        static final String PROCESS = "process";
+        static final String REFRESH_INTERVAL = "refresh_interval";
+        static final String REFRESH_INTERVAL_IN_MILLIS = "refresh_interval_in_millis";
+        static final String ID = "id";
+        static final String MLOCKALL = "mlockall";
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.PROCESS);
+        builder.humanReadableField(Fields.REFRESH_INTERVAL_IN_MILLIS, Fields.REFRESH_INTERVAL, new TimeValue(refreshInterval));
+        builder.field(Fields.ID, id);
+        builder.field(Fields.MLOCKALL, mlockall);
+        builder.endObject();
+        return builder;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessService.java b/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessService.java
new file mode 100644
index 0000000000000..6de862abc7e9e
--- /dev/null
+++ b/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessService.java
@@ -0,0 +1,67 @@
+/*
+ * 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.
+ */
+
+package org.opensearch.monitor.process;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Setting.Property;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.SingleObjectCache;
+import org.opensearch.node.ProtobufReportingService;
+
+/**
+ * The service for the process
+ *
+ * @opensearch.internal
+ */
+public final class ProtobufProcessService implements ProtobufReportingService<ProtobufProcessInfo> {
+
+    private static final Logger logger = LogManager.getLogger(ProtobufProcessService.class);
+
+    private final ProcessProbe probe;
+    private final ProtobufProcessInfo info;
+    private final SingleObjectCache<ProtobufProcessStats> processStatsCache;
+
+    public static final Setting<TimeValue> REFRESH_INTERVAL_SETTING = Setting.timeSetting(
+        "monitor.process.refresh_interval",
+        TimeValue.timeValueSeconds(1),
+        TimeValue.timeValueSeconds(1),
+        Property.NodeScope
+    );
+
+    public ProtobufProcessService(Settings settings) {
+        this.probe = ProcessProbe.getInstance();
+        final TimeValue refreshInterval = REFRESH_INTERVAL_SETTING.get(settings);
+        processStatsCache = new ProcessStatsCache(refreshInterval, probe.processProtobufStats());
+        this.info = probe.protobufProcessInfo(refreshInterval.millis());
+        logger.debug("using refresh_interval [{}]", refreshInterval);
+    }
+
+    @Override
+    public ProtobufProcessInfo protobufInfo() {
+        return this.info;
+    }
+
+    public ProtobufProcessStats stats() {
+        return processStatsCache.getOrRefresh();
+    }
+
+    private class ProcessStatsCache extends SingleObjectCache<ProtobufProcessStats> {
+        ProcessStatsCache(TimeValue interval, ProtobufProcessStats initValue) {
+            super(interval, initValue);
+        }
+
+        @Override
+        protected ProtobufProcessStats refresh() {
+            return probe.processProtobufStats();
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/node/Node.java b/server/src/main/java/org/opensearch/node/Node.java
index 60c0d4c75879b..0ec80f0bfda21 100644
--- a/server/src/main/java/org/opensearch/node/Node.java
+++ b/server/src/main/java/org/opensearch/node/Node.java
@@ -114,7 +114,7 @@
 import org.opensearch.cluster.metadata.TemplateUpgradeService;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.routing.BatchedRerouteService;
 import org.opensearch.cluster.routing.RerouteService;
 import org.opensearch.cluster.routing.allocation.DiskThresholdMonitor;
@@ -184,6 +184,7 @@
 import org.opensearch.indices.store.IndicesStore;
 import org.opensearch.ingest.IngestService;
 import org.opensearch.monitor.MonitorService;
+import org.opensearch.monitor.ProtobufMonitorService;
 import org.opensearch.monitor.fs.FsHealthService;
 import org.opensearch.monitor.jvm.JvmInfo;
 import org.opensearch.persistent.PersistentTasksClusterService;
@@ -558,7 +559,8 @@ protected Node(
             }
             client = new NodeClient(settings, threadPool);
 
-            // final ProtobufThreadPool protobufThreadPool = new ProtobufThreadPool(settings, runnableTaskListener, executorBuilders.toArray(new ProtobufExecutorBuilder[0]));
+            // final ProtobufThreadPool protobufThreadPool = new ProtobufThreadPool(settings, runnableTaskListener,
+            // executorBuilders.toArray(new ProtobufExecutorBuilder[0]));
             // resourcesToClose.add(() -> ProtobufThreadPool.terminate(threadPool, 10, TimeUnit.SECONDS));
             // final ResourceWatcherService resourceWatcherServiceProtobuf = new ResourceWatcherService(settings, protobufThreadPool);
             // resourcesToClose.add(resourceWatcherServiceProtobuf);
@@ -567,7 +569,7 @@ protected Node(
             // resourcesToClose.add(() -> HeaderWarning.removeThreadContext(protobufThreadPool.getThreadContext()));
 
             // for (final ProtobufExecutorBuilder<?> builder : protobufThreadPool.builders()) {
-            //     additionalSettings.addAll(builder.getRegisteredSettings());
+            // additionalSettings.addAll(builder.getRegisteredSettings());
             // }
             protobufClient = new ProtobufNodeClient(settings, threadPool);
 
@@ -662,6 +664,12 @@ protected Node(
             initializeFileCache(settings, circuitBreakerService.getBreaker(CircuitBreaker.REQUEST));
             final FileCacheCleaner fileCacheCleaner = new FileCacheCleaner(nodeEnvironment, fileCache);
             final MonitorService monitorService = new MonitorService(settings, nodeEnvironment, threadPool, fileCache);
+            final ProtobufMonitorService protobufMonitorService = new ProtobufMonitorService(
+                settings,
+                nodeEnvironment,
+                threadPool,
+                fileCache
+            );
 
             pluginsService.filterPlugins(CircuitBreakerPlugin.class).forEach(plugin -> {
                 CircuitBreaker breaker = circuitBreakerService.getBreaker(plugin.getCircuitBreaker(settings).getName());
@@ -831,17 +839,17 @@ protected Node(
                 .collect(Collectors.toList());
 
             // ActionModule actionModule = new ActionModule(
-            //     settings,
-            //     clusterModule.getIndexNameExpressionResolver(),
-            //     settingsModule.getIndexScopedSettings(),
-            //     settingsModule.getClusterSettings(),
-            //     settingsModule.getSettingsFilter(),
-            //     threadPool,
-            //     pluginsService.filterPlugins(ActionPlugin.class),
-            //     client,
-            //     circuitBreakerService,
-            //     usageService,
-            //     systemIndices
+            // settings,
+            // clusterModule.getIndexNameExpressionResolver(),
+            // settingsModule.getIndexScopedSettings(),
+            // settingsModule.getClusterSettings(),
+            // settingsModule.getSettingsFilter(),
+            // threadPool,
+            // pluginsService.filterPlugins(ActionPlugin.class),
+            // client,
+            // circuitBreakerService,
+            // usageService,
+            // systemIndices
             // );
             // modules.add(actionModule);
 
@@ -922,14 +930,14 @@ protected Node(
             TopNSearchTasksLogger taskConsumer = new TopNSearchTasksLogger(settings, settingsModule.getClusterSettings());
             transportService.getTaskManager().registerTaskResourceConsumer(taskConsumer);
             // if (FeatureFlags.isEnabled(FeatureFlags.EXTENSIONS)) {
-            //     this.extensionsManager.initializeServicesAndRestHandler(
-            //         actionModule,
-            //         settingsModule,
-            //         transportService,
-            //         clusterService,
-            //         environment.settings(),
-            //         client
-            //     );
+            // this.extensionsManager.initializeServicesAndRestHandler(
+            // actionModule,
+            // settingsModule,
+            // transportService,
+            // clusterService,
+            // environment.settings(),
+            // client
+            // );
             // }
             final GatewayMetaState gatewayMetaState = new GatewayMetaState();
             final ResponseCollectorService responseCollectorService = new ResponseCollectorService(clusterService);
@@ -1078,30 +1086,7 @@ protected Node(
             this.protobufNodeService = new ProtobufNodeService(
                 settings,
                 threadPool,
-                monitorService,
-                discoveryModule.getDiscovery(),
-                protobufTransportService,
-                indicesService,
-                pluginsService,
-                circuitBreakerService,
-                scriptService,
-                httpServerTransport,
-                ingestService,
-                clusterService,
-                settingsModule.getSettingsFilter(),
-                responseCollectorService,
-                searchTransportService,
-                indexingPressureService,
-                searchModule.getValuesSourceRegistry().getUsageService(),
-                searchBackpressureService,
-                searchPipelineService,
-                fileCache,
-                taskCancellationMonitoringService
-            );
-            this.protobufNodeService = new ProtobufNodeService(
-                settings,
-                threadPool,
-                monitorService,
+                protobufMonitorService,
                 discoveryModule.getDiscovery(),
                 protobufTransportService,
                 indicesService,
@@ -1288,8 +1273,10 @@ protected Node(
             this.namedWriteableRegistry = namedWriteableRegistry;
 
             ProtobufDynamicActionRegistry protobufDynamicActionRegistry = protobufActionModule.getProtobufDynamicActionRegistry();
-            protobufDynamicActionRegistry.registerUnmodifiableActionMap(injector.getInstance(new Key<Map<ProtobufActionType, ProtobufTransportAction>>() {
-            }));
+            protobufDynamicActionRegistry.registerUnmodifiableActionMap(
+                injector.getInstance(new Key<Map<ProtobufActionType, ProtobufTransportAction>>() {
+                })
+            );
             protobufClient.initialize(
                 protobufDynamicActionRegistry,
                 () -> clusterService.localNode().getId(),
@@ -1329,7 +1316,7 @@ protected ProtobufTransportService newProtobufTransportService(
         Transport transport,
         ThreadPool threadPool,
         ProtobufTransportInterceptor interceptor,
-        Function<ProtobufBoundTransportAddress, ProtobufDiscoveryNode> localNodeFactory,
+        Function<ProtobufBoundTransportAddress, DiscoveryNode> localNodeFactory,
         ClusterSettings clusterSettings,
         Set<String> taskHeaders
     ) {
@@ -1419,6 +1406,11 @@ public Node start() throws NodeValidationException {
         assert localNodeFactory.getNode() != null;
         assert transportService.getLocalNode().equals(localNodeFactory.getNode())
             : "transportService has a different local node than the factory provided";
+        protobufTransportService.start();
+        protobufTransportService.setLocalNode(localNodeFactory.getNode());
+        assert localNodeFactory.getNode() != null;
+        assert protobufTransportService.getLocalNode().equals(localNodeFactory.getNode())
+            : "protobufTransportService has a different local node than the factory provided";
         injector.getInstance(PeerRecoverySourceService.class).start();
         injector.getInstance(SegmentReplicationSourceService.class).start();
 
@@ -1465,7 +1457,7 @@ public Node start() throws NodeValidationException {
         assert clusterService.localNode().equals(localNodeFactory.getNode())
             : "clusterService has a different local node than the factory provided";
         transportService.acceptIncomingRequests();
-        // protobufTransportService.acceptIncomingRequests();
+        protobufTransportService.acceptIncomingRequests();
         discovery.startInitialJoin();
         final TimeValue initialStateTimeout = DiscoverySettings.INITIAL_STATE_TIMEOUT_SETTING.get(settings());
         configureNodeAndClusterIdStateListener(clusterService);
@@ -1476,7 +1468,13 @@ public Node start() throws NodeValidationException {
             ClusterState clusterState = clusterService.state();
             ProtobufClusterState protobufClusterState = clusterService.protobufState();
             ClusterStateObserver observer = new ClusterStateObserver(clusterState, clusterService, null, logger, thread.getThreadContext());
-            ProtobufClusterStateObserver protobufObserver = new ProtobufClusterStateObserver(protobufClusterState, clusterService, null, logger, thread.getThreadContext());
+            ProtobufClusterStateObserver protobufObserver = new ProtobufClusterStateObserver(
+                protobufClusterState,
+                clusterService,
+                null,
+                logger,
+                thread.getThreadContext()
+            );
 
             if (clusterState.nodes().getClusterManagerNodeId() == null) {
                 logger.debug("waiting to join the cluster. timeout [{}]", initialStateTimeout);
@@ -1896,8 +1894,8 @@ DiscoveryNode getNode() {
         }
     }
 
-    private static class ProtobufLocalNodeFactory implements Function<ProtobufBoundTransportAddress, ProtobufDiscoveryNode> {
-        private final SetOnce<ProtobufDiscoveryNode> localNode = new SetOnce<>();
+    private static class ProtobufLocalNodeFactory implements Function<ProtobufBoundTransportAddress, DiscoveryNode> {
+        private final SetOnce<DiscoveryNode> localNode = new SetOnce<>();
         private final String persistentNodeId;
         private final Settings settings;
 
@@ -1907,12 +1905,18 @@ private ProtobufLocalNodeFactory(Settings settings, String persistentNodeId) {
         }
 
         @Override
-        public ProtobufDiscoveryNode apply(ProtobufBoundTransportAddress boundTransportAddress) {
-            localNode.set(ProtobufDiscoveryNode.createLocal(settings, boundTransportAddress.publishAddress(), persistentNodeId));
+        public DiscoveryNode apply(ProtobufBoundTransportAddress boundTransportAddress) {
+            localNode.set(
+                DiscoveryNode.createLocal(
+                    settings,
+                    new TransportAddress(boundTransportAddress.publishAddress().address()),
+                    persistentNodeId
+                )
+            );
             return localNode.get();
         }
 
-        ProtobufDiscoveryNode getNode() {
+        DiscoveryNode getNode() {
             assert localNode.get() != null;
             return localNode.get();
         }
diff --git a/server/src/main/java/org/opensearch/node/ProtobufNodeClosedException.java b/server/src/main/java/org/opensearch/node/ProtobufNodeClosedException.java
index cf5ab03c8bb91..a07b7e39cdd0f 100644
--- a/server/src/main/java/org/opensearch/node/ProtobufNodeClosedException.java
+++ b/server/src/main/java/org/opensearch/node/ProtobufNodeClosedException.java
@@ -10,7 +10,7 @@
 
 import com.google.protobuf.CodedInputStream;
 import org.opensearch.ProtobufOpenSearchException;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 
 import java.io.IOException;
 
@@ -21,7 +21,7 @@
 */
 public class ProtobufNodeClosedException extends ProtobufOpenSearchException {
 
-    public ProtobufNodeClosedException(ProtobufDiscoveryNode node) {
+    public ProtobufNodeClosedException(DiscoveryNode node) {
         super("node closed " + node);
     }
 
diff --git a/server/src/main/java/org/opensearch/node/ProtobufNodeService.java b/server/src/main/java/org/opensearch/node/ProtobufNodeService.java
index b774178bb8122..0f0b600881d78 100644
--- a/server/src/main/java/org/opensearch/node/ProtobufNodeService.java
+++ b/server/src/main/java/org/opensearch/node/ProtobufNodeService.java
@@ -8,13 +8,12 @@
 
 package org.opensearch.node;
 
-import org.opensearch.cluster.routing.WeightedRoutingStats;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.Build;
 import org.opensearch.Version;
 import org.opensearch.action.admin.cluster.node.info.ProtobufNodeInfo;
 import org.opensearch.action.admin.cluster.node.stats.ProtobufNodeStats;
-import org.opensearch.action.admin.indices.stats.ProtobufCommonStatsFlags;
+import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
 import org.opensearch.action.search.SearchTransportService;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.Nullable;
@@ -27,7 +26,7 @@
 import org.opensearch.indices.IndicesService;
 import org.opensearch.indices.breaker.CircuitBreakerService;
 import org.opensearch.ingest.IngestService;
-import org.opensearch.monitor.MonitorService;
+import org.opensearch.monitor.ProtobufMonitorService;
 import org.opensearch.plugins.PluginsService;
 import org.opensearch.script.ScriptService;
 import org.opensearch.search.aggregations.support.AggregationUsageService;
@@ -48,7 +47,7 @@
 public class ProtobufNodeService implements Closeable {
     private final Settings settings;
     private final ThreadPool threadPool;
-    private final MonitorService monitorService;
+    private final ProtobufMonitorService monitorService;
     private final ProtobufTransportService transportService;
     private final IndicesService indicesService;
     private final PluginsService pluginService;
@@ -70,7 +69,7 @@ public class ProtobufNodeService implements Closeable {
     ProtobufNodeService(
         Settings settings,
         ThreadPool threadPool,
-        MonitorService monitorService,
+        ProtobufMonitorService monitorService,
         Discovery discovery,
         ProtobufTransportService transportService,
         IndicesService indicesService,
@@ -131,44 +130,44 @@ public ProtobufNodeInfo info(
         if (settings) {
             builder.setSettings(settingsFilter.filter(this.settings));
         }
-        // if (os) {
-        //     builder.setOs(monitorService.osService().info());
-        // }
-        // if (process) {
-        //     builder.setProcess(monitorService.processService().info());
-        // }
-        // if (jvm) {
-        //     builder.setJvm(monitorService.jvmService().info());
-        // }
+        if (os) {
+            builder.setOs(monitorService.osService().protobufInfo());
+        }
+        if (process) {
+            builder.setProcess(monitorService.processService().protobufInfo());
+        }
+        if (jvm) {
+            builder.setJvm(monitorService.jvmService().protobufInfo());
+        }
         if (threadPool) {
             builder.setThreadPool(this.threadPool.protobufInfo());
         }
         if (transport) {
             builder.setTransport(transportService.protobufInfo());
         }
-        // if (http && httpServerTransport != null) {
-        //     builder.setHttp(httpServerTransport.info());
-        // }
+        if (http && httpServerTransport != null) {
+            builder.setHttp(httpServerTransport.protobufInfo());
+        }
         // if (plugin && pluginService != null) {
-        //     builder.setPlugins(pluginService.info());
-        // }
-        // if (ingest && ingestService != null) {
-        //     builder.setIngest(ingestService.info());
-        // }
-        // if (aggs && aggregationUsageService != null) {
-        //     builder.setAggsInfo(aggregationUsageService.info());
+        // builder.setPlugins(pluginService.info());
         // }
+        if (ingest && ingestService != null) {
+            builder.setIngest(ingestService.protobufInfo());
+        }
+        if (aggs && aggregationUsageService != null) {
+            builder.setAggsInfo(aggregationUsageService.protobufInfo());
+        }
         if (indices) {
             builder.setTotalIndexingBuffer(indicesService.getTotalIndexingBufferBytes());
         }
-        // if (searchPipeline && searchPipelineService != null) {
-        //     builder.setSearchPipelineInfo(searchPipelineService.info());
-        // }
+        if (searchPipeline && searchPipelineService != null) {
+            builder.setProtobufSearchPipelineInfo(searchPipelineService.protobufInfo());
+        }
         return builder.build();
     }
 
     public ProtobufNodeStats stats(
-        ProtobufCommonStatsFlags indices,
+        CommonStatsFlags indices,
         boolean os,
         boolean process,
         boolean jvm,
@@ -194,19 +193,26 @@ public ProtobufNodeStats stats(
         return new ProtobufNodeStats(
             transportService.getLocalNode(),
             System.currentTimeMillis(),
-            null,
-            null,
-            null,
-            null,
+            indices.anySet() ? indicesService.protobufStats(indices) : null,
+            os ? monitorService.osService().stats() : null,
+            process ? monitorService.processService().stats() : null,
+            jvm ? monitorService.jvmService().stats() : null,
             threadPool ? this.threadPool.protobufStats() : null,
-            null,
+            fs ? monitorService.fsService().stats() : null,
             transport ? transportService.stats() : null,
-            null,
-            null,
-            null,
-            null,
-            null,
-            null
+            http ? (httpServerTransport == null ? null : httpServerTransport.protobufStats()) : null,
+            circuitBreaker ? circuitBreakerService.protobufStats() : null,
+            script ? scriptService.protobufStats() : null,
+            discoveryStats ? discovery.protobufStats() : null,
+            ingest ? ingestService.protobufStats() : null,
+            adaptiveSelection ? responseCollectorService.getProtobufAdaptiveStats(searchTransportService.getPendingSearchRequests()) : null
+            // scriptCache ? scriptService.cacheStats() : null,
+            // indexingPressure ? this.indexingPressureService.nodeStats() : null,
+            // shardIndexingPressure ? this.indexingPressureService.shardStats(indices) : null,
+            // searchBackpressure ? this.searchBackpressureService.nodeStats() : null,
+            // clusterManagerThrottling ? this.clusterService.getClusterManagerService().getThrottlingStats() : null,
+            // weightedRoutingStats ? WeightedRoutingStats.getInstance() : null,
+            // fileCacheStats && fileCache != null ? fileCache.fileCacheStats() : null
         );
     }
 
@@ -214,7 +220,7 @@ public IngestService getIngestService() {
         return ingestService;
     }
 
-    public MonitorService getMonitorService() {
+    public ProtobufMonitorService getMonitorService() {
         return monitorService;
     }
 
diff --git a/server/src/main/java/org/opensearch/node/ProtobufReportingService.java b/server/src/main/java/org/opensearch/node/ProtobufReportingService.java
index d6e54f245ea95..fbb90a7617148 100644
--- a/server/src/main/java/org/opensearch/node/ProtobufReportingService.java
+++ b/server/src/main/java/org/opensearch/node/ProtobufReportingService.java
@@ -9,6 +9,7 @@
 package org.opensearch.node;
 
 import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.xcontent.ToXContent;
 
 /**
  * Node reporting service
@@ -23,7 +24,7 @@ public interface ProtobufReportingService<I extends ProtobufReportingService.Pro
     *
     * @opensearch.internal
     */
-    interface ProtobufInfo extends ProtobufWriteable {
+    interface ProtobufInfo extends ProtobufWriteable, ToXContent {
 
     }
 }
diff --git a/server/src/main/java/org/opensearch/node/ResponseCollectorService.java b/server/src/main/java/org/opensearch/node/ResponseCollectorService.java
index 88b29764e4f07..8a527f4ae1161 100644
--- a/server/src/main/java/org/opensearch/node/ResponseCollectorService.java
+++ b/server/src/main/java/org/opensearch/node/ResponseCollectorService.java
@@ -81,10 +81,22 @@ public Map<String, ComputedNodeStats> getAllNodeStatistics() {
         return nodeStats;
     }
 
+    public Map<String, ProtobufComputedNodeStats> getAllNodeStatisticsProtobuf() {
+        final int clientNum = nodeIdToStats.size();
+        // Transform the mutable object internally used for accounting into the computed version
+        Map<String, ProtobufComputedNodeStats> nodeStats = new HashMap<>(nodeIdToStats.size());
+        nodeIdToStats.forEach((k, v) -> { nodeStats.put(k, new ProtobufComputedNodeStats(clientNum, v)); });
+        return nodeStats;
+    }
+
     public AdaptiveSelectionStats getAdaptiveStats(Map<String, Long> clientSearchConnections) {
         return new AdaptiveSelectionStats(clientSearchConnections, getAllNodeStatistics());
     }
 
+    public ProtobufAdaptiveSelectionStats getProtobufAdaptiveStats(Map<String, Long> clientSearchConnections) {
+        return new ProtobufAdaptiveSelectionStats(clientSearchConnections, getAllNodeStatisticsProtobuf());
+    }
+
     /**
      * Optionally return a {@code NodeStatistics} for the given nodeid, if
      * response information exists for the given node. Returns an empty
diff --git a/server/src/main/java/org/opensearch/plugins/ProtobufPluginInfo.java b/server/src/main/java/org/opensearch/plugins/ProtobufPluginInfo.java
index 29620fb5ee5dd..c82e40e71166e 100644
--- a/server/src/main/java/org/opensearch/plugins/ProtobufPluginInfo.java
+++ b/server/src/main/java/org/opensearch/plugins/ProtobufPluginInfo.java
@@ -16,6 +16,9 @@
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.xcontent.ToXContent.Params;
+import org.opensearch.core.xcontent.ToXContentObject;
+import org.opensearch.core.xcontent.XContentBuilder;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -35,7 +38,7 @@
 *
 * @opensearch.api
 */
-public class ProtobufPluginInfo implements ProtobufWriteable {
+public class ProtobufPluginInfo implements ProtobufWriteable, ToXContentObject {
 
     public static final String OPENSEARCH_PLUGIN_PROPERTIES = "plugin-descriptor.properties";
     public static final String OPENSEARCH_PLUGIN_POLICY = "plugin-security.policy";
@@ -347,4 +350,23 @@ public boolean hasNativeController() {
     public String getTargetFolderName() {
         return (this.customFolderName == null || this.customFolderName.isEmpty()) ? this.name : this.customFolderName;
     }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        {
+            builder.field("name", name);
+            builder.field("version", version);
+            builder.field("opensearch_version", opensearchVersion);
+            builder.field("java_version", javaVersion);
+            builder.field("description", description);
+            builder.field("classname", classname);
+            builder.field("custom_foldername", customFolderName);
+            builder.field("extended_plugins", extendedPlugins);
+            builder.field("has_native_controller", hasNativeController);
+        }
+        builder.endObject();
+
+        return builder;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/rest/BaseRestHandler.java b/server/src/main/java/org/opensearch/rest/BaseRestHandler.java
index 00b9b2fa1fec5..bcfff383f5199 100644
--- a/server/src/main/java/org/opensearch/rest/BaseRestHandler.java
+++ b/server/src/main/java/org/opensearch/rest/BaseRestHandler.java
@@ -103,8 +103,10 @@ public final long getUsageCount() {
 
     @Override
     public final void handleRequest(RestRequest request, RestChannel channel, NodeClient client) throws Exception {
+        logger.info("BaseRestHandler.handleRequest {}", request);
         // prepare the request for execution; has the side effect of touching the request parameters
         final RestChannelConsumer action = prepareRequest(request, client);
+        logger.info("BaseRestHandler.handleRequest action: {}", action);
 
         // validate unconsumed params, but we must exclude params used to format the response
         // use a sorted set so the unconsumed parameters appear in a reliable sorted order
diff --git a/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java b/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java
index 42dd853e87aba..6bc78abee594b 100644
--- a/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java
+++ b/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java
@@ -77,8 +77,10 @@ public final long getUsageCount() {
 
     @Override
     public final void handleRequest(RestRequest request, RestChannel channel, ProtobufNodeClient client) throws Exception {
+        logger.info("ProtobufBaseRestHandler.handleRequest {}", request);
         // prepare the request for execution; has the side effect of touching the request parameters
         final RestChannelConsumer action = prepareRequest(request, client);
+        logger.info("ProtobufBaseRestHandler.handleRequest action: {}", action.getClass().getName());
 
         // validate unconsumed params, but we must exclude params used to format the response
         // use a sorted set so the unconsumed parameters appear in a reliable sorted order
diff --git a/server/src/main/java/org/opensearch/rest/ProtobufDeprecationRestHandler.java b/server/src/main/java/org/opensearch/rest/ProtobufDeprecationRestHandler.java
new file mode 100644
index 0000000000000..0b0c147d7f29d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/ProtobufDeprecationRestHandler.java
@@ -0,0 +1,105 @@
+/*
+ * 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.
+ */
+
+package org.opensearch.rest;
+
+import org.opensearch.client.node.ProtobufNodeClient;
+import org.opensearch.common.Strings;
+import org.opensearch.common.logging.DeprecationLogger;
+
+import java.util.Objects;
+
+/**
+ * {@code ProtobufDeprecationRestHandler} provides a proxy for any existing {@link ProtobufRestHandler} so that usage of the handler can be
+ * logged using the {@link DeprecationLogger}.
+ *
+ * @opensearch.api
+ */
+public class ProtobufDeprecationRestHandler implements ProtobufRestHandler {
+
+    private final ProtobufRestHandler handler;
+    private final String deprecationMessage;
+    private final DeprecationLogger deprecationLogger;
+
+    /**
+     * Create a {@link ProtobufDeprecationRestHandler} that encapsulates the {@code handler} using the {@code deprecationLogger} to log
+     * deprecation {@code warning}.
+     *
+     * @param handler The rest handler to deprecate (it's possible that the handler is reused with a different name!)
+     * @param deprecationMessage The message to warn users with when they use the {@code handler}
+     * @param deprecationLogger The deprecation logger
+     * @throws NullPointerException if any parameter except {@code deprecationMessage} is {@code null}
+     * @throws IllegalArgumentException if {@code deprecationMessage} is not a valid header
+     */
+    public ProtobufDeprecationRestHandler(ProtobufRestHandler handler, String deprecationMessage, DeprecationLogger deprecationLogger) {
+        this.handler = Objects.requireNonNull(handler);
+        this.deprecationMessage = requireValidHeader(deprecationMessage);
+        this.deprecationLogger = Objects.requireNonNull(deprecationLogger);
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * Usage is logged via the {@link DeprecationLogger} so that the actual response can be notified of deprecation as well.
+     */
+    @Override
+    public void handleRequest(RestRequest request, RestChannel channel, ProtobufNodeClient client) throws Exception {
+        deprecationLogger.deprecate("deprecated_route", deprecationMessage);
+
+        handler.handleRequest(request, channel, client);
+    }
+
+    @Override
+    public boolean supportsContentStream() {
+        return handler.supportsContentStream();
+    }
+
+    /**
+     * This does a very basic pass at validating that a header's value contains only expected characters according to RFC-5987, and those
+     * that it references.
+     * <p>
+     * https://tools.ietf.org/html/rfc5987
+     * <p>
+     * This is only expected to be used for assertions. The idea is that only readable US-ASCII characters are expected; the rest must be
+     * encoded with percent encoding, which makes checking for a valid character range very simple.
+     *
+     * @param value The header value to check
+     * @return {@code true} if the {@code value} is not obviously wrong.
+     */
+    public static boolean validHeaderValue(String value) {
+        if (Strings.hasText(value) == false) {
+            return false;
+        }
+
+        for (int i = 0; i < value.length(); i++) {
+            char c = value.charAt(i);
+
+            // 32 = ' ' (31 = unit separator); 126 = '~' (127 = DEL)
+            if (c < 32 || c > 126) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Throw an exception if the {@code value} is not a {@link #validHeaderValue(String) valid header}.
+     *
+     * @param value The header value to check
+     * @return Always {@code value}.
+     * @throws IllegalArgumentException if {@code value} is not a {@link #validHeaderValue(String) valid header}.
+     */
+    public static String requireValidHeader(String value) {
+        if (validHeaderValue(value) == false) {
+            throw new IllegalArgumentException("header value must contain only US ASCII text");
+        }
+
+        return value;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/rest/RestBaseHandler.java b/server/src/main/java/org/opensearch/rest/RestBaseHandler.java
index ba51a918e2427..cb9a39f394a5f 100644
--- a/server/src/main/java/org/opensearch/rest/RestBaseHandler.java
+++ b/server/src/main/java/org/opensearch/rest/RestBaseHandler.java
@@ -8,13 +8,11 @@
 
 package org.opensearch.rest;
 
-import org.opensearch.client.node.ProtobufNodeClient;
 import org.opensearch.core.xcontent.XContent;
 import org.opensearch.rest.RestRequest.Method;
 
 import java.util.Collections;
 import java.util.List;
-import java.util.Objects;
 import java.util.stream.Collectors;
 
 /**
@@ -59,10 +57,10 @@ default boolean allowsUnsafeBuffers() {
     }
 
     // /**
-    //  * The list of {@link Route}s that this RestHandler is responsible for handling.
-    //  */
+    // * The list of {@link Route}s that this RestHandler is responsible for handling.
+    // */
     // default List<Route> routes() {
-    //     return Collections.emptyList();
+    // return Collections.emptyList();
     // }
 
     /**
diff --git a/server/src/main/java/org/opensearch/rest/RestController.java b/server/src/main/java/org/opensearch/rest/RestController.java
index 9710ab5497c36..50cf7dcde5019 100644
--- a/server/src/main/java/org/opensearch/rest/RestController.java
+++ b/server/src/main/java/org/opensearch/rest/RestController.java
@@ -280,7 +280,7 @@ private void registerProtobufHandlerNoWrap(RestRequest.Method method, String pat
      * Registers a REST handler with the controller. The REST handler declares the {@code method}
      * and {@code path} combinations.
      */
-    public void registerHandler(final RestHandler restHandler) {    
+    public void registerHandler(final RestHandler restHandler) {
         restHandler.routes().forEach(route -> registerHandler(route.getMethod(), route.getPath(), restHandler));
         restHandler.deprecatedRoutes()
             .forEach(route -> registerAsDeprecatedHandler(route.getMethod(), route.getPath(), restHandler, route.getDeprecationMessage()));
@@ -300,27 +300,24 @@ public void registerHandler(final RestHandler restHandler) {
      * Registers a REST handler with the controller. The REST handler declares the {@code method}
      * and {@code path} combinations.
      */
-    public void registerProtobufHandler(final ProtobufRestHandler restHandler) {    
-        System.out.println("Registering route");
-        restHandler.routes().forEach(route -> System.out.println(route.getMethod() + " " + route.getPath()));
+    public void registerProtobufHandler(final ProtobufRestHandler restHandler) {
         restHandler.routes().forEach(route -> registerProtobufHandler(route.getMethod(), route.getPath(), restHandler));
         // restHandler.deprecatedRoutes()
-        //     .forEach(route -> registerAsDeprecatedHandler(route.getMethod(), route.getPath(), restHandler, route.getDeprecationMessage()));
+        // .forEach(route -> registerAsDeprecatedHandler(route.getMethod(), route.getPath(), restHandler, route.getDeprecationMessage()));
         // restHandler.replacedRoutes()
-        //     .forEach(
-        //         route -> registerWithDeprecatedHandler(
-        //             route.getMethod(),
-        //             route.getPath(),
-        //             restHandler,
-        //             route.getDeprecatedMethod(),
-        //             route.getDeprecatedPath()
-        //         )
-        //     );
+        // .forEach(
+        // route -> registerWithDeprecatedHandler(
+        // route.getMethod(),
+        // route.getPath(),
+        // restHandler,
+        // route.getDeprecatedMethod(),
+        // route.getDeprecatedPath()
+        // )
+        // );
     }
 
     @Override
     public void dispatchRequest(RestRequest request, RestChannel channel, ThreadContext threadContext) {
-        System.out.println("Dispatching request");
         try {
             tryAllHandlers(request, channel, threadContext);
         } catch (Exception e) {
@@ -400,7 +397,6 @@ private void dispatchRequest(RestRequest request, RestChannel channel, RestHandl
     }
 
     private void dispatchProtobufRequest(RestRequest request, RestChannel channel, ProtobufRestHandler handler) throws Exception {
-        System.out.println("Dispatching protobuf request");
         final int contentLength = request.content().length();
         if (contentLength > 0) {
             final MediaType mediaType = request.getMediaType();
@@ -522,8 +518,6 @@ private void sendContentTypeErrorMessage(@Nullable List<String> contentTypeHeade
     }
 
     private void tryAllHandlers(final RestRequest request, final RestChannel channel, final ThreadContext threadContext) throws Exception {
-        System.out.println("Trying all handlers");
-        System.out.println("Request: " + request.toString());
         for (final RestHeaderDefinition restHeader : headersToCopy) {
             final String name = restHeader.getName();
             final List<String> headerValues = request.getAllHeaderValues(name);
@@ -555,9 +549,6 @@ private void tryAllHandlers(final RestRequest request, final RestChannel channel
         final String rawPath = request.rawPath();
         final String uri = request.uri();
         final RestRequest.Method requestMethod;
-        System.out.println("raw path: " + rawPath);
-        System.out.println("uri: " + uri);
-        System.out.println("request method: " + request.method().toString());
         try {
             // Resolves the HTTP method and fails if the method is invalid
             requestMethod = request.method();
@@ -566,22 +557,17 @@ private void tryAllHandlers(final RestRequest request, final RestChannel channel
             while (allHandlers.hasNext()) {
                 final RestHandler handler;
                 final ProtobufRestHandler protobufHandler;
-                System.out.println("All handlers has next");
                 final MethodHandlers handlers = allHandlers.next();
-                System.out.println("Handlers: " + handlers);
                 if (handlers == null) {
-                    System.out.println("Handlers is null");
                     handler = null;
                     protobufHandler = null;
                 } else {
                     if (rawPath.contains("protobuf")) {
                         handler = null;
                         protobufHandler = handlers.getProtobufHandler(requestMethod);
-                        System.out.println("Protobuf handler: " + protobufHandler);
                     } else {
                         protobufHandler = null;
                         handler = handlers.getHandler(requestMethod);
-                        System.out.println("Handler: " + handler);
                     }
                 }
                 if (handler == null && protobufHandler == null) {
@@ -611,9 +597,6 @@ private void tryAllHandlers(final RestRequest request, final RestChannel channel
     }
 
     Iterator<MethodHandlers> getAllHandlers(@Nullable Map<String, String> requestParamsRef, String rawPath) {
-        System.out.println("Getting all handlers");
-        System.out.println("Request params: " + requestParamsRef);
-        System.out.println("Raw path: " + rawPath);
         final Supplier<Map<String, String>> paramsSupplier;
         if (requestParamsRef == null) {
             paramsSupplier = () -> null;
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
index 93db24d9ee7d6..ce45b1942d35a 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
@@ -17,7 +17,7 @@
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
 import org.opensearch.client.node.ProtobufNodeClient;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
 import org.opensearch.common.Strings;
@@ -25,6 +25,7 @@
 import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.network.NetworkAddress;
 import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.unit.ByteSizeValue;
 import org.opensearch.http.ProtobufHttpInfo;
 import org.opensearch.index.cache.query.ProtobufQueryCacheStats;
@@ -39,7 +40,7 @@
 import org.opensearch.index.shard.ProtobufIndexingStats;
 import org.opensearch.indices.ProtobufNodeIndicesStats;
 import org.opensearch.monitor.fs.ProtobufFsInfo;
-import org.opensearch.monitor.jvm.ProtobufJvmInfo;
+import org.opensearch.monitor.jvm.JvmInfo;
 import org.opensearch.monitor.jvm.ProtobufJvmStats;
 import org.opensearch.monitor.os.ProtobufOsStats;
 import org.opensearch.monitor.process.ProtobufProcessInfo;
@@ -334,16 +335,15 @@ Table buildTable(
         ProtobufNodesInfoResponse nodesInfo,
         ProtobufNodesStatsResponse nodesStats
     ) {
-
         ProtobufDiscoveryNodes nodes = state.getState().nodes();
         String clusterManagerId = nodes.getClusterManagerNodeId();
         Table table = getTableWithHeader(req);
 
-        for (ProtobufDiscoveryNode node : nodes) {
+        for (DiscoveryNode node : nodes) {
             ProtobufNodeInfo info = nodesInfo.getNodesMap().get(node.getId());
             ProtobufNodeStats stats = nodesStats.getNodesMap().get(node.getId());
 
-            ProtobufJvmInfo jvmInfo = info == null ? null : info.getInfo(ProtobufJvmInfo.class);
+            JvmInfo jvmInfo = info == null ? null : info.getInfo(JvmInfo.class);
             ProtobufJvmStats jvmStats = stats == null ? null : stats.getJvm();
             ProtobufFsInfo fsInfo = stats == null ? null : stats.getFs();
             ProtobufOsStats osStats = stats == null ? null : stats.getOs();
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
index b54c8955283a2..88ae0dd74c087 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
@@ -354,7 +354,6 @@ Table buildTable(
         NodesInfoResponse nodesInfo,
         NodesStatsResponse nodesStats
     ) {
-
         DiscoveryNodes nodes = state.getState().nodes();
         String clusterManagerId = nodes.getClusterManagerNodeId();
         Table table = getTableWithHeader(req);
diff --git a/server/src/main/java/org/opensearch/script/ScriptCache.java b/server/src/main/java/org/opensearch/script/ScriptCache.java
index 439953f816cbb..0c536bd7ec133 100644
--- a/server/src/main/java/org/opensearch/script/ScriptCache.java
+++ b/server/src/main/java/org/opensearch/script/ScriptCache.java
@@ -155,6 +155,14 @@ public ScriptContextStats stats(String context) {
         return scriptMetrics.stats(context);
     }
 
+    public ProtobufScriptStats protobufStats() {
+        return scriptMetrics.protobufStats();
+    }
+
+    public ProtobufScriptContextStats protobufStats(String context) {
+        return scriptMetrics.protobufStats(context);
+    }
+
     /**
      * Check whether there have been too many compilations within the last minute, throwing a circuit breaking exception if so.
      * This is a variant of the token bucket algorithm: https://en.wikipedia.org/wiki/Token_bucket
diff --git a/server/src/main/java/org/opensearch/script/ScriptMetrics.java b/server/src/main/java/org/opensearch/script/ScriptMetrics.java
index fd54c757fd017..aa348ff5948c9 100644
--- a/server/src/main/java/org/opensearch/script/ScriptMetrics.java
+++ b/server/src/main/java/org/opensearch/script/ScriptMetrics.java
@@ -63,4 +63,17 @@ public ScriptStats stats() {
     public ScriptContextStats stats(String context) {
         return new ScriptContextStats(context, compilationsMetric.count(), cacheEvictionsMetric.count(), compilationLimitTriggered.count());
     }
+
+    public ProtobufScriptStats protobufStats() {
+        return new ProtobufScriptStats(compilationsMetric.count(), cacheEvictionsMetric.count(), compilationLimitTriggered.count());
+    }
+
+    public ProtobufScriptContextStats protobufStats(String context) {
+        return new ProtobufScriptContextStats(
+            context,
+            compilationsMetric.count(),
+            cacheEvictionsMetric.count(),
+            compilationLimitTriggered.count()
+        );
+    }
 }
diff --git a/server/src/main/java/org/opensearch/script/ScriptService.java b/server/src/main/java/org/opensearch/script/ScriptService.java
index 11e72ee6a8b66..d34153d126646 100644
--- a/server/src/main/java/org/opensearch/script/ScriptService.java
+++ b/server/src/main/java/org/opensearch/script/ScriptService.java
@@ -689,6 +689,10 @@ public ScriptStats stats() {
         return cacheHolder.get().stats();
     }
 
+    public ProtobufScriptStats protobufStats() {
+        return cacheHolder.get().protobufStats();
+    }
+
     public ScriptCacheStats cacheStats() {
         return cacheHolder.get().cacheStats();
     }
@@ -813,6 +817,18 @@ ScriptStats stats() {
             return new ScriptStats(contextStats);
         }
 
+        ProtobufScriptStats protobufStats() {
+            if (general != null) {
+                return general.protobufStats();
+            }
+            List<ProtobufScriptContextStats> contextStats = new ArrayList<>(contextCache.size());
+            for (Map.Entry<String, AtomicReference<ScriptCache>> entry : contextCache.entrySet()) {
+                ScriptCache cache = entry.getValue().get();
+                contextStats.add(cache.protobufStats(entry.getKey()));
+            }
+            return new ProtobufScriptStats(contextStats);
+        }
+
         ScriptCacheStats cacheStats() {
             if (general != null) {
                 return new ScriptCacheStats(general.stats());
diff --git a/server/src/main/java/org/opensearch/search/aggregations/support/AggregationUsageService.java b/server/src/main/java/org/opensearch/search/aggregations/support/AggregationUsageService.java
index eba64998014e2..cdcbe8d2fba61 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/support/AggregationUsageService.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/support/AggregationUsageService.java
@@ -32,6 +32,7 @@
 
 package org.opensearch.search.aggregations.support;
 
+import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.node.ReportingService;
 
 import java.util.HashMap;
@@ -43,9 +44,10 @@
  *
  * @opensearch.internal
  */
-public class AggregationUsageService implements ReportingService<AggregationInfo> {
+public class AggregationUsageService implements ReportingService<AggregationInfo>, ProtobufReportingService<ProtobufAggregationInfo> {
     private final Map<String, Map<String, LongAdder>> aggs;
     private final AggregationInfo info;
+    private final ProtobufAggregationInfo protobufInfo;
 
     public static final String OTHER_SUBTYPE = "other";
 
@@ -82,6 +84,7 @@ public AggregationUsageService build() {
     private AggregationUsageService(Builder builder) {
         this.aggs = builder.aggs;
         info = new AggregationInfo(aggs);
+        protobufInfo = new ProtobufAggregationInfo(aggs);
     }
 
     public void incAggregationUsage(String aggregationName, String valuesSourceType) {
@@ -118,4 +121,9 @@ public Map<String, Object> getUsageStats() {
     public AggregationInfo info() {
         return info;
     }
+
+    @Override
+    public ProtobufAggregationInfo protobufInfo() {
+        return protobufInfo;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/search/aggregations/support/ProtobufAggregationInfo.java b/server/src/main/java/org/opensearch/search/aggregations/support/ProtobufAggregationInfo.java
index cb90457671506..d9dcc049fcf5d 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/support/ProtobufAggregationInfo.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/support/ProtobufAggregationInfo.java
@@ -10,6 +10,8 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
+
+import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.node.ProtobufReportingService;
 
 import java.io.IOException;
@@ -68,4 +70,20 @@ public void writeTo(CodedOutputStream out) throws IOException {
     public Map<String, Set<String>> getAggregations() {
         return aggs;
     }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject("aggregations");
+        for (Map.Entry<String, Set<String>> e : aggs.entrySet()) {
+            builder.startObject(e.getKey());
+            builder.startArray("types");
+            for (String s : e.getValue()) {
+                builder.value(s);
+            }
+            builder.endArray();
+            builder.endObject();
+        }
+        builder.endObject();
+        return builder;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/search/pipeline/ProtobufSearchPipelineInfo.java b/server/src/main/java/org/opensearch/search/pipeline/ProtobufSearchPipelineInfo.java
index 245eaa31b7bcc..d95845f1eea77 100644
--- a/server/src/main/java/org/opensearch/search/pipeline/ProtobufSearchPipelineInfo.java
+++ b/server/src/main/java/org/opensearch/search/pipeline/ProtobufSearchPipelineInfo.java
@@ -10,6 +10,8 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
+
+import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.ingest.ProtobufProcessorInfo;
 import org.opensearch.node.ProtobufReportingService;
 
@@ -53,4 +55,16 @@ public void writeTo(CodedOutputStream out) throws IOException {
     public boolean containsProcessor(String type) {
         return processors.contains(new ProtobufProcessorInfo(type));
     }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject("search_pipelines");
+        builder.startArray("processors");
+        for (ProtobufProcessorInfo info : processors) {
+            info.toXContent(builder, params);
+        }
+        builder.endArray();
+        builder.endObject();
+        return builder;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/search/pipeline/SearchPipelineService.java b/server/src/main/java/org/opensearch/search/pipeline/SearchPipelineService.java
index 1066d836e5183..6984f774f3650 100644
--- a/server/src/main/java/org/opensearch/search/pipeline/SearchPipelineService.java
+++ b/server/src/main/java/org/opensearch/search/pipeline/SearchPipelineService.java
@@ -41,6 +41,8 @@
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.analysis.AnalysisRegistry;
 import org.opensearch.ingest.ConfigurationUtils;
+import org.opensearch.ingest.ProtobufProcessorInfo;
+import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.node.ReportingService;
 import org.opensearch.plugins.SearchPipelinePlugin;
 import org.opensearch.script.ScriptService;
@@ -63,7 +65,11 @@
  * The main entry point for search pipelines. Handles CRUD operations and exposes the API to execute search pipelines
  * against requests and responses.
  */
-public class SearchPipelineService implements ClusterStateApplier, ReportingService<SearchPipelineInfo> {
+public class SearchPipelineService
+    implements
+        ClusterStateApplier,
+        ReportingService<SearchPipelineInfo>,
+        ProtobufReportingService<ProtobufSearchPipelineInfo> {
 
     public static final String SEARCH_PIPELINE_ORIGIN = "search_pipeline";
     public static final String AD_HOC_PIPELINE_ID = "_ad_hoc_pipeline";
@@ -445,6 +451,15 @@ public SearchPipelineStats stats() {
         return builder.build();
     }
 
+    @Override
+    public ProtobufSearchPipelineInfo protobufInfo() {
+        List<ProtobufProcessorInfo> processorInfoList = new ArrayList<>();
+        for (Map.Entry<String, Processor.Factory> entry : processorFactories.entrySet()) {
+            processorInfoList.add(new ProtobufProcessorInfo(entry.getKey()));
+        }
+        return new ProtobufSearchPipelineInfo(processorInfoList);
+    }
+
     public static List<PipelineConfiguration> getPipelines(ClusterState clusterState, String... ids) {
         SearchPipelineMetadata metadata = clusterState.getMetadata().custom(SearchPipelineMetadata.TYPE);
         return innerGetPipelines(metadata, ids);
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTask.java b/server/src/main/java/org/opensearch/tasks/ProtobufTask.java
index 21165cb7736ca..779089a610d68 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTask.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTask.java
@@ -16,7 +16,7 @@
 import org.opensearch.ExceptionsHelper;
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.action.NotifyOnceListener;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.io.stream.NamedWriteable;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.ToXContentObject;
@@ -385,11 +385,11 @@ public String getHeader(String header) {
         return headers.get(header);
     }
 
-    public ProtobufTaskResult result(ProtobufDiscoveryNode node, Exception error) throws IOException {
+    public ProtobufTaskResult result(DiscoveryNode node, Exception error) throws IOException {
         return new ProtobufTaskResult(taskInfo(node.getId(), true, true), error);
     }
 
-    public ProtobufTaskResult result(ProtobufDiscoveryNode node, ProtobufActionResponse response) throws IOException {
+    public ProtobufTaskResult result(DiscoveryNode node, ProtobufActionResponse response) throws IOException {
         if (response instanceof ToXContent) {
             return new ProtobufTaskResult(taskInfo(node.getId(), true, true), (ToXContent) response);
         } else {
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
index 5a716bf2a4032..388a5b3d497b0 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
@@ -18,7 +18,7 @@
 import org.opensearch.action.StepListener;
 import org.opensearch.action.support.ProtobufChannelActionListener;
 import org.opensearch.action.support.GroupedActionListener;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ProtobufEmptyTransportResponseHandler;
 import org.opensearch.transport.ProtobufTransportChannel;
@@ -64,7 +64,7 @@ void cancelTaskAndDescendants(ProtobufCancellableTask task, String reason, boole
             logger.trace("cancelling task [{}] and its descendants", taskId);
             StepListener<Void> completedListener = new StepListener<>();
             GroupedActionListener<Void> groupedListener = new GroupedActionListener<>(ActionListener.map(completedListener, r -> null), 3);
-            Collection<ProtobufDiscoveryNode> childrenNodes = taskManager.startBanOnChildrenNodesProtobuf(task.getId(), () -> {
+            Collection<DiscoveryNode> childrenNodes = taskManager.startBanOnChildrenNodesProtobuf(task.getId(), () -> {
                 logger.trace("child tasks of parent [{}] are completed", taskId);
                 groupedListener.onResponse(null);
             });
@@ -104,7 +104,7 @@ private void setBanOnNodes(
         String reason,
         boolean waitForCompletion,
         ProtobufCancellableTask task,
-        Collection<ProtobufDiscoveryNode> childNodes,
+        Collection<DiscoveryNode> childNodes,
         ActionListener<Void> listener
     ) {
         if (childNodes.isEmpty()) {
@@ -118,7 +118,7 @@ private void setBanOnNodes(
             childNodes.size()
         );
         final BanParentTaskRequest banRequest = BanParentTaskRequest.createSetBanParentTaskRequest(taskId, reason, waitForCompletion);
-        for (ProtobufDiscoveryNode node : childNodes) {
+        for (DiscoveryNode node : childNodes) {
             transportService.sendRequest(
                 node,
                 BAN_PARENT_ACTION_NAME,
@@ -141,11 +141,11 @@ public void handleException(ProtobufTransportException exp) {
         }
     }
 
-    private void removeBanOnNodes(ProtobufCancellableTask task, Collection<ProtobufDiscoveryNode> childNodes) {
+    private void removeBanOnNodes(ProtobufCancellableTask task, Collection<DiscoveryNode> childNodes) {
         final BanParentTaskRequest request = BanParentTaskRequest.createRemoveBanParentTaskRequest(
             new ProtobufTaskId(localNodeId(), task.getId())
         );
-        for (ProtobufDiscoveryNode node : childNodes) {
+        for (DiscoveryNode node : childNodes) {
             logger.trace("Sending remove ban for tasks with the parent [{}] to the node [{}]", request.parentTaskId, node);
             transportService.sendRequest(
                 node,
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskManager.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskManager.java
deleted file mode 100644
index b53958eb290d3..0000000000000
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskManager.java
+++ /dev/null
@@ -1,763 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.tasks;
-
-import com.carrotsearch.hppc.ObjectIntHashMap;
-import com.carrotsearch.hppc.ObjectIntMap;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.message.ParameterizedMessage;
-import org.opensearch.core.Assertions;
-import org.opensearch.ExceptionsHelper;
-import org.opensearch.OpenSearchException;
-import org.opensearch.OpenSearchTimeoutException;
-import org.opensearch.action.ActionListener;
-import org.opensearch.action.ProtobufActionResponse;
-import org.opensearch.action.NotifyOnceListener;
-import org.opensearch.cluster.ProtobufClusterChangedEvent;
-import org.opensearch.cluster.ProtobufClusterStateApplier;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
-import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
-import org.opensearch.common.SetOnce;
-import org.opensearch.common.lease.Releasable;
-import org.opensearch.common.lease.Releasables;
-import org.opensearch.common.settings.ClusterSettings;
-import org.opensearch.common.settings.Setting;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.common.util.concurrent.AbstractRunnable;
-import org.opensearch.common.util.concurrent.ConcurrentCollections;
-import org.opensearch.common.util.concurrent.ConcurrentMapLong;
-import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.TcpChannel;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.Semaphore;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.function.Consumer;
-import java.util.stream.Collectors;
-import java.util.stream.StreamSupport;
-
-import static org.opensearch.common.unit.TimeValue.timeValueMillis;
-import static org.opensearch.http.HttpTransportSettings.SETTING_HTTP_MAX_HEADER_SIZE;
-
-/**
- * ProtobufTask Manager service for keeping track of currently running tasks on the nodes
-*
-* @opensearch.internal
-*/
-public class ProtobufTaskManager implements ProtobufClusterStateApplier {
-
-    private static final Logger logger = LogManager.getLogger(ProtobufTaskManager.class);
-
-    private static final TimeValue WAIT_FOR_COMPLETION_POLL = timeValueMillis(100);
-
-    public static final String TASK_RESOURCE_CONSUMERS_ATTRIBUTES = "task_resource_consumers.enabled";
-
-    public static final Setting<Boolean> TASK_RESOURCE_CONSUMERS_ENABLED = Setting.boolSetting(
-        TASK_RESOURCE_CONSUMERS_ATTRIBUTES,
-        false,
-        Setting.Property.Dynamic,
-        Setting.Property.NodeScope
-    );
-
-    /**
-     * Rest headers that are copied to the task
-    */
-    private final List<String> taskHeaders;
-    private final ThreadPool threadPool;
-
-    private final ConcurrentMapLong<ProtobufTask> tasks = ConcurrentCollections.newConcurrentMapLongWithAggressiveConcurrency();
-
-    private final ConcurrentMapLong<CancellableTaskHolder> cancellableTasks = ConcurrentCollections
-        .newConcurrentMapLongWithAggressiveConcurrency();
-
-    private final AtomicLong taskIdGenerator = new AtomicLong();
-
-    private final Map<ProtobufTaskId, String> banedParents = new ConcurrentHashMap<>();
-
-    private TaskResultsService taskResultsService;
-    private final SetOnce<ProtobufTaskResourceTrackingService> taskResourceTrackingService = new SetOnce<>();
-
-    private volatile ProtobufDiscoveryNodes lastDiscoveryNodes = ProtobufDiscoveryNodes.EMPTY_NODES;
-
-    private final ByteSizeValue maxHeaderSize;
-    private final Map<TcpChannel, ChannelPendingTaskTracker> channelPendingTaskTrackers = ConcurrentCollections.newConcurrentMap();
-    private final SetOnce<ProtobufTaskCancellationService> cancellationService = new SetOnce<>();
-
-    private volatile boolean taskResourceConsumersEnabled;
-    private final Set<Consumer<ProtobufTask>> taskResourceConsumer;
-
-    public static ProtobufTaskManager createTaskManagerWithClusterSettings(
-        Settings settings,
-        ClusterSettings clusterSettings,
-        ThreadPool threadPool,
-        Set<String> taskHeaders
-    ) {
-        final ProtobufTaskManager taskManager = new ProtobufTaskManager(settings, threadPool, taskHeaders);
-        clusterSettings.addSettingsUpdateConsumer(TASK_RESOURCE_CONSUMERS_ENABLED, taskManager::setTaskResourceConsumersEnabled);
-        return taskManager;
-    }
-
-    public ProtobufTaskManager(Settings settings, ThreadPool threadPool, Set<String> taskHeaders) {
-        this.threadPool = threadPool;
-        this.taskHeaders = new ArrayList<>(taskHeaders);
-        this.maxHeaderSize = SETTING_HTTP_MAX_HEADER_SIZE.get(settings);
-        this.taskResourceConsumersEnabled = TASK_RESOURCE_CONSUMERS_ENABLED.get(settings);
-        taskResourceConsumer = new HashSet<>();
-    }
-
-    public void registerTaskResourceConsumer(Consumer<ProtobufTask> consumer) {
-        taskResourceConsumer.add(consumer);
-    }
-
-    public void setTaskResultsService(TaskResultsService taskResultsService) {
-        assert this.taskResultsService == null;
-        this.taskResultsService = taskResultsService;
-    }
-
-    public void setTaskCancellationService(ProtobufTaskCancellationService taskCancellationService) {
-        this.cancellationService.set(taskCancellationService);
-    }
-
-    public void setTaskResourceTrackingService(ProtobufTaskResourceTrackingService taskResourceTrackingService) {
-        this.taskResourceTrackingService.set(taskResourceTrackingService);
-    }
-
-    public void setTaskResourceConsumersEnabled(boolean taskResourceConsumersEnabled) {
-        this.taskResourceConsumersEnabled = taskResourceConsumersEnabled;
-    }
-
-    /**
-     * Registers a task without parent task
-    */
-    public ProtobufTask register(String type, String action, ProtobufTaskAwareRequest request) {
-        Map<String, String> headers = new HashMap<>();
-        long headerSize = 0;
-        long maxSize = maxHeaderSize.getBytes();
-        ThreadContext threadContext = threadPool.getThreadContext();
-        for (String key : taskHeaders) {
-            String httpHeader = threadContext.getHeader(key);
-            if (httpHeader != null) {
-                headerSize += key.length() * 2 + httpHeader.length() * 2;
-                if (headerSize > maxSize) {
-                    throw new IllegalArgumentException("Request exceeded the maximum size of task headers " + maxHeaderSize);
-                }
-                headers.put(key, httpHeader);
-            }
-        }
-        ProtobufTask task = request.createTask(taskIdGenerator.incrementAndGet(), type, action, request.getParentTask(), headers);
-        Objects.requireNonNull(task);
-        assert task.getParentTaskId().equals(request.getParentTask()) : "Request [ " + request + "] didn't preserve it parentTaskId";
-        if (logger.isTraceEnabled()) {
-            logger.trace("register {} [{}] [{}] [{}]", task.getId(), type, action, task.getDescription());
-        }
-
-        if (task.supportsResourceTracking()) {
-            boolean success = task.addResourceTrackingCompletionListener(new NotifyOnceListener<>() {
-                @Override
-                protected void innerOnResponse(ProtobufTask task) {
-                    // Stop tracking the task once the last thread has been marked inactive.
-                    if (taskResourceTrackingService.get() != null && task.supportsResourceTracking()) {
-                        taskResourceTrackingService.get().stopTracking(task);
-                    }
-                }
-
-                @Override
-                protected void innerOnFailure(Exception e) {
-                    ExceptionsHelper.reThrowIfNotNull(e);
-                }
-            });
-
-            if (success == false) {
-                logger.debug(
-                    "failed to register a completion listener as task resource tracking has already completed [taskId={}]",
-                    task.getId()
-                );
-            }
-        }
-
-        if (task instanceof ProtobufCancellableTask) {
-            registerCancellableTask(task);
-        } else {
-            ProtobufTask previousTask = tasks.put(task.getId(), task);
-            assert previousTask == null;
-        }
-        return task;
-    }
-
-    private void registerCancellableTask(ProtobufTask task) {
-        ProtobufCancellableTask cancellableTask = (ProtobufCancellableTask) task;
-        CancellableTaskHolder holder = new CancellableTaskHolder(cancellableTask);
-        CancellableTaskHolder oldHolder = cancellableTasks.put(task.getId(), holder);
-        assert oldHolder == null;
-        // Check if this task was banned before we start it. The empty check is used to avoid
-        // computing the hash code of the parent taskId as most of the time banedParents is empty.
-        if (task.getParentTaskId().isSet() && banedParents.isEmpty() == false) {
-            String reason = banedParents.get(task.getParentTaskId());
-            if (reason != null) {
-                try {
-                    holder.cancel(reason);
-                    throw new TaskCancelledException("ProtobufTask cancelled before it started: " + reason);
-                } finally {
-                    // let's clean up the registration
-                    unregister(task);
-                }
-            }
-        }
-    }
-
-    /**
-     * Cancels a task
-    * <p>
-    * After starting cancellation on the parent task, the task manager tries to cancel all children tasks
-    * of the current task. Once cancellation of the children tasks is done, the listener is triggered.
-    * If the task is completed or unregistered from ProtobufTaskManager, then the listener is called immediately.
-    */
-    public void cancel(ProtobufCancellableTask task, String reason, Runnable listener) {
-        CancellableTaskHolder holder = cancellableTasks.get(task.getId());
-        if (holder != null) {
-            logger.trace("cancelling task with id {}", task.getId());
-            holder.cancel(reason, listener);
-        } else {
-            listener.run();
-        }
-    }
-
-    /**
-     * Unregister the task
-    */
-    public ProtobufTask unregister(ProtobufTask task) {
-        logger.trace("unregister task for id: {}", task.getId());
-
-        // Decrement the task's self-thread as part of unregistration.
-        task.decrementResourceTrackingThreads();
-
-        if (taskResourceConsumersEnabled) {
-            for (Consumer<ProtobufTask> taskConsumer : taskResourceConsumer) {
-                try {
-                    taskConsumer.accept(task);
-                } catch (Exception e) {
-                    logger.error("error encountered when updating the consumer", e);
-                }
-            }
-        }
-
-        if (task instanceof ProtobufCancellableTask) {
-            CancellableTaskHolder holder = cancellableTasks.remove(task.getId());
-            if (holder != null) {
-                holder.finish();
-                return holder.getTask();
-            } else {
-                return null;
-            }
-        } else {
-            return tasks.remove(task.getId());
-        }
-    }
-
-    /**
-     * Register a node on which a child task will execute. The returned {@link Releasable} must be called
-    * to unregister the child node once the child task is completed or failed.
-    */
-    public Releasable registerChildNode(long taskId, ProtobufDiscoveryNode node) {
-        final CancellableTaskHolder holder = cancellableTasks.get(taskId);
-        if (holder != null) {
-            logger.trace("register child node [{}] task [{}]", node, taskId);
-            holder.registerChildNode(node);
-            return Releasables.releaseOnce(() -> {
-                logger.trace("unregister child node [{}] task [{}]", node, taskId);
-                holder.unregisterChildNode(node);
-            });
-        }
-        return () -> {};
-    }
-
-    public ProtobufDiscoveryNode localNode() {
-        return lastDiscoveryNodes.getLocalNode();
-    }
-
-    /**
-     * Stores the task failure
-    */
-    public <Response extends ProtobufActionResponse> void storeResult(
-        ProtobufTask task,
-        Exception error,
-        ActionListener<Response> listener
-    ) {
-        ProtobufDiscoveryNode localNode = lastDiscoveryNodes.getLocalNode();
-        if (localNode == null) {
-            // too early to store anything, shouldn't really be here - just pass the error along
-            listener.onFailure(error);
-            return;
-        }
-        final ProtobufTaskResult taskResult;
-        try {
-            taskResult = task.result(localNode, error);
-        } catch (IOException ex) {
-            logger.warn(() -> new ParameterizedMessage("couldn't store error {}", ExceptionsHelper.detailedMessage(error)), ex);
-            listener.onFailure(ex);
-            return;
-        }
-        taskResultsService.storeResult(taskResult, new ActionListener<Void>() {
-            @Override
-            public void onResponse(Void aVoid) {
-                listener.onFailure(error);
-            }
-
-            @Override
-            public void onFailure(Exception e) {
-                logger.warn(() -> new ParameterizedMessage("couldn't store error {}", ExceptionsHelper.detailedMessage(error)), e);
-                listener.onFailure(e);
-            }
-        });
-    }
-
-    /**
-     * Stores the task result
-    */
-    public <Response extends ProtobufActionResponse> void storeResult(
-        ProtobufTask task,
-        Response response,
-        ActionListener<Response> listener
-    ) {
-        ProtobufDiscoveryNode localNode = lastDiscoveryNodes.getLocalNode();
-        if (localNode == null) {
-            // too early to store anything, shouldn't really be here - just pass the response along
-            logger.warn("couldn't store response {}, the node didn't join the cluster yet", response);
-            listener.onResponse(response);
-            return;
-        }
-        final ProtobufTaskResult taskResult;
-        try {
-            taskResult = task.result(localNode, response);
-        } catch (IOException ex) {
-            logger.warn(() -> new ParameterizedMessage("couldn't store response {}", response), ex);
-            listener.onFailure(ex);
-            return;
-        }
-
-        taskResultsService.storeResult(taskResult, new ActionListener<Void>() {
-            @Override
-            public void onResponse(Void aVoid) {
-                listener.onResponse(response);
-            }
-
-            @Override
-            public void onFailure(Exception e) {
-                logger.warn(() -> new ParameterizedMessage("couldn't store response {}", response), e);
-                listener.onFailure(e);
-            }
-        });
-    }
-
-    /**
-     * Returns the list of currently running tasks on the node
-    */
-    public Map<Long, ProtobufTask> getTasks() {
-        HashMap<Long, ProtobufTask> taskHashMap = new HashMap<>(this.tasks);
-        for (CancellableTaskHolder holder : cancellableTasks.values()) {
-            taskHashMap.put(holder.getTask().getId(), holder.getTask());
-        }
-        return Collections.unmodifiableMap(taskHashMap);
-    }
-
-    /**
-     * Returns the list of currently running tasks on the node that can be cancelled
-    */
-    public Map<Long, ProtobufCancellableTask> getCancellableTasks() {
-        HashMap<Long, ProtobufCancellableTask> taskHashMap = new HashMap<>();
-        for (CancellableTaskHolder holder : cancellableTasks.values()) {
-            taskHashMap.put(holder.getTask().getId(), holder.getTask());
-        }
-        return Collections.unmodifiableMap(taskHashMap);
-    }
-
-    /**
-     * Returns a task with given id, or null if the task is not found.
-    */
-    public ProtobufTask getTask(long id) {
-        ProtobufTask task = tasks.get(id);
-        if (task != null) {
-            return task;
-        } else {
-            return getCancellableTask(id);
-        }
-    }
-
-    /**
-     * Returns a cancellable task with given id, or null if the task is not found.
-    */
-    public ProtobufCancellableTask getCancellableTask(long id) {
-        CancellableTaskHolder holder = cancellableTasks.get(id);
-        if (holder != null) {
-            return holder.getTask();
-        } else {
-            return null;
-        }
-    }
-
-    /**
-     * Returns the number of currently banned tasks.
-    * <p>
-    * Will be used in task manager stats and for debugging.
-    */
-    public int getBanCount() {
-        return banedParents.size();
-    }
-
-    /**
-     * Bans all tasks with the specified parent task from execution, cancels all tasks that are currently executing.
-    * <p>
-    * This method is called when a parent task that has children is cancelled.
-    *
-    * @return a list of pending cancellable child tasks
-    */
-    public List<ProtobufCancellableTask> setBan(ProtobufTaskId parentTaskId, String reason) {
-        logger.trace("setting ban for the parent task {} {}", parentTaskId, reason);
-
-        // Set the ban first, so the newly created tasks cannot be registered
-        synchronized (banedParents) {
-            if (lastDiscoveryNodes.nodeExists(parentTaskId.getNodeId())) {
-                // Only set the ban if the node is the part of the cluster
-                banedParents.put(parentTaskId, reason);
-            }
-        }
-        return cancellableTasks.values().stream().filter(t -> t.hasParent(parentTaskId)).map(t -> t.task).collect(Collectors.toList());
-    }
-
-    /**
-     * Removes the ban for the specified parent task.
-    * <p>
-    * This method is called when a previously banned task finally cancelled
-    */
-    public void removeBan(ProtobufTaskId parentTaskId) {
-        logger.trace("removing ban for the parent task {}", parentTaskId);
-        banedParents.remove(parentTaskId);
-    }
-
-    // for testing
-    public Set<ProtobufTaskId> getBannedTaskIds() {
-        return Collections.unmodifiableSet(banedParents.keySet());
-    }
-
-    /**
-     * Start rejecting new child requests as the parent task was cancelled.
-    *
-    * @param taskId                the parent task id
-    * @param onChildTasksCompleted called when all child tasks are completed or failed
-    * @return the set of current nodes that have outstanding child tasks
-    */
-    public Collection<ProtobufDiscoveryNode> startBanOnChildrenNodes(long taskId, Runnable onChildTasksCompleted) {
-        final CancellableTaskHolder holder = cancellableTasks.get(taskId);
-        if (holder != null) {
-            return holder.startBan(onChildTasksCompleted);
-        } else {
-            onChildTasksCompleted.run();
-            return Collections.emptySet();
-        }
-    }
-
-    @Override
-    public void applyProtobufClusterState(ProtobufClusterChangedEvent event) {
-        lastDiscoveryNodes = event.state().getNodes();
-        if (event.nodesRemoved()) {
-            synchronized (banedParents) {
-                lastDiscoveryNodes = event.state().getNodes();
-                // Remove all bans that were registered by nodes that are no longer in the cluster state
-                Iterator<ProtobufTaskId> banIterator = banedParents.keySet().iterator();
-                while (banIterator.hasNext()) {
-                    ProtobufTaskId taskId = banIterator.next();
-                    if (lastDiscoveryNodes.nodeExists(taskId.getNodeId()) == false) {
-                        logger.debug(
-                            "Removing ban for the parent [{}] on the node [{}], reason: the parent node is gone",
-                            taskId,
-                            event.state().getNodes().getLocalNode()
-                        );
-                        banIterator.remove();
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * Blocks the calling thread, waiting for the task to vanish from the ProtobufTaskManager.
-    */
-    public void waitForTaskCompletion(ProtobufTask task, long untilInNanos) {
-        while (System.nanoTime() - untilInNanos < 0) {
-            if (getTask(task.getId()) == null) {
-                return;
-            }
-            try {
-                Thread.sleep(WAIT_FOR_COMPLETION_POLL.millis());
-            } catch (InterruptedException e) {
-                throw new OpenSearchException("Interrupted waiting for completion of [{}]", e, task);
-            }
-        }
-        throw new OpenSearchTimeoutException("Timed out waiting for completion of [{}]", task);
-    }
-
-    /**
-     * Takes actions when a task is registered and its execution starts
-    *
-    * @param task getting executed.
-    * @return AutoCloseable to free up resources (clean up thread context) when task execution block returns
-    */
-    public ThreadContext.StoredContext taskExecutionStarted(ProtobufTask task) {
-        if (taskResourceTrackingService.get() == null) return () -> {};
-
-        return taskResourceTrackingService.get().startTracking(task);
-    }
-
-    private static class CancellableTaskHolder {
-        private final ProtobufCancellableTask task;
-        private boolean finished = false;
-        private List<Runnable> cancellationListeners = null;
-        private ObjectIntMap<ProtobufDiscoveryNode> childTasksPerNode = null;
-        private boolean banChildren = false;
-        private List<Runnable> childTaskCompletedListeners = null;
-
-        CancellableTaskHolder(ProtobufCancellableTask task) {
-            this.task = task;
-        }
-
-        void cancel(String reason, Runnable listener) {
-            final Runnable toRun;
-            synchronized (this) {
-                if (finished) {
-                    assert cancellationListeners == null;
-                    toRun = listener;
-                } else {
-                    toRun = () -> {};
-                    if (listener != null) {
-                        if (cancellationListeners == null) {
-                            cancellationListeners = new ArrayList<>();
-                        }
-                        cancellationListeners.add(listener);
-                    }
-                }
-            }
-            try {
-                task.cancel(reason);
-            } finally {
-                if (toRun != null) {
-                    toRun.run();
-                }
-            }
-        }
-
-        void cancel(String reason) {
-            task.cancel(reason);
-        }
-
-        /**
-         * Marks task as finished.
-        */
-        public void finish() {
-            final List<Runnable> listeners;
-            synchronized (this) {
-                this.finished = true;
-                if (cancellationListeners != null) {
-                    listeners = cancellationListeners;
-                    cancellationListeners = null;
-                } else {
-                    listeners = Collections.emptyList();
-                }
-            }
-            // We need to call the listener outside of the synchronised section to avoid potential bottle necks
-            // in the listener synchronization
-            notifyListeners(listeners);
-        }
-
-        private void notifyListeners(List<Runnable> listeners) {
-            assert Thread.holdsLock(this) == false;
-            Exception rootException = null;
-            for (Runnable listener : listeners) {
-                try {
-                    listener.run();
-                } catch (RuntimeException inner) {
-                    rootException = ExceptionsHelper.useOrSuppress(rootException, inner);
-                }
-            }
-            ExceptionsHelper.reThrowIfNotNull(rootException);
-        }
-
-        public boolean hasParent(ProtobufTaskId parentTaskId) {
-            return task.getParentTaskId().equals(parentTaskId);
-        }
-
-        public ProtobufCancellableTask getTask() {
-            return task;
-        }
-
-        synchronized void registerChildNode(ProtobufDiscoveryNode node) {
-            if (banChildren) {
-                throw new TaskCancelledException("The parent task was cancelled, shouldn't start any child tasks");
-            }
-            if (childTasksPerNode == null) {
-                childTasksPerNode = new ObjectIntHashMap<>();
-            }
-            childTasksPerNode.addTo(node, 1);
-        }
-
-        void unregisterChildNode(ProtobufDiscoveryNode node) {
-            final List<Runnable> listeners;
-            synchronized (this) {
-                if (childTasksPerNode.addTo(node, -1) == 0) {
-                    childTasksPerNode.remove(node);
-                }
-                if (childTasksPerNode.isEmpty() && this.childTaskCompletedListeners != null) {
-                    listeners = childTaskCompletedListeners;
-                    childTaskCompletedListeners = null;
-                } else {
-                    listeners = Collections.emptyList();
-                }
-            }
-            notifyListeners(listeners);
-        }
-
-        Set<ProtobufDiscoveryNode> startBan(Runnable onChildTasksCompleted) {
-            final Set<ProtobufDiscoveryNode> pendingChildNodes;
-            final Runnable toRun;
-            synchronized (this) {
-                banChildren = true;
-                if (childTasksPerNode == null) {
-                    pendingChildNodes = Collections.emptySet();
-                } else {
-                    pendingChildNodes = StreamSupport.stream(childTasksPerNode.spliterator(), false)
-                        .map(e -> e.key)
-                        .collect(Collectors.toSet());
-                }
-                if (pendingChildNodes.isEmpty()) {
-                    assert childTaskCompletedListeners == null;
-                    toRun = onChildTasksCompleted;
-                } else {
-                    toRun = () -> {};
-                    if (childTaskCompletedListeners == null) {
-                        childTaskCompletedListeners = new ArrayList<>();
-                    }
-                    childTaskCompletedListeners.add(onChildTasksCompleted);
-                }
-            }
-            toRun.run();
-            return pendingChildNodes;
-        }
-    }
-
-    /**
-     * Start tracking a cancellable task with its tcp channel, so if the channel gets closed we can get a set of
-    * pending tasks associated that channel and cancel them as these results won't be retrieved by the parent task.
-    *
-    * @return a releasable that should be called when this pending task is completed
-    */
-    public Releasable startTrackingCancellableChannelTask(TcpChannel channel, ProtobufCancellableTask task) {
-        assert cancellableTasks.containsKey(task.getId()) : "task [" + task.getId() + "] is not registered yet";
-        final ChannelPendingTaskTracker tracker = channelPendingTaskTrackers.compute(channel, (k, curr) -> {
-            if (curr == null) {
-                curr = new ChannelPendingTaskTracker();
-            }
-            curr.addTask(task);
-            return curr;
-        });
-        if (tracker.registered.compareAndSet(false, true)) {
-            channel.addCloseListener(ActionListener.wrap(r -> {
-                final ChannelPendingTaskTracker removedTracker = channelPendingTaskTrackers.remove(channel);
-                assert removedTracker == tracker;
-                cancelTasksOnChannelClosed(tracker.drainTasks());
-            }, e -> { assert false : new AssertionError("must not be here", e); }));
-        }
-        return () -> tracker.removeTask(task);
-    }
-
-    // for testing
-    final int numberOfChannelPendingTaskTrackers() {
-        return channelPendingTaskTrackers.size();
-    }
-
-    private static class ChannelPendingTaskTracker {
-        final AtomicBoolean registered = new AtomicBoolean();
-        final Semaphore permits = Assertions.ENABLED ? new Semaphore(Integer.MAX_VALUE) : null;
-        final Set<ProtobufCancellableTask> pendingTasks = ConcurrentCollections.newConcurrentSet();
-
-        void addTask(ProtobufCancellableTask task) {
-            assert permits.tryAcquire() : "tracker was drained";
-            final boolean added = pendingTasks.add(task);
-            assert added : "task " + task.getId() + " is in the pending list already";
-            assert releasePermit();
-        }
-
-        boolean acquireAllPermits() {
-            permits.acquireUninterruptibly(Integer.MAX_VALUE);
-            return true;
-        }
-
-        boolean releasePermit() {
-            permits.release();
-            return true;
-        }
-
-        Set<ProtobufCancellableTask> drainTasks() {
-            assert acquireAllPermits(); // do not release permits so we can't add tasks to this tracker after draining
-            return Collections.unmodifiableSet(pendingTasks);
-        }
-
-        void removeTask(ProtobufCancellableTask task) {
-            final boolean removed = pendingTasks.remove(task);
-            assert removed : "task " + task.getId() + " is not in the pending list";
-        }
-    }
-
-    private void cancelTasksOnChannelClosed(Set<ProtobufCancellableTask> tasks) {
-        if (tasks.isEmpty() == false) {
-            threadPool.generic().execute(new AbstractRunnable() {
-                @Override
-                public void onFailure(Exception e) {
-                    logger.warn("failed to cancel tasks on channel closed", e);
-                }
-
-                @Override
-                protected void doRun() {
-                    for (ProtobufCancellableTask task : tasks) {
-                        cancelTaskAndDescendants(task, "channel was closed", false, ActionListener.wrap(() -> {}));
-                    }
-                }
-            });
-        }
-    }
-
-    public void cancelTaskAndDescendants(
-        ProtobufCancellableTask task,
-        String reason,
-        boolean waitForCompletion,
-        ActionListener<Void> listener
-    ) {
-        final ProtobufTaskCancellationService service = cancellationService.get();
-        if (service != null) {
-            service.cancelTaskAndDescendants(task, reason, waitForCompletion, listener);
-        } else {
-            assert false : "ProtobufTaskCancellationService is not initialized";
-            throw new IllegalStateException("ProtobufTaskCancellationService is not initialized");
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/tasks/TaskManager.java b/server/src/main/java/org/opensearch/tasks/TaskManager.java
index 484ca84501be9..c3bcb316d16e9 100644
--- a/server/src/main/java/org/opensearch/tasks/TaskManager.java
+++ b/server/src/main/java/org/opensearch/tasks/TaskManager.java
@@ -49,7 +49,7 @@
 import org.opensearch.cluster.ProtobufClusterStateApplier;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
 import org.opensearch.common.SetOnce;
 import org.opensearch.common.settings.ClusterSettings;
@@ -139,7 +139,8 @@ public class TaskManager implements ClusterStateApplier, ProtobufClusterStateApp
 
     private final ByteSizeValue maxHeaderSize;
     private final Map<TcpChannel, ChannelPendingTaskTracker> channelPendingTaskTrackers = ConcurrentCollections.newConcurrentMap();
-    private final Map<TcpChannel, ProtobufChannelPendingTaskTracker> protobufChannelPendingTaskTrackers = ConcurrentCollections.newConcurrentMap();
+    private final Map<TcpChannel, ProtobufChannelPendingTaskTracker> protobufChannelPendingTaskTrackers = ConcurrentCollections
+        .newConcurrentMap();
     private final SetOnce<TaskCancellationService> cancellationService = new SetOnce<>();
     private final SetOnce<ProtobufTaskCancellationService> protobufCancellationService = new SetOnce<>();
 
@@ -543,7 +544,7 @@ public DiscoveryNode localNode() {
      * Register a node on which a child task will execute. The returned {@link Releasable} must be called
     * to unregister the child node once the child task is completed or failed.
     */
-    public Releasable registerProtobufChildNode(long taskId, ProtobufDiscoveryNode node) {
+    public Releasable registerProtobufChildNode(long taskId, DiscoveryNode node) {
         final ProtobufCancellableTaskHolder holder = protobufCancellableTasks.get(taskId);
         if (holder != null) {
             logger.trace("register child node [{}] task [{}]", node, taskId);
@@ -556,7 +557,7 @@ public Releasable registerProtobufChildNode(long taskId, ProtobufDiscoveryNode n
         return () -> {};
     }
 
-    public ProtobufDiscoveryNode localProtobufNode() {
+    public DiscoveryNode localProtobufNode() {
         return lastDiscoveryNodesProtobuf.getLocalNode();
     }
 
@@ -600,7 +601,7 @@ public <Response extends ProtobufActionResponse> void storeResultProtobuf(
         Exception error,
         ActionListener<Response> listener
     ) {
-        ProtobufDiscoveryNode localNode = lastDiscoveryNodesProtobuf.getLocalNode();
+        DiscoveryNode localNode = lastDiscoveryNodesProtobuf.getLocalNode();
         if (localNode == null) {
             // too early to store anything, shouldn't really be here - just pass the error along
             listener.onFailure(error);
@@ -670,7 +671,7 @@ public <Response extends ProtobufActionResponse> void storeResultProtobuf(
         Response response,
         ActionListener<Response> listener
     ) {
-        ProtobufDiscoveryNode localNode = lastDiscoveryNodesProtobuf.getLocalNode();
+        DiscoveryNode localNode = lastDiscoveryNodesProtobuf.getLocalNode();
         if (localNode == null) {
             // too early to store anything, shouldn't really be here - just pass the response along
             logger.warn("couldn't store response {}, the node didn't join the cluster yet", response);
@@ -853,11 +854,11 @@ public Collection<DiscoveryNode> startBanOnChildrenNodes(long taskId, Runnable o
         }
     }
 
-        /**
-     * Returns the number of currently banned tasks.
-     * <p>
-     * Will be used in task manager stats and for debugging.
-     */
+    /**
+    * Returns the number of currently banned tasks.
+    * <p>
+    * Will be used in task manager stats and for debugging.
+    */
     public int getBanCountProtobuf() {
         return banedParentsProtobuf.size();
     }
@@ -879,7 +880,11 @@ public List<ProtobufCancellableTask> setBanProtobuf(ProtobufTaskId parentTaskId,
                 banedParentsProtobuf.put(parentTaskId, reason);
             }
         }
-        return protobufCancellableTasks.values().stream().filter(t -> t.hasParent(parentTaskId)).map(t -> t.task).collect(Collectors.toList());
+        return protobufCancellableTasks.values()
+            .stream()
+            .filter(t -> t.hasParent(parentTaskId))
+            .map(t -> t.task)
+            .collect(Collectors.toList());
     }
 
     /**
@@ -904,7 +909,7 @@ public Set<ProtobufTaskId> getBannedTaskIdsProtobuf() {
      * @param onChildTasksCompleted called when all child tasks are completed or failed
      * @return the set of current nodes that have outstanding child tasks
      */
-    public Collection<ProtobufDiscoveryNode> startBanOnChildrenNodesProtobuf(long taskId, Runnable onChildTasksCompleted) {
+    public Collection<DiscoveryNode> startBanOnChildrenNodesProtobuf(long taskId, Runnable onChildTasksCompleted) {
         final ProtobufCancellableTaskHolder holder = protobufCancellableTasks.get(taskId);
         if (holder != null) {
             return holder.startBan(onChildTasksCompleted);
@@ -1288,7 +1293,7 @@ private static class ProtobufCancellableTaskHolder {
         private final ProtobufCancellableTask task;
         private boolean finished = false;
         private List<Runnable> cancellationListeners = null;
-        private ObjectIntMap<ProtobufDiscoveryNode> childTasksPerNode = null;
+        private ObjectIntMap<DiscoveryNode> childTasksPerNode = null;
         private boolean banChildren = false;
         private List<Runnable> childTaskCompletedListeners = null;
 
@@ -1365,7 +1370,7 @@ public ProtobufCancellableTask getTask() {
             return task;
         }
 
-        synchronized void registerChildNode(ProtobufDiscoveryNode node) {
+        synchronized void registerChildNode(DiscoveryNode node) {
             if (banChildren) {
                 throw new TaskCancelledException("The parent task was cancelled, shouldn't start any child tasks");
             }
@@ -1375,7 +1380,7 @@ synchronized void registerChildNode(ProtobufDiscoveryNode node) {
             childTasksPerNode.addTo(node, 1);
         }
 
-        void unregisterChildNode(ProtobufDiscoveryNode node) {
+        void unregisterChildNode(DiscoveryNode node) {
             final List<Runnable> listeners;
             synchronized (this) {
                 if (childTasksPerNode.addTo(node, -1) == 0) {
@@ -1391,8 +1396,8 @@ void unregisterChildNode(ProtobufDiscoveryNode node) {
             notifyListeners(listeners);
         }
 
-        Set<ProtobufDiscoveryNode> startBan(Runnable onChildTasksCompleted) {
-            final Set<ProtobufDiscoveryNode> pendingChildNodes;
+        Set<DiscoveryNode> startBan(Runnable onChildTasksCompleted) {
+            final Set<DiscoveryNode> pendingChildNodes;
             final Runnable toRun;
             synchronized (this) {
                 banChildren = true;
@@ -1416,6 +1421,7 @@ Set<ProtobufDiscoveryNode> startBan(Runnable onChildTasksCompleted) {
             return pendingChildNodes;
         }
     }
+
     /**
      * Start tracking a cancellable task with its tcp channel, so if the channel gets closed we can get a set of
      * pending tasks associated that channel and cancel them as these results won't be retrieved by the parent task.
diff --git a/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java b/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java
index c9e3a51bb077c..0addbd9276b22 100644
--- a/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java
+++ b/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java
@@ -13,6 +13,7 @@
 
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.node.ProtobufReportingService;
 
 import java.io.IOException;
@@ -48,4 +49,18 @@ public void writeTo(CodedOutputStream out) throws IOException {
     public Iterator<ThreadPool.Info> iterator() {
         return infos.iterator();
     }
+
+    static final class Fields {
+        static final String THREAD_POOL = "thread_pool";
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.THREAD_POOL);
+        for (ThreadPool.Info info : infos) {
+            info.toXContent(builder, params);
+        }
+        builder.endObject();
+        return builder;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/threadpool/ThreadPool.java b/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
index fa94ec0156090..e55bfc4e5fb50 100644
--- a/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
+++ b/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
@@ -64,7 +64,6 @@
 
 import java.io.IOException;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
diff --git a/server/src/main/java/org/opensearch/transport/InboundHandler.java b/server/src/main/java/org/opensearch/transport/InboundHandler.java
index bb04f149d39a9..8632ad7102bd7 100644
--- a/server/src/main/java/org/opensearch/transport/InboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/InboundHandler.java
@@ -70,6 +70,7 @@ public class InboundHandler {
     private final Transport.RequestHandlers requestHandlers;
 
     private volatile TransportMessageListener messageListener = TransportMessageListener.NOOP_LISTENER;
+    private volatile ProtobufTransportMessageListener protobufMessageListener = ProtobufTransportMessageListener.NOOP_LISTENER;
 
     private volatile long slowLogThresholdMs = Long.MAX_VALUE;
 
@@ -99,6 +100,14 @@ void setMessageListener(TransportMessageListener listener) {
         }
     }
 
+    void setProtobufMessageListener(ProtobufTransportMessageListener listener) {
+        if (protobufMessageListener == ProtobufTransportMessageListener.NOOP_LISTENER) {
+            protobufMessageListener = listener;
+        } else {
+            throw new IllegalStateException("Cannot set message listener twice");
+        }
+    }
+
     void setSlowLogThreshold(TimeValue slowLogThreshold) {
         this.slowLogThresholdMs = slowLogThreshold.getMillis();
     }
diff --git a/server/src/main/java/org/opensearch/transport/OutboundHandler.java b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
index 3e493267242fb..a77dad228a626 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
@@ -71,6 +71,7 @@ final class OutboundHandler {
     private final ThreadPool threadPool;
     private final BigArrays bigArrays;
     private volatile TransportMessageListener messageListener = TransportMessageListener.NOOP_LISTENER;
+    private volatile ProtobufTransportMessageListener protobufMessageListener = ProtobufTransportMessageListener.NOOP_LISTENER;
 
     OutboundHandler(
         String nodeName,
@@ -212,6 +213,14 @@ void setMessageListener(TransportMessageListener listener) {
         }
     }
 
+    void setProtobufMessageListener(ProtobufTransportMessageListener listener) {
+        if (protobufMessageListener == ProtobufTransportMessageListener.NOOP_LISTENER) {
+            protobufMessageListener = listener;
+        } else {
+            throw new IllegalStateException("Cannot set message listener twice");
+        }
+    }
+
     /**
      * Internal message serializer
      *
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java b/server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java
index 377451f06892d..42d5046a9be4c 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java
@@ -11,7 +11,7 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.opensearch.action.ActionListener;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.concurrent.AbstractRefCounted;
 import org.opensearch.common.util.concurrent.ConcurrentCollections;
@@ -39,16 +39,14 @@ public class ProtobufClusterConnectionManager implements ProtobufConnectionManag
 
     private static final Logger logger = LogManager.getLogger(ProtobufClusterConnectionManager.class);
 
-    private final ConcurrentMap<ProtobufDiscoveryNode, Transport.ProtobufConnection> connectedNodes = ConcurrentCollections
-        .newConcurrentMap();
-    private final ConcurrentMap<ProtobufDiscoveryNode, ListenableFuture<Void>> pendingConnections = ConcurrentCollections
-        .newConcurrentMap();
+    private final ConcurrentMap<DiscoveryNode, Transport.ProtobufConnection> connectedNodes = ConcurrentCollections.newConcurrentMap();
+    private final ConcurrentMap<DiscoveryNode, ListenableFuture<Void>> pendingConnections = ConcurrentCollections.newConcurrentMap();
     private final AbstractRefCounted connectingRefCounter = new AbstractRefCounted("connection manager") {
         @Override
         protected void closeInternal() {
-            Iterator<Map.Entry<ProtobufDiscoveryNode, Transport.ProtobufConnection>> iterator = connectedNodes.entrySet().iterator();
+            Iterator<Map.Entry<DiscoveryNode, Transport.ProtobufConnection>> iterator = connectedNodes.entrySet().iterator();
             while (iterator.hasNext()) {
-                Map.Entry<ProtobufDiscoveryNode, Transport.ProtobufConnection> next = iterator.next();
+                Map.Entry<DiscoveryNode, Transport.ProtobufConnection> next = iterator.next();
                 try {
                     IOUtils.closeWhileHandlingException(next.getValue());
                 } finally {
@@ -85,7 +83,7 @@ public void removeListener(ProtobufTransportConnectionListener listener) {
 
     @Override
     public void openConnection(
-        ProtobufDiscoveryNode node,
+        DiscoveryNode node,
         ProtobufConnectionProfile connectionProfile,
         ActionListener<Transport.ProtobufConnection> listener
     ) {
@@ -100,7 +98,7 @@ public void openConnection(
     */
     @Override
     public void connectToNode(
-        ProtobufDiscoveryNode node,
+        DiscoveryNode node,
         ProtobufConnectionProfile connectionProfile,
         ConnectionValidator connectionValidator,
         ActionListener<Void> listener
@@ -180,10 +178,10 @@ public void connectToNode(
     * maintained by this connection manager
     *
     * @throws ProtobufNodeNotConnectedException if the node is not connected
-    * @see #connectToNode(ProtobufDiscoveryNode, ProtobufConnectionProfile, ConnectionValidator, ActionListener)
+    * @see #connectToNode(DiscoveryNode, ProtobufConnectionProfile, ConnectionValidator, ActionListener)
     */
     @Override
-    public Transport.ProtobufConnection getConnection(ProtobufDiscoveryNode node) {
+    public Transport.ProtobufConnection getConnection(DiscoveryNode node) {
         Transport.ProtobufConnection connection = connectedNodes.get(node);
         if (connection == null) {
             throw new ProtobufNodeNotConnectedException(node, "Node not connected");
@@ -195,7 +193,7 @@ public Transport.ProtobufConnection getConnection(ProtobufDiscoveryNode node) {
      * Returns {@code true} if the node is connected.
     */
     @Override
-    public boolean nodeConnected(ProtobufDiscoveryNode node) {
+    public boolean nodeConnected(DiscoveryNode node) {
         return connectedNodes.containsKey(node);
     }
 
@@ -203,7 +201,7 @@ public boolean nodeConnected(ProtobufDiscoveryNode node) {
      * Disconnected from the given node, if not connected, will do nothing.
     */
     @Override
-    public void disconnectFromNode(ProtobufDiscoveryNode node) {
+    public void disconnectFromNode(DiscoveryNode node) {
         Transport.ProtobufConnection nodeChannels = connectedNodes.remove(node);
         if (nodeChannels != null) {
             // if we found it and removed it we close
@@ -220,7 +218,7 @@ public int size() {
     }
 
     @Override
-    public Set<ProtobufDiscoveryNode> getAllConnectedNodes() {
+    public Set<DiscoveryNode> getAllConnectedNodes() {
         return Collections.unmodifiableSet(connectedNodes.keySet());
     }
 
@@ -250,7 +248,7 @@ private void internalClose(boolean waitForPendingConnections) {
     }
 
     private void internalOpenConnection(
-        ProtobufDiscoveryNode node,
+        DiscoveryNode node,
         ProtobufConnectionProfile connectionProfile,
         ActionListener<Transport.ProtobufConnection> listener
     ) {
@@ -268,12 +266,7 @@ private void internalOpenConnection(
         }));
     }
 
-    private void failConnectionListeners(
-        ProtobufDiscoveryNode node,
-        RunOnce releaseOnce,
-        Exception e,
-        ListenableFuture<Void> expectedListener
-    ) {
+    private void failConnectionListeners(DiscoveryNode node, RunOnce releaseOnce, Exception e, ListenableFuture<Void> expectedListener) {
         ListenableFuture<Void> future = pendingConnections.remove(node);
         releaseOnce.run();
         if (future != null) {
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufConnectTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufConnectTransportException.java
index ebb7e37b7010b..3a8108db629bf 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufConnectTransportException.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufConnectTransportException.java
@@ -10,7 +10,7 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
 
@@ -23,29 +23,29 @@
 */
 public class ProtobufConnectTransportException extends ProtobufActionTransportException {
 
-    private final ProtobufDiscoveryNode node;
+    private final DiscoveryNode node;
 
-    public ProtobufConnectTransportException(ProtobufDiscoveryNode node, String msg) {
+    public ProtobufConnectTransportException(DiscoveryNode node, String msg) {
         this(node, msg, null, null);
     }
 
-    public ProtobufConnectTransportException(ProtobufDiscoveryNode node, String msg, String action) {
+    public ProtobufConnectTransportException(DiscoveryNode node, String msg, String action) {
         this(node, msg, action, null);
     }
 
-    public ProtobufConnectTransportException(ProtobufDiscoveryNode node, String msg, Throwable cause) {
+    public ProtobufConnectTransportException(DiscoveryNode node, String msg, Throwable cause) {
         this(node, msg, null, cause);
     }
 
-    public ProtobufConnectTransportException(ProtobufDiscoveryNode node, String msg, String action, Throwable cause) {
-        super(node == null ? null : node.getName(), node == null ? null : node.getAddress(), action, msg, cause);
+    public ProtobufConnectTransportException(DiscoveryNode node, String msg, String action, Throwable cause) {
+        super(node == null ? null : node.getName(), node == null ? null : node.getProtobufAddress(), action, msg, cause);
         this.node = node;
     }
 
     public ProtobufConnectTransportException(CodedInputStream in) throws IOException {
         super(in);
         ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        node = protobufStreamInput.readOptionalWriteable(ProtobufDiscoveryNode::new);
+        node = protobufStreamInput.readOptionalWriteable(DiscoveryNode::new);
     }
 
     @Override
@@ -55,7 +55,7 @@ public void writeTo(CodedOutputStream out) throws IOException {
         protobufStreamOutput.writeOptionalWriteable(node);
     }
 
-    public ProtobufDiscoveryNode node() {
+    public DiscoveryNode node() {
         return node;
     }
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java b/server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java
index 05d059955d0fb..d1ed3a6812bed 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java
@@ -9,7 +9,7 @@
 package org.opensearch.transport;
 
 import org.opensearch.action.ActionListener;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 
 import java.io.Closeable;
 import java.util.Set;
@@ -27,25 +27,25 @@ public interface ProtobufConnectionManager extends Closeable {
     void removeListener(ProtobufTransportConnectionListener listener);
 
     void openConnection(
-        ProtobufDiscoveryNode node,
+        DiscoveryNode node,
         ProtobufConnectionProfile connectionProfile,
         ActionListener<Transport.ProtobufConnection> listener
     );
 
     void connectToNode(
-        ProtobufDiscoveryNode node,
+        DiscoveryNode node,
         ProtobufConnectionProfile connectionProfile,
         ConnectionValidator connectionValidator,
         ActionListener<Void> listener
     ) throws ConnectTransportException;
 
-    Transport.ProtobufConnection getConnection(ProtobufDiscoveryNode node);
+    Transport.ProtobufConnection getConnection(DiscoveryNode node);
 
-    boolean nodeConnected(ProtobufDiscoveryNode node);
+    boolean nodeConnected(DiscoveryNode node);
 
-    void disconnectFromNode(ProtobufDiscoveryNode node);
+    void disconnectFromNode(DiscoveryNode node);
 
-    Set<ProtobufDiscoveryNode> getAllConnectedNodes();
+    Set<DiscoveryNode> getAllConnectedNodes();
 
     int size();
 
@@ -76,14 +76,14 @@ final class DelegatingNodeConnectionListener implements ProtobufTransportConnect
         private final CopyOnWriteArrayList<ProtobufTransportConnectionListener> listeners = new CopyOnWriteArrayList<>();
 
         @Override
-        public void onNodeDisconnected(ProtobufDiscoveryNode key, Transport.ProtobufConnection connection) {
+        public void onNodeDisconnected(DiscoveryNode key, Transport.ProtobufConnection connection) {
             for (ProtobufTransportConnectionListener listener : listeners) {
                 listener.onNodeDisconnected(key, connection);
             }
         }
 
         @Override
-        public void onNodeConnected(ProtobufDiscoveryNode node, Transport.ProtobufConnection connection) {
+        public void onNodeConnected(DiscoveryNode node, Transport.ProtobufConnection connection) {
             for (ProtobufTransportConnectionListener listener : listeners) {
                 listener.onNodeConnected(node, connection);
             }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufConnectionProfile.java b/server/src/main/java/org/opensearch/transport/ProtobufConnectionProfile.java
index a2e10d03bd189..db39394a4e94c 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufConnectionProfile.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufConnectionProfile.java
@@ -8,7 +8,7 @@
 
 package org.opensearch.transport;
 
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
@@ -84,14 +84,11 @@ public static ProtobufConnectionProfile buildDefaultConnectionProfile(Settings s
         builder.addConnections(connectionsPerNodePing, TransportRequestOptions.Type.PING);
         // if we are not cluster-manager eligible we don't need a dedicated channel to publish the state
         builder.addConnections(
-            ProtobufDiscoveryNode.isClusterManagerNode(settings) ? connectionsPerNodeState : 0,
+            DiscoveryNode.isClusterManagerNode(settings) ? connectionsPerNodeState : 0,
             TransportRequestOptions.Type.STATE
         );
         // if we are not a data-node we don't need any dedicated channels for recovery
-        builder.addConnections(
-            ProtobufDiscoveryNode.isDataNode(settings) ? connectionsPerNodeRecovery : 0,
-            TransportRequestOptions.Type.RECOVERY
-        );
+        builder.addConnections(DiscoveryNode.isDataNode(settings) ? connectionsPerNodeRecovery : 0, TransportRequestOptions.Type.RECOVERY);
         builder.addConnections(connectionsPerNodeReg, TransportRequestOptions.Type.REG);
         return builder.build();
     }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufNodeDisconnectedException.java b/server/src/main/java/org/opensearch/transport/ProtobufNodeDisconnectedException.java
index 7a46892128218..19a2ff22dfb55 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufNodeDisconnectedException.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufNodeDisconnectedException.java
@@ -9,7 +9,7 @@
 package org.opensearch.transport;
 
 import com.google.protobuf.CodedInputStream;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 
 import java.io.IOException;
 
@@ -20,7 +20,7 @@
 */
 public class ProtobufNodeDisconnectedException extends ProtobufConnectTransportException {
 
-    public ProtobufNodeDisconnectedException(ProtobufDiscoveryNode node, String action) {
+    public ProtobufNodeDisconnectedException(DiscoveryNode node, String action) {
         super(node, "disconnected", action, null);
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufNodeNotConnectedException.java b/server/src/main/java/org/opensearch/transport/ProtobufNodeNotConnectedException.java
index 9b90f26324fb3..1aa71c609f9d6 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufNodeNotConnectedException.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufNodeNotConnectedException.java
@@ -9,7 +9,7 @@
 package org.opensearch.transport;
 
 import com.google.protobuf.CodedInputStream;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 
 import java.io.IOException;
 
@@ -20,7 +20,7 @@
 */
 public class ProtobufNodeNotConnectedException extends ProtobufConnectTransportException {
 
-    public ProtobufNodeNotConnectedException(ProtobufDiscoveryNode node, String msg) {
+    public ProtobufNodeNotConnectedException(DiscoveryNode node, String msg) {
         super(node, msg, (String) null);
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java b/server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java
index 365bed06c42f7..63e108b044831 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java
@@ -15,7 +15,7 @@
 import org.opensearch.Version;
 import org.opensearch.action.ActionListener;
 import org.opensearch.action.NotifyOnceListener;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.CheckedSupplier;
 import org.opensearch.common.bytes.BytesReference;
 import org.opensearch.common.lease.Releasable;
@@ -78,7 +78,7 @@ void sendBytes(TcpChannel channel, BytesReference bytes, ActionListener<Void> li
     * objects back to the caller.
     */
     void sendRequest(
-        final ProtobufDiscoveryNode node,
+        final DiscoveryNode node,
         final TcpChannel channel,
         final long requestId,
         final String action,
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufProxyConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/ProtobufProxyConnectionStrategy.java
index 52fa5f55ad1ff..584967aa2b9bb 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufProxyConnectionStrategy.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufProxyConnectionStrategy.java
@@ -13,15 +13,16 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.Version;
 import org.opensearch.action.ActionListener;
-import org.opensearch.cluster.ProtobufClusterName;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.common.Strings;
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.util.concurrent.CountDown;
 import org.opensearch.core.xcontent.XContentBuilder;
 
@@ -93,8 +94,8 @@ public class ProtobufProxyConnectionStrategy extends ProtobufRemoteConnectionStr
     private final int maxNumConnections;
     private final String configuredAddress;
     private final String configuredServerName;
-    private final Supplier<ProtobufTransportAddress> address;
-    private final AtomicReference<ProtobufClusterName> remoteClusterName = new AtomicReference<>();
+    private final Supplier<TransportAddress> address;
+    private final AtomicReference<ClusterName> remoteClusterName = new AtomicReference<>();
     private final ProtobufConnectionManager.ConnectionValidator clusterNameValidator;
 
     ProtobufProxyConnectionStrategy(
@@ -162,7 +163,7 @@ public class ProtobufProxyConnectionStrategy extends ProtobufRemoteConnectionStr
         Settings settings,
         int maxNumConnections,
         String configuredAddress,
-        Supplier<ProtobufTransportAddress> address,
+        Supplier<TransportAddress> address,
         String configuredServerName
     ) {
         super(clusterAlias, transportService, connectionManager, settings);
@@ -176,12 +177,12 @@ public class ProtobufProxyConnectionStrategy extends ProtobufRemoteConnectionStr
             actualProfile.getHandshakeTimeout().millis(),
             cn -> true,
             ActionListener.map(listener, resp -> {
-                ProtobufClusterName remote = resp.getClusterName();
+                ClusterName remote = resp.getClusterName();
                 if (remoteClusterName.compareAndSet(null, remote)) {
                     return null;
                 } else {
                     if (remoteClusterName.get().equals(remote) == false) {
-                        ProtobufDiscoveryNode node = newConnection.getNode();
+                        DiscoveryNode node = newConnection.getNode();
                         throw new ProtobufConnectTransportException(node, "handshake failed. unexpected remote cluster name " + remote);
                     }
                     return null;
@@ -234,7 +235,7 @@ private void performProxyConnectionProcess(ActionListener<Void> listener) {
 
     private void openConnections(ActionListener<Void> finished, int attemptNumber) {
         if (attemptNumber <= MAX_CONNECT_ATTEMPTS_PER_RUN) {
-            ProtobufTransportAddress resolved = address.get();
+            TransportAddress resolved = address.get();
 
             int remaining = maxNumConnections - connectionManager.size();
             ActionListener<Void> compositeListener = new ActionListener<Void>() {
@@ -270,9 +271,9 @@ public void onFailure(Exception e) {
                 } else {
                     attributes = Collections.singletonMap("server_name", configuredServerName);
                 }
-                ProtobufDiscoveryNode node = new ProtobufDiscoveryNode(
+                DiscoveryNode node = new DiscoveryNode(
                     id,
-                    resolved,
+                    new TransportAddress(resolved.address()),
                     attributes,
                     DiscoveryNodeRole.BUILT_IN_ROLES,
                     Version.CURRENT.minimumCompatibilityVersion()
@@ -316,8 +317,8 @@ public void onFailure(Exception e) {
         }
     }
 
-    private static ProtobufTransportAddress resolveAddress(String address) {
-        return new ProtobufTransportAddress(parseConfiguredAddress(address));
+    private static TransportAddress resolveAddress(String address) {
+        return new TransportAddress(parseConfiguredAddress(address));
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufReceiveTimeoutTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufReceiveTimeoutTransportException.java
index 28fb5baa28b2b..704ab50753ee6 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufReceiveTimeoutTransportException.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufReceiveTimeoutTransportException.java
@@ -9,7 +9,7 @@
 package org.opensearch.transport;
 
 import com.google.protobuf.CodedInputStream;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 
 import java.io.IOException;
 
@@ -20,8 +20,8 @@
 */
 public class ProtobufReceiveTimeoutTransportException extends ProtobufActionTransportException {
 
-    public ProtobufReceiveTimeoutTransportException(ProtobufDiscoveryNode node, String action, String msg) {
-        super(node.getName(), node.getAddress(), action, msg, null);
+    public ProtobufReceiveTimeoutTransportException(DiscoveryNode node, String action, String msg) {
+        super(node.getName(), node.getProtobufAddress(), action, msg, null);
     }
 
     public ProtobufReceiveTimeoutTransportException(CodedInputStream in) throws IOException {
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java
index a5317b0fcee62..a5d6fec24c4d3 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java
@@ -15,7 +15,7 @@
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.client.ProtobufClient;
 import org.opensearch.client.support.ProtobufAbstractClient;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.threadpool.ThreadPool;
 
@@ -30,12 +30,7 @@ final class ProtobufRemoteClusterAwareClient extends ProtobufAbstractClient {
     private final String clusterAlias;
     private final RemoteClusterService remoteClusterService;
 
-    ProtobufRemoteClusterAwareClient(
-        Settings settings,
-        ThreadPool threadPool,
-        ProtobufTransportService service,
-        String clusterAlias
-    ) {
+    ProtobufRemoteClusterAwareClient(Settings settings, ThreadPool threadPool, ProtobufTransportService service, String clusterAlias) {
         super(settings, threadPool);
         this.service = service;
         this.clusterAlias = clusterAlias;
@@ -50,8 +45,8 @@ protected <Request extends ProtobufActionRequest, Response extends ProtobufActio
     ) {
         remoteClusterService.ensureConnected(clusterAlias, ActionListener.wrap(v -> {
             Transport.ProtobufConnection connection;
-            if (request instanceof ProtobufRemoteClusterAwareRequest) {
-                ProtobufDiscoveryNode preferredTargetNode = ((ProtobufRemoteClusterAwareRequest) request).getPreferredTargetNode();
+            if (request instanceof RemoteClusterAwareRequest) {
+                DiscoveryNode preferredTargetNode = ((RemoteClusterAwareRequest) request).getPreferredTargetNode();
                 connection = remoteClusterService.getConnectionProtobuf(preferredTargetNode, clusterAlias);
             } else {
                 connection = remoteClusterService.getConnectionProtobuf(clusterAlias);
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareRequest.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareRequest.java
deleted file mode 100644
index 80576bd9608bf..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareRequest.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
-
-/**
- * Request for remote clusters
-*
-* @opensearch.internal
-*/
-public interface ProtobufRemoteClusterAwareRequest {
-
-    /**
-     * Returns the preferred discovery node for this request. The remote cluster client will attempt to send
-    * this request directly to this node. Otherwise, it will send the request as a proxy action that will
-    * be routed by the remote cluster to this node.
-    *
-    * @return preferred discovery node
-    */
-    ProtobufDiscoveryNode getPreferredTargetNode();
-
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
index ef896f62e856e..71fc6c9154b73 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
@@ -14,7 +14,7 @@
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
 import org.opensearch.action.support.ContextPreservingActionListener;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
@@ -106,7 +106,7 @@ void ensureConnected(ActionListener<Void> listener) {
     }
 
     /**
-     * Collects all nodes on the connected cluster and returns / passes a nodeID to {@link ProtobufDiscoveryNode} lookup function
+     * Collects all nodes on the connected cluster and returns / passes a nodeID to {@link DiscoveryNode} lookup function
     * that returns <code>null</code> if the node ID is not found.
     *
     * The requests to get cluster state on the connected cluster are made in the system context because logically
@@ -114,10 +114,10 @@ void ensureConnected(ActionListener<Void> listener) {
     * user who made the request that is using this method in its implementation is authorized to view the entire
     * cluster state.
     */
-    void collectNodes(ActionListener<Function<String, ProtobufDiscoveryNode>> listener) {
+    void collectNodes(ActionListener<Function<String, DiscoveryNode>> listener) {
         Runnable runnable = () -> {
             final ThreadContext threadContext = threadPool.getThreadContext();
-            final ContextPreservingActionListener<Function<String, ProtobufDiscoveryNode>> contextPreservingActionListener =
+            final ContextPreservingActionListener<Function<String, DiscoveryNode>> contextPreservingActionListener =
                 new ContextPreservingActionListener<>(threadContext.newRestorableContext(false), listener);
             try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
                 // we stash any context here since this is an internal execution and should not leak any existing context information
@@ -172,10 +172,10 @@ public String executor() {
     }
 
     /**
-     * Returns a connection to the remote cluster, preferably a direct connection to the provided {@link ProtobufDiscoveryNode}.
+     * Returns a connection to the remote cluster, preferably a direct connection to the provided {@link DiscoveryNode}.
     * If such node is not connected, the returned connection will be a proxy connection that redirects to it.
     */
-    Transport.ProtobufConnection getConnection(ProtobufDiscoveryNode remoteClusterNode) {
+    Transport.ProtobufConnection getConnection(DiscoveryNode remoteClusterNode) {
         return remoteConnectionManager.getConnection(remoteClusterNode);
     }
 
@@ -197,7 +197,7 @@ boolean assertNoRunningConnections() {
         return connectionStrategy.assertNoRunningConnections();
     }
 
-    boolean isNodeConnected(final ProtobufDiscoveryNode node) {
+    boolean isNodeConnected(final DiscoveryNode node) {
         return remoteConnectionManager.nodeConnected(node);
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java
index eef008cbb398e..bbcd06df4a1f7 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java
@@ -16,7 +16,7 @@
 import org.opensearch.action.support.IndicesOptions;
 import org.opensearch.action.support.PlainActionFuture;
 import org.opensearch.client.ProtobufClient;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.common.Strings;
 import org.opensearch.common.settings.ClusterSettings;
@@ -130,7 +130,7 @@ public boolean isEnabled() {
 
     ProtobufRemoteClusterService(Settings settings, ProtobufTransportService transportService) {
         super(settings);
-        this.enabled = ProtobufDiscoveryNode.isRemoteClusterClient(settings);
+        this.enabled = DiscoveryNode.isRemoteClusterClient(settings);
         this.transportService = transportService;
     }
 
@@ -141,7 +141,7 @@ public boolean isCrossClusterSearchEnabled() {
         return remoteClusters.isEmpty() == false;
     }
 
-    boolean isRemoteNodeConnected(final String remoteCluster, final ProtobufDiscoveryNode node) {
+    boolean isRemoteNodeConnected(final String remoteCluster, final DiscoveryNode node) {
         return remoteClusters.get(remoteCluster).isNodeConnected(node);
     }
 
@@ -185,7 +185,7 @@ public Set<String> getRegisteredRemoteClusterNames() {
     *
     * @throws IllegalArgumentException if the remote cluster is unknown
     */
-    public Transport.ProtobufConnection getConnection(ProtobufDiscoveryNode node, String cluster) {
+    public Transport.ProtobufConnection getConnection(DiscoveryNode node, String cluster) {
         return getRemoteClusterConnection(cluster).getConnection(node);
     }
 
@@ -346,10 +346,10 @@ public Stream<ProtobufRemoteConnectionInfo> getRemoteConnectionInfos() {
     }
 
     /**
-     * Collects all nodes of the given clusters and returns / passes a (clusterAlias, nodeId) to {@link ProtobufDiscoveryNode}
+     * Collects all nodes of the given clusters and returns / passes a (clusterAlias, nodeId) to {@link DiscoveryNode}
     * function on success.
     */
-    public void collectNodes(Set<String> clusters, ActionListener<BiFunction<String, String, ProtobufDiscoveryNode>> listener) {
+    public void collectNodes(Set<String> clusters, ActionListener<BiFunction<String, String, DiscoveryNode>> listener) {
         if (enabled == false) {
             throw new IllegalArgumentException(
                 "this node does not have the " + DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName() + " role"
@@ -363,14 +363,14 @@ public void collectNodes(Set<String> clusters, ActionListener<BiFunction<String,
             }
         }
 
-        final Map<String, Function<String, ProtobufDiscoveryNode>> clusterMap = new HashMap<>();
+        final Map<String, Function<String, DiscoveryNode>> clusterMap = new HashMap<>();
         CountDown countDown = new CountDown(clusters.size());
-        Function<String, ProtobufDiscoveryNode> nullFunction = s -> null;
+        Function<String, DiscoveryNode> nullFunction = s -> null;
         for (final String cluster : clusters) {
             ProtobufRemoteClusterConnection connection = remoteClusters.get(cluster);
-            connection.collectNodes(new ActionListener<Function<String, ProtobufDiscoveryNode>>() {
+            connection.collectNodes(new ActionListener<Function<String, DiscoveryNode>>() {
                 @Override
-                public void onResponse(Function<String, ProtobufDiscoveryNode> nodeLookup) {
+                public void onResponse(Function<String, DiscoveryNode> nodeLookup) {
                     synchronized (clusterMap) {
                         clusterMap.put(cluster, nodeLookup);
                     }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java
index 95c0e2a9624bd..f0c7a093d83f6 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java
@@ -10,7 +10,7 @@
 
 import org.opensearch.Version;
 import org.opensearch.action.ActionListener;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -29,19 +29,19 @@ public class ProtobufRemoteConnectionManager implements ProtobufConnectionManage
     private final String clusterAlias;
     private final ProtobufConnectionManager delegate;
     private final AtomicLong counter = new AtomicLong();
-    private volatile List<ProtobufDiscoveryNode> connectedNodes = Collections.emptyList();
+    private volatile List<DiscoveryNode> connectedNodes = Collections.emptyList();
 
     ProtobufRemoteConnectionManager(String clusterAlias, ProtobufConnectionManager delegate) {
         this.clusterAlias = clusterAlias;
         this.delegate = delegate;
         this.delegate.addListener(new ProtobufTransportConnectionListener() {
             @Override
-            public void onNodeConnected(ProtobufDiscoveryNode node, Transport.ProtobufConnection connection) {
+            public void onNodeConnected(DiscoveryNode node, Transport.ProtobufConnection connection) {
                 addConnectedNode(node);
             }
 
             @Override
-            public void onNodeDisconnected(ProtobufDiscoveryNode node, Transport.ProtobufConnection connection) {
+            public void onNodeDisconnected(DiscoveryNode node, Transport.ProtobufConnection connection) {
                 removeConnectedNode(node);
             }
         });
@@ -49,7 +49,7 @@ public void onNodeDisconnected(ProtobufDiscoveryNode node, Transport.ProtobufCon
 
     @Override
     public void connectToNode(
-        ProtobufDiscoveryNode node,
+        DiscoveryNode node,
         ProtobufConnectionProfile connectionProfile,
         ProtobufConnectionManager.ConnectionValidator connectionValidator,
         ActionListener<Void> listener
@@ -69,7 +69,7 @@ public void removeListener(ProtobufTransportConnectionListener listener) {
 
     @Override
     public void openConnection(
-        ProtobufDiscoveryNode node,
+        DiscoveryNode node,
         ProtobufConnectionProfile profile,
         ActionListener<Transport.ProtobufConnection> listener
     ) {
@@ -77,7 +77,7 @@ public void openConnection(
     }
 
     @Override
-    public Transport.ProtobufConnection getConnection(ProtobufDiscoveryNode node) {
+    public Transport.ProtobufConnection getConnection(DiscoveryNode node) {
         try {
             return delegate.getConnection(node);
         } catch (NodeNotConnectedException e) {
@@ -86,12 +86,12 @@ public Transport.ProtobufConnection getConnection(ProtobufDiscoveryNode node) {
     }
 
     @Override
-    public boolean nodeConnected(ProtobufDiscoveryNode node) {
+    public boolean nodeConnected(DiscoveryNode node) {
         return delegate.nodeConnected(node);
     }
 
     @Override
-    public void disconnectFromNode(ProtobufDiscoveryNode node) {
+    public void disconnectFromNode(DiscoveryNode node) {
         delegate.disconnectFromNode(node);
     }
 
@@ -101,22 +101,20 @@ public ProtobufConnectionProfile getConnectionProfile() {
     }
 
     public Transport.ProtobufConnection getAnyRemoteConnection() {
-        List<ProtobufDiscoveryNode> localConnectedNodes = this.connectedNodes;
+        List<DiscoveryNode> localConnectedNodes = this.connectedNodes;
         long curr;
         while ((curr = counter.incrementAndGet()) == Long.MIN_VALUE)
             ;
         if (localConnectedNodes.isEmpty() == false) {
-            ProtobufDiscoveryNode nextNode = localConnectedNodes.get(
-                Math.toIntExact(Math.floorMod(curr, (long) localConnectedNodes.size()))
-            );
+            DiscoveryNode nextNode = localConnectedNodes.get(Math.toIntExact(Math.floorMod(curr, (long) localConnectedNodes.size())));
             try {
                 return delegate.getConnection(nextNode);
             } catch (NodeNotConnectedException e) {
                 // Ignore. We will manually create an iterator of open nodes
             }
         }
-        Set<ProtobufDiscoveryNode> allConnectionNodes = getAllConnectedNodes();
-        for (ProtobufDiscoveryNode connectedNode : allConnectionNodes) {
+        Set<DiscoveryNode> allConnectionNodes = getAllConnectedNodes();
+        for (DiscoveryNode connectedNode : allConnectionNodes) {
             try {
                 return delegate.getConnection(connectedNode);
             } catch (NodeNotConnectedException e) {
@@ -127,7 +125,7 @@ public Transport.ProtobufConnection getAnyRemoteConnection() {
     }
 
     @Override
-    public Set<ProtobufDiscoveryNode> getAllConnectedNodes() {
+    public Set<DiscoveryNode> getAllConnectedNodes() {
         return delegate.getAllConnectedNodes();
     }
 
@@ -146,16 +144,16 @@ public void closeNoBlock() {
         delegate.closeNoBlock();
     }
 
-    private synchronized void addConnectedNode(ProtobufDiscoveryNode addedNode) {
-        ArrayList<ProtobufDiscoveryNode> newConnections = new ArrayList<>(this.connectedNodes);
+    private synchronized void addConnectedNode(DiscoveryNode addedNode) {
+        ArrayList<DiscoveryNode> newConnections = new ArrayList<>(this.connectedNodes);
         newConnections.add(addedNode);
         this.connectedNodes = Collections.unmodifiableList(newConnections);
     }
 
-    private synchronized void removeConnectedNode(ProtobufDiscoveryNode removedNode) {
+    private synchronized void removeConnectedNode(DiscoveryNode removedNode) {
         int newSize = this.connectedNodes.size() - 1;
-        ArrayList<ProtobufDiscoveryNode> newConnectedNodes = new ArrayList<>(newSize);
-        for (ProtobufDiscoveryNode connectedNode : this.connectedNodes) {
+        ArrayList<DiscoveryNode> newConnectedNodes = new ArrayList<>(newSize);
+        for (DiscoveryNode connectedNode : this.connectedNodes) {
             if (connectedNode.equals(removedNode) == false) {
                 newConnectedNodes.add(connectedNode);
             }
@@ -166,15 +164,15 @@ private synchronized void removeConnectedNode(ProtobufDiscoveryNode removedNode)
 
     static final class ProxyConnection implements Transport.ProtobufConnection {
         private final Transport.ProtobufConnection connection;
-        private final ProtobufDiscoveryNode targetNode;
+        private final DiscoveryNode targetNode;
 
-        private ProxyConnection(Transport.ProtobufConnection connection, ProtobufDiscoveryNode targetNode) {
+        private ProxyConnection(Transport.ProtobufConnection connection, DiscoveryNode targetNode) {
             this.connection = connection;
             this.targetNode = targetNode;
         }
 
         @Override
-        public ProtobufDiscoveryNode getNode() {
+        public DiscoveryNode getNode() {
             return targetNode;
         }
 
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java
index 53f3ad80acc4e..3b9b68a3b5be3 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java
@@ -38,7 +38,7 @@
 import org.apache.lucene.store.AlreadyClosedException;
 import org.opensearch.action.ActionListener;
 import org.opensearch.action.support.ContextPreservingActionListener;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.Strings;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.settings.Setting;
@@ -361,7 +361,7 @@ boolean shouldRebuildConnection(Settings newSettings) {
     protected abstract ProtobufConnectionStrategy strategyType();
 
     @Override
-    public void onNodeDisconnected(ProtobufDiscoveryNode node, Transport.ProtobufConnection connection) {
+    public void onNodeDisconnected(DiscoveryNode node, Transport.ProtobufConnection connection) {
         if (shouldOpenMoreConnections()) {
             // try to reconnect and fill up the slot of the disconnected node
             connect(
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
index 8a2d15db70e11..f2c65666bd7b9 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
@@ -74,7 +74,10 @@ public void processMessageReceived(Request request, ProtobufTransportChannel cha
                 // );
                 // }
                 final TcpChannel tcpChannel = ((ProtobufTcpTransportChannel) channel).getChannel();
-                final Releasable stopTracking = taskManager.startProtobufTrackingCancellableChannelTask(tcpChannel, (ProtobufCancellableTask) task);
+                final Releasable stopTracking = taskManager.startProtobufTrackingCancellableChannelTask(
+                    tcpChannel,
+                    (ProtobufCancellableTask) task
+                );
                 unregisterTask = Releasables.wrap(unregisterTask, stopTracking);
             }
             final ProtobufTaskTransportChannel taskTransportChannel = new ProtobufTaskTransportChannel(channel, unregisterTask);
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufSendRequestTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufSendRequestTransportException.java
index eb1e1340230c4..0281f1c530a44 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufSendRequestTransportException.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufSendRequestTransportException.java
@@ -10,7 +10,7 @@
 
 import com.google.protobuf.CodedInputStream;
 import org.opensearch.OpenSearchWrapperException;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 
 import java.io.IOException;
 
@@ -21,8 +21,8 @@
 */
 public class ProtobufSendRequestTransportException extends ProtobufActionTransportException implements OpenSearchWrapperException {
 
-    public ProtobufSendRequestTransportException(ProtobufDiscoveryNode node, String action, Throwable cause) {
-        super(node == null ? null : node.getName(), node == null ? null : node.getAddress(), action, cause);
+    public ProtobufSendRequestTransportException(DiscoveryNode node, String action, Throwable cause) {
+        super(node == null ? null : node.getName(), node == null ? null : node.getProtobufAddress(), action, cause);
     }
 
     public ProtobufSendRequestTransportException(CodedInputStream in) throws IOException {
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java
index f503ff0951eda..edf73810a43c2 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java
@@ -17,8 +17,8 @@
 import org.opensearch.action.admin.cluster.state.ClusterStateAction;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
-import org.opensearch.cluster.ProtobufClusterName;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.common.Booleans;
 import org.opensearch.common.SetOnce;
@@ -29,7 +29,7 @@
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.common.util.io.IOUtils;
@@ -118,14 +118,14 @@ public class ProtobufSniffConnectionStrategy extends ProtobufRemoteConnectionStr
 
     static final int CHANNELS_PER_CONNECTION = 6;
 
-    private static final Predicate<ProtobufDiscoveryNode> DEFAULT_NODE_PREDICATE = (node) -> Version.CURRENT.isCompatible(node.getVersion())
+    private static final Predicate<DiscoveryNode> DEFAULT_NODE_PREDICATE = (node) -> Version.CURRENT.isCompatible(node.getVersion())
         && (node.isClusterManagerNode() == false || node.isDataNode() || node.isIngestNode());
 
     private final List<String> configuredSeedNodes;
-    private final List<Supplier<ProtobufDiscoveryNode>> seedNodes;
+    private final List<Supplier<DiscoveryNode>> seedNodes;
     private final int maxNumRemoteConnections;
-    private final Predicate<ProtobufDiscoveryNode> nodePredicate;
-    private final SetOnce<ProtobufClusterName> remoteClusterName = new SetOnce<>();
+    private final Predicate<DiscoveryNode> nodePredicate;
+    private final SetOnce<ClusterName> remoteClusterName = new SetOnce<>();
     private final String proxyAddress;
 
     ProtobufSniffConnectionStrategy(
@@ -153,7 +153,7 @@ public class ProtobufSniffConnectionStrategy extends ProtobufRemoteConnectionStr
         String proxyAddress,
         Settings settings,
         int maxNumRemoteConnections,
-        Predicate<ProtobufDiscoveryNode> nodePredicate,
+        Predicate<DiscoveryNode> nodePredicate,
         List<String> configuredSeedNodes
     ) {
         this(
@@ -166,7 +166,7 @@ public class ProtobufSniffConnectionStrategy extends ProtobufRemoteConnectionStr
             nodePredicate,
             configuredSeedNodes,
             configuredSeedNodes.stream()
-                .map(seedAddress -> (Supplier<ProtobufDiscoveryNode>) () -> resolveSeedNode(clusterAlias, seedAddress, proxyAddress))
+                .map(seedAddress -> (Supplier<DiscoveryNode>) () -> resolveSeedNode(clusterAlias, seedAddress, proxyAddress))
                 .collect(Collectors.toList())
         );
     }
@@ -178,9 +178,9 @@ public class ProtobufSniffConnectionStrategy extends ProtobufRemoteConnectionStr
         String proxyAddress,
         Settings settings,
         int maxNumRemoteConnections,
-        Predicate<ProtobufDiscoveryNode> nodePredicate,
+        Predicate<DiscoveryNode> nodePredicate,
         List<String> configuredSeedNodes,
-        List<Supplier<ProtobufDiscoveryNode>> seedNodes
+        List<Supplier<DiscoveryNode>> seedNodes
     ) {
         super(clusterAlias, transportService, connectionManager, settings);
         this.proxyAddress = proxyAddress;
@@ -228,7 +228,7 @@ protected ProtobufRemoteConnectionInfo.ModeInfo getModeInfo() {
         return new SniffModeInfo(configuredSeedNodes, maxNumRemoteConnections, connectionManager.size());
     }
 
-    private void collectRemoteNodes(Iterator<Supplier<ProtobufDiscoveryNode>> seedNodes, ActionListener<Void> listener) {
+    private void collectRemoteNodes(Iterator<Supplier<DiscoveryNode>> seedNodes, ActionListener<Void> listener) {
         if (Thread.currentThread().isInterrupted()) {
             listener.onFailure(new InterruptedException("remote connect thread got interrupted"));
             return;
@@ -254,7 +254,7 @@ private void collectRemoteNodes(Iterator<Supplier<ProtobufDiscoveryNode>> seedNo
                 listener.onFailure(e);
             };
 
-            final ProtobufDiscoveryNode seedNode = seedNodes.next().get();
+            final DiscoveryNode seedNode = seedNodes.next().get();
             logger.trace("[{}] opening transient connection to seed node: [{}]", clusterAlias, seedNode);
             final StepListener<Transport.ProtobufConnection> openConnectionStep = new StepListener<>();
             try {
@@ -276,7 +276,7 @@ private void collectRemoteNodes(Iterator<Supplier<ProtobufDiscoveryNode>> seedNo
 
             final StepListener<Void> fullConnectionStep = new StepListener<>();
             handshakeStep.whenComplete(handshakeResponse -> {
-                final ProtobufDiscoveryNode handshakeNode = handshakeResponse.getDiscoveryNode();
+                final DiscoveryNode handshakeNode = handshakeResponse.getDiscoveryNode();
 
                 if (nodePredicate.test(handshakeNode) && shouldOpenMoreConnections()) {
                     logger.trace(
@@ -285,7 +285,7 @@ private void collectRemoteNodes(Iterator<Supplier<ProtobufDiscoveryNode>> seedNo
                         handshakeNode,
                         proxyAddress
                     );
-                    final ProtobufDiscoveryNode handshakeNodeWithProxy = maybeAddProxyAddress(proxyAddress, handshakeNode);
+                    final DiscoveryNode handshakeNodeWithProxy = maybeAddProxyAddress(proxyAddress, handshakeNode);
                     connectionManager.connectToNode(
                         handshakeNodeWithProxy,
                         null,
@@ -297,7 +297,7 @@ private void collectRemoteNodes(Iterator<Supplier<ProtobufDiscoveryNode>> seedNo
                 }
             }, e -> {
                 final Transport.ProtobufConnection connection = openConnectionStep.result();
-                final ProtobufDiscoveryNode node = connection.getNode();
+                final DiscoveryNode node = connection.getNode();
                 logger.debug(() -> new ParameterizedMessage("[{}] failed to handshake with seed node: [{}]", clusterAlias, node), e);
                 IOUtils.closeWhileHandlingException(connection);
                 onFailure.accept(e);
@@ -338,7 +338,7 @@ private void collectRemoteNodes(Iterator<Supplier<ProtobufDiscoveryNode>> seedNo
                 }
             }, e -> {
                 final Transport.ProtobufConnection connection = openConnectionStep.result();
-                final ProtobufDiscoveryNode node = connection.getNode();
+                final DiscoveryNode node = connection.getNode();
                 logger.debug(
                     () -> new ParameterizedMessage("[{}] failed to open managed connection to seed node: [{}]", clusterAlias, node),
                     e
@@ -356,12 +356,12 @@ private class SniffClusterStateResponseHandler implements ProtobufTransportRespo
 
         private final Transport.ProtobufConnection connection;
         private final ActionListener<Void> listener;
-        private final Iterator<Supplier<ProtobufDiscoveryNode>> seedNodes;
+        private final Iterator<Supplier<DiscoveryNode>> seedNodes;
 
         SniffClusterStateResponseHandler(
             Transport.ProtobufConnection connection,
             ActionListener<Void> listener,
-            Iterator<Supplier<ProtobufDiscoveryNode>> seedNodes
+            Iterator<Supplier<DiscoveryNode>> seedNodes
         ) {
             this.connection = connection;
             this.listener = listener;
@@ -378,12 +378,12 @@ public void handleResponse(ProtobufClusterStateResponse response) {
             handleNodes(response.getState().nodes().getNodes().valuesIt());
         }
 
-        private void handleNodes(Iterator<ProtobufDiscoveryNode> nodesIter) {
+        private void handleNodes(Iterator<DiscoveryNode> nodesIter) {
             while (nodesIter.hasNext()) {
-                final ProtobufDiscoveryNode node = nodesIter.next();
+                final DiscoveryNode node = nodesIter.next();
                 if (nodePredicate.test(node) && shouldOpenMoreConnections()) {
                     logger.trace("[{}] opening managed connection to node: [{}] proxy address: [{}]", clusterAlias, node, proxyAddress);
-                    final ProtobufDiscoveryNode nodeWithProxy = maybeAddProxyAddress(proxyAddress, node);
+                    final DiscoveryNode nodeWithProxy = maybeAddProxyAddress(proxyAddress, node);
                     connectionManager.connectToNode(
                         nodeWithProxy,
                         null,
@@ -451,10 +451,10 @@ public String executor() {
         }
     }
 
-    private Predicate<ProtobufClusterName> getRemoteClusterNamePredicate() {
-        return new Predicate<ProtobufClusterName>() {
+    private Predicate<ClusterName> getRemoteClusterNamePredicate() {
+        return new Predicate<ClusterName>() {
             @Override
-            public boolean test(ProtobufClusterName c) {
+            public boolean test(ClusterName c) {
                 return remoteClusterName.get() == null || c.equals(remoteClusterName.get());
             }
 
@@ -467,18 +467,18 @@ public String toString() {
         };
     }
 
-    private static ProtobufDiscoveryNode resolveSeedNode(String clusterAlias, String address, String proxyAddress) {
+    private static DiscoveryNode resolveSeedNode(String clusterAlias, String address, String proxyAddress) {
         if (proxyAddress == null || proxyAddress.isEmpty()) {
-            ProtobufTransportAddress transportAddress = new ProtobufTransportAddress(parseConfiguredAddress(address));
-            return new ProtobufDiscoveryNode(
+            TransportAddress transportAddress = new TransportAddress(parseConfiguredAddress(address));
+            return new DiscoveryNode(
                 clusterAlias + "#" + transportAddress.toString(),
                 transportAddress,
                 Version.CURRENT.minimumCompatibilityVersion()
             );
         } else {
-            ProtobufTransportAddress transportAddress = new ProtobufTransportAddress(parseConfiguredAddress(proxyAddress));
+            TransportAddress transportAddress = new TransportAddress(parseConfiguredAddress(proxyAddress));
             String hostName = ProtobufRemoteConnectionStrategy.parseHost(proxyAddress);
-            return new ProtobufDiscoveryNode(
+            return new DiscoveryNode(
                 "",
                 clusterAlias + "#" + address,
                 UUIDs.randomBase64UUID(),
@@ -493,7 +493,7 @@ private static ProtobufDiscoveryNode resolveSeedNode(String clusterAlias, String
     }
 
     // Default visibility for tests
-    static Predicate<ProtobufDiscoveryNode> getNodePredicate(Settings settings) {
+    static Predicate<DiscoveryNode> getNodePredicate(Settings settings) {
         if (RemoteClusterService.REMOTE_NODE_ATTRIBUTE.exists(settings)) {
             // nodes can be tagged with node.attr.remote_gateway: true to allow a node to be a gateway node for cross cluster search
             String attribute = RemoteClusterService.REMOTE_NODE_ATTRIBUTE.get(settings);
@@ -502,19 +502,19 @@ static Predicate<ProtobufDiscoveryNode> getNodePredicate(Settings settings) {
         return DEFAULT_NODE_PREDICATE;
     }
 
-    private static ProtobufDiscoveryNode maybeAddProxyAddress(String proxyAddress, ProtobufDiscoveryNode node) {
+    private static DiscoveryNode maybeAddProxyAddress(String proxyAddress, DiscoveryNode node) {
         if (proxyAddress == null || proxyAddress.isEmpty()) {
             return node;
         } else {
             // resolve proxy address lazy here
             InetSocketAddress proxyInetAddress = parseConfiguredAddress(proxyAddress);
-            return new ProtobufDiscoveryNode(
+            return new DiscoveryNode(
                 node.getName(),
                 node.getId(),
                 node.getEphemeralId(),
                 node.getHostName(),
                 node.getHostAddress(),
-                new ProtobufTransportAddress(proxyInetAddress),
+                new TransportAddress(proxyInetAddress),
                 node.getAttributes(),
                 node.getRoles(),
                 node.getVersion()
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransport.java b/server/src/main/java/org/opensearch/transport/ProtobufTransport.java
deleted file mode 100644
index 234583dd011a8..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransport.java
+++ /dev/null
@@ -1,281 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import org.opensearch.Version;
-import org.opensearch.action.ActionListener;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
-import org.opensearch.common.collect.MapBuilder;
-import org.opensearch.common.component.LifecycleComponent;
-import org.opensearch.common.transport.ProtobufBoundTransportAddress;
-import org.opensearch.common.transport.ProtobufTransportAddress;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.common.util.concurrent.ConcurrentCollections;
-import org.opensearch.common.util.concurrent.ConcurrentMapLong;
-
-import java.io.Closeable;
-import java.io.IOException;
-import java.net.UnknownHostException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.function.Predicate;
-
-/**
- * OpenSearch ProtobufTransport Interface
-*
-* @opensearch.internal
-*/
-public interface ProtobufTransport extends LifecycleComponent {
-
-    /**
-     * Registers a new request handler
-    */
-    default <Request extends ProtobufTransportRequest> void registerRequestHandler(ProtobufRequestHandlerRegistry<Request> reg) {
-        getRequestHandlers().registerHandler(reg);
-    }
-
-    void setMessageListener(ProtobufTransportMessageListener listener);
-
-    default void setSlowLogThreshold(TimeValue slowLogThreshold) {}
-
-    default boolean isSecure() {
-        return false;
-    }
-
-    /**
-     * The address the transport is bound on.
-    */
-    ProtobufBoundTransportAddress boundAddress();
-
-    /**
-     * Further profile bound addresses
-    * @return <code>null</code> iff profiles are unsupported, otherwise a map with name of profile and its bound transport address
-    */
-    Map<String, ProtobufBoundTransportAddress> profileBoundAddresses();
-
-    /**
-     * Returns an address from its string representation.
-    */
-    ProtobufTransportAddress[] addressesFromString(String address) throws UnknownHostException;
-
-    /**
-     * Returns a list of all local addresses for this transport
-    */
-    List<String> getDefaultSeedAddresses();
-
-    /**
-     * Opens a new connection to the given node. When the connection is fully connected, the listener is called.
-    * The ActionListener will be called on the calling thread or the generic thread pool.
-    */
-    void openConnection(
-        ProtobufDiscoveryNode node,
-        ProtobufConnectionProfile profile,
-        ActionListener<ProtobufTransport.Connection> listener
-    );
-
-    ProtobufTransportStats getStats();
-
-    ResponseHandlers getResponseHandlers();
-
-    RequestHandlers getRequestHandlers();
-
-    /**
-     * A unidirectional connection to a {@link ProtobufDiscoveryNode}
-    */
-    interface Connection extends Closeable {
-        /**
-         * The node this connection is associated with
-        */
-        ProtobufDiscoveryNode getNode();
-
-        /**
-         * Sends the request to the node this connection is associated with
-        * @param requestId see {@link ResponseHandlers#add(ResponseContext)} for details
-        * @param action the action to execute
-        * @param request the request to send
-        * @param options request options to apply
-        * @throws NodeNotConnectedException if the given node is not connected
-        */
-        void sendRequest(long requestId, String action, ProtobufTransportRequest request, TransportRequestOptions options)
-            throws IOException, TransportException;
-
-        /**
-         * The listener's {@link ActionListener#onResponse(Object)} method will be called when this
-        * connection is closed. No implementations currently throw an exception during close, so
-        * {@link ActionListener#onFailure(Exception)} will not be called.
-        *
-        * @param listener to be called
-        */
-        void addCloseListener(ActionListener<Void> listener);
-
-        boolean isClosed();
-
-        /**
-         * Returns the version of the node this connection was established with.
-        */
-        default Version getVersion() {
-            return getNode().getVersion();
-        }
-
-        /**
-         * Returns a key that this connection can be cached on. Delegating subclasses must delegate method call to
-        * the original connection.
-        */
-        default Object getCacheKey() {
-            return this;
-        }
-
-        @Override
-        void close();
-    }
-
-    /**
-     * This class represents a response context that encapsulates the actual response handler, the action and the connection it was
-    * executed on.
-    */
-    final class ResponseContext<T extends ProtobufTransportResponse> {
-
-        private final ProtobufTransportResponseHandler<T> handler;
-
-        private final Connection connection;
-
-        private final String action;
-
-        ResponseContext(ProtobufTransportResponseHandler<T> handler, Connection connection, String action) {
-            this.handler = handler;
-            this.connection = connection;
-            this.action = action;
-        }
-
-        public ProtobufTransportResponseHandler<T> handler() {
-            return handler;
-        }
-
-        public Connection connection() {
-            return this.connection;
-        }
-
-        public String action() {
-            return this.action;
-        }
-    }
-
-    /**
-     * This class is a registry that allows
-    */
-    final class ResponseHandlers {
-        private final ConcurrentMapLong<ResponseContext<? extends ProtobufTransportResponse>> handlers = ConcurrentCollections
-            .newConcurrentMapLongWithAggressiveConcurrency();
-        private final AtomicLong requestIdGenerator = new AtomicLong();
-
-        /**
-         * Returns <code>true</code> if the give request ID has a context associated with it.
-        */
-        public boolean contains(long requestId) {
-            return handlers.containsKey(requestId);
-        }
-
-        /**
-         * Removes and return the {@link ResponseContext} for the given request ID or returns
-        * <code>null</code> if no context is associated with this request ID.
-        */
-        public ResponseContext<? extends ProtobufTransportResponse> remove(long requestId) {
-            return handlers.remove(requestId);
-        }
-
-        /**
-         * Adds a new response context and associates it with a new request ID.
-        * @return the new request ID
-        * @see Connection#sendRequest(long, String, ProtobufTransportRequest, TransportRequestOptions)
-        */
-        public long add(ResponseContext<? extends ProtobufTransportResponse> holder) {
-            long requestId = newRequestId();
-            ResponseContext<? extends ProtobufTransportResponse> existing = handlers.put(requestId, holder);
-            assert existing == null : "request ID already in use: " + requestId;
-            return requestId;
-        }
-
-        /**
-         * Returns a new request ID to use when sending a message via {@link Connection#sendRequest(long, String,
-        * ProtobufTransportRequest, TransportRequestOptions)}
-        */
-        long newRequestId() {
-            return requestIdGenerator.incrementAndGet();
-        }
-
-        /**
-         * Removes and returns all {@link ResponseContext} instances that match the predicate
-        */
-        public List<ResponseContext<? extends ProtobufTransportResponse>> prune(
-            Predicate<ResponseContext<? extends ProtobufTransportResponse>> predicate
-        ) {
-            final List<ResponseContext<? extends ProtobufTransportResponse>> holders = new ArrayList<>();
-            for (Map.Entry<Long, ResponseContext<? extends ProtobufTransportResponse>> entry : handlers.entrySet()) {
-                ResponseContext<? extends ProtobufTransportResponse> holder = entry.getValue();
-                if (predicate.test(holder)) {
-                    ResponseContext<? extends ProtobufTransportResponse> remove = handlers.remove(entry.getKey());
-                    if (remove != null) {
-                        holders.add(holder);
-                    }
-                }
-            }
-            return holders;
-        }
-
-        /**
-         * called by the {@link ProtobufTransport} implementation when a response or an exception has been received for a previously
-        * sent request (before any processing or deserialization was done). Returns the appropriate response handler or null if not
-        * found.
-        */
-        public ProtobufTransportResponseHandler<? extends ProtobufTransportResponse> onResponseReceived(
-            final long requestId,
-            final ProtobufTransportMessageListener listener
-        ) {
-            ResponseContext<? extends ProtobufTransportResponse> context = handlers.remove(requestId);
-            // listener.onResponseReceived(requestId, context);
-            if (context == null) {
-                return null;
-            } else {
-                return context.handler();
-            }
-        }
-    }
-
-    /**
-     * Request handler implementations
-    *
-    * @opensearch.internal
-    */
-    final class RequestHandlers {
-
-        private volatile Map<String, ProtobufRequestHandlerRegistry<? extends ProtobufTransportRequest>> requestHandlers = Collections
-            .emptyMap();
-
-        synchronized <Request extends ProtobufTransportRequest> void registerHandler(ProtobufRequestHandlerRegistry<Request> reg) {
-            if (requestHandlers.containsKey(reg.getAction())) {
-                throw new IllegalArgumentException("transport handlers for action " + reg.getAction() + " is already registered");
-            }
-            requestHandlers = MapBuilder.newMapBuilder(requestHandlers).put(reg.getAction(), reg).immutableMap();
-        }
-
-        // TODO: Only visible for testing. Perhaps move StubbableTransport from
-        // org.opensearch.test.transport to org.opensearch.transport
-        public synchronized <Request extends ProtobufTransportRequest> void forceRegister(ProtobufRequestHandlerRegistry<Request> reg) {
-            requestHandlers = MapBuilder.newMapBuilder(requestHandlers).put(reg.getAction(), reg).immutableMap();
-        }
-
-        @SuppressWarnings("unchecked")
-        public <T extends ProtobufTransportRequest> ProtobufRequestHandlerRegistry<T> getHandler(String action) {
-            return (ProtobufRequestHandlerRegistry<T>) requestHandlers.get(action);
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java
index 15b51edeabd0f..22e52438a8e99 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java
@@ -10,7 +10,7 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.tasks.ProtobufTask;
 import org.opensearch.threadpool.ThreadPool;
@@ -53,7 +53,7 @@ private static class ProxyRequestHandler<T extends ProxyRequest> implements Prot
 
         @Override
         public void messageReceived(T request, ProtobufTransportChannel channel, ProtobufTask task) throws Exception {
-            ProtobufDiscoveryNode targetNode = request.targetNode;
+            DiscoveryNode targetNode = request.targetNode;
             ProtobufTransportRequest wrappedRequest = request.wrapped;
             service.sendRequest(
                 targetNode,
@@ -115,16 +115,16 @@ public String executor() {
     */
     static class ProxyRequest<T extends ProtobufTransportRequest> extends ProtobufTransportRequest {
         final T wrapped;
-        final ProtobufDiscoveryNode targetNode;
+        final DiscoveryNode targetNode;
 
-        ProxyRequest(T wrapped, ProtobufDiscoveryNode targetNode) {
+        ProxyRequest(T wrapped, DiscoveryNode targetNode) {
             this.wrapped = wrapped;
             this.targetNode = targetNode;
         }
 
         ProxyRequest(CodedInputStream in, ProtobufWriteable.Reader<T> reader) throws IOException {
             super(in);
-            targetNode = new ProtobufDiscoveryNode(in);
+            targetNode = new DiscoveryNode(in);
             wrapped = reader.read(in);
         }
 
@@ -188,7 +188,7 @@ public static String getProxyAction(String action) {
     /**
      * Wraps the actual request in a proxy request object that encodes the target node.
     */
-    public static ProtobufTransportRequest wrapRequest(ProtobufDiscoveryNode node, ProtobufTransportRequest request) {
+    public static ProtobufTransportRequest wrapRequest(DiscoveryNode node, ProtobufTransportRequest request) {
         return new ProxyRequest<>(request, node);
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java
index 30c66104145e8..228a5dfe5367e 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java
@@ -8,7 +8,7 @@
 
 package org.opensearch.transport;
 
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 
 /**
  * A listener interface that allows to react on transport events. All methods may be
@@ -34,10 +34,10 @@ default void onConnectionClosed(Transport.ProtobufConnection connection) {}
     /**
      * Called once a node connection is opened and registered.
     */
-    default void onNodeConnected(ProtobufDiscoveryNode node, Transport.ProtobufConnection connection) {}
+    default void onNodeConnected(DiscoveryNode node, Transport.ProtobufConnection connection) {}
 
     /**
      * Called once a node connection is closed and unregistered.
     */
-    default void onNodeDisconnected(ProtobufDiscoveryNode node, Transport.ProtobufConnection connection) {}
+    default void onNodeDisconnected(DiscoveryNode node, Transport.ProtobufConnection connection) {}
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportInfo.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportInfo.java
index 633955d561fad..ff3dc3bb434ad 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportInfo.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportInfo.java
@@ -20,6 +20,8 @@
 import org.opensearch.common.network.InetAddresses;
 import org.opensearch.common.transport.ProtobufBoundTransportAddress;
 import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.node.ProtobufReportingService;
 
 import java.io.IOException;
@@ -135,4 +137,24 @@ public Map<String, ProtobufBoundTransportAddress> getProfileAddresses() {
     public Map<String, ProtobufBoundTransportAddress> profileAddresses() {
         return profileAddresses;
     }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.TRANSPORT);
+        builder.array(Fields.BOUND_ADDRESS, (Object[]) address.boundAddresses());
+        builder.field(Fields.PUBLISH_ADDRESS, formatPublishAddressString("transport.publish_address", address.publishAddress()));
+        builder.startObject(Fields.PROFILES);
+        if (profileAddresses != null && profileAddresses.size() > 0) {
+            for (Map.Entry<String, ProtobufBoundTransportAddress> entry : profileAddresses.entrySet()) {
+                builder.startObject(entry.getKey());
+                builder.array(Fields.BOUND_ADDRESS, (Object[]) entry.getValue().boundAddresses());
+                String propertyName = "transport." + entry.getKey() + ".publish_address";
+                builder.field(Fields.PUBLISH_ADDRESS, formatPublishAddressString(propertyName, entry.getValue().publishAddress()));
+                builder.endObject();
+            }
+        }
+        builder.endObject();
+        builder.endObject();
+        return builder;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java
index bf109d0518693..e2624a1a16b20 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java
@@ -8,7 +8,7 @@
 
 package org.opensearch.transport;
 
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.io.stream.ProtobufWriteable.Reader;
 
 /**
@@ -35,8 +35,8 @@ default <T extends ProtobufTransportRequest> ProtobufTransportRequestHandler<T>
     /**
      * This is called up-front providing the actual low level {@link AsyncSender} that performs the low level send request.
     * The returned sender is used to send all requests that come in via
-    * {@link ProtobufTransportService#sendRequest(ProtobufDiscoveryNode, String, ProtobufTransportRequest, ProtobufTransportResponseHandler)} or
-    * {@link ProtobufTransportService#sendRequest(ProtobufDiscoveryNode, String, ProtobufTransportRequest, TransportRequestOptions, ProtobufTransportResponseHandler)}.
+    * {@link ProtobufTransportService#sendRequest(DiscoveryNode, String, ProtobufTransportRequest, ProtobufTransportResponseHandler)} or
+    * {@link ProtobufTransportService#sendRequest(DiscoveryNode, String, ProtobufTransportRequest, TransportRequestOptions, ProtobufTransportResponseHandler)}.
     * This allows plugins to perform actions on each send request including modifying the request context etc.
     */
     default AsyncSender interceptSender(AsyncSender sender) {
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java
index 5c58c2064801f..d0167c8c61570 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java
@@ -8,7 +8,7 @@
 
 package org.opensearch.transport;
 
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 
 /**
  * Listens for transport messages
@@ -53,7 +53,7 @@ default void onResponseSent(long requestId, String action, Exception error) {}
     * @param finalOptions the request options
     */
     default void onRequestSent(
-        ProtobufDiscoveryNode node,
+        DiscoveryNode node,
         long requestId,
         String action,
         ProtobufTransportRequest request,
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java
index 4b1e934977c7e..3f708b5be1a03 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java
@@ -15,11 +15,10 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.Version;
 import org.opensearch.action.ActionListener;
-import org.opensearch.action.ActionListenerResponseHandler;
 import org.opensearch.action.ProtobufActionListenerResponseHandler;
 import org.opensearch.action.support.PlainActionFuture;
-import org.opensearch.cluster.ProtobufClusterName;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.Strings;
 import org.opensearch.common.component.AbstractLifecycleComponent;
@@ -32,7 +31,8 @@
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.transport.ProtobufBoundTransportAddress;
-import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
 import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
@@ -83,10 +83,10 @@ public class ProtobufTransportService extends AbstractLifecycleComponent
     protected final Transport transport;
     protected final ProtobufConnectionManager connectionManager;
     protected final ThreadPool threadPool;
-    protected final ProtobufClusterName clusterName;
+    protected final ClusterName clusterName;
     protected final TaskManager taskManager;
     private final ProtobufTransportInterceptor.AsyncSender asyncSender;
-    private final Function<ProtobufBoundTransportAddress, ProtobufDiscoveryNode> localNodeFactory;
+    private final Function<ProtobufBoundTransportAddress, DiscoveryNode> localNodeFactory;
     private final boolean remoteClusterClient;
     private final Transport.ProtobufResponseHandlers responseHandlers;
     private final ProtobufTransportInterceptor interceptor;
@@ -115,10 +115,10 @@ protected boolean removeEldestEntry(Map.Entry eldest) {
     private final RemoteClusterService remoteClusterService;
 
     /** if set will call requests sent to this id to shortcut and executed locally */
-    volatile ProtobufDiscoveryNode localNode = null;
+    volatile DiscoveryNode localNode = null;
     private final Transport.ProtobufConnection localNodeConnection = new Transport.ProtobufConnection() {
         @Override
-        public ProtobufDiscoveryNode getNode() {
+        public DiscoveryNode getNode() {
             return localNode;
         }
 
@@ -151,7 +151,7 @@ public ProtobufTransportService(
         Transport transport,
         ThreadPool threadPool,
         ProtobufTransportInterceptor transportInterceptor,
-        Function<ProtobufBoundTransportAddress, ProtobufDiscoveryNode> localNodeFactory,
+        Function<ProtobufBoundTransportAddress, DiscoveryNode> localNodeFactory,
         @Nullable ClusterSettings clusterSettings,
         Set<String> taskHeaders
     ) {
@@ -172,7 +172,7 @@ public ProtobufTransportService(
         Transport transport,
         ThreadPool threadPool,
         ProtobufTransportInterceptor transportInterceptor,
-        Function<ProtobufBoundTransportAddress, ProtobufDiscoveryNode> localNodeFactory,
+        Function<ProtobufBoundTransportAddress, DiscoveryNode> localNodeFactory,
         @Nullable ClusterSettings clusterSettings,
         Set<String> taskHeaders,
         ProtobufConnectionManager connectionManager
@@ -182,14 +182,14 @@ public ProtobufTransportService(
         this.threadPool = threadPool;
         this.localNodeFactory = localNodeFactory;
         this.connectionManager = connectionManager;
-        this.clusterName = ProtobufClusterName.CLUSTER_NAME_SETTING.get(settings);
+        this.clusterName = ClusterName.CLUSTER_NAME_SETTING.get(settings);
         setTracerLogInclude(TransportSettings.TRACE_LOG_INCLUDE_SETTING.get(settings));
         setTracerLogExclude(TransportSettings.TRACE_LOG_EXCLUDE_SETTING.get(settings));
         tracerLog = Loggers.getLogger(logger, ".tracer");
         taskManager = createTaskManager(settings, clusterSettings, threadPool, taskHeaders);
         this.interceptor = transportInterceptor;
         this.asyncSender = interceptor.interceptSender(this::sendRequestInternal);
-        this.remoteClusterClient = ProtobufDiscoveryNode.isRemoteClusterClient(settings);
+        this.remoteClusterClient = DiscoveryNode.isRemoteClusterClient(settings);
         remoteClusterService = new RemoteClusterService(settings, this);
         responseHandlers = transport.getProtobufResponseHandlers();
         if (clusterSettings != null) {
@@ -214,7 +214,7 @@ public RemoteClusterService getRemoteClusterService() {
         return remoteClusterService;
     }
 
-    public ProtobufDiscoveryNode getLocalNode() {
+    public DiscoveryNode getLocalNode() {
         return localNode;
     }
 
@@ -263,6 +263,7 @@ protected void doStart() {
                 logger.info("profile [{}]: {}", entry.getKey(), entry.getValue());
             }
         }
+
         localNode = localNodeFactory.apply(transport.boundProtobufAddress());
 
         if (remoteClusterClient) {
@@ -271,6 +272,10 @@ protected void doStart() {
         }
     }
 
+    public void setLocalNode(DiscoveryNode localNode) {
+        this.localNode = localNode;
+    }
+
     @Override
     protected void doStop() {
         try {
@@ -363,7 +368,7 @@ public List<String> getDefaultSeedAddresses() {
     /**
      * Returns <code>true</code> iff the given node is already connected.
     */
-    public boolean nodeConnected(ProtobufDiscoveryNode node) {
+    public boolean nodeConnected(DiscoveryNode node) {
         return isLocalNode(node) || connectionManager.nodeConnected(node);
     }
 
@@ -372,12 +377,12 @@ public boolean nodeConnected(ProtobufDiscoveryNode node) {
     *
     * @param node the node to connect to
     */
-    public void connectToNode(ProtobufDiscoveryNode node) throws ProtobufConnectTransportException {
+    public void connectToNode(DiscoveryNode node) throws ProtobufConnectTransportException {
         connectToNode(node, (ProtobufConnectionProfile) null);
     }
 
     // We are skipping node validation for extensibility as extensionNode and opensearchNode(LocalNode) will have different ephemeral id's
-    public void connectToExtensionNode(final ProtobufDiscoveryNode node) {
+    public void connectToExtensionNode(final DiscoveryNode node) {
         PlainActionFuture.get(fut -> connectToExtensionNode(node, (ProtobufConnectionProfile) null, ActionListener.map(fut, x -> null)));
     }
 
@@ -387,11 +392,11 @@ public void connectToExtensionNode(final ProtobufDiscoveryNode node) {
     * @param node the node to connect to
     * @param connectionProfile the connection profile to use when connecting to this node
     */
-    public void connectToNode(final ProtobufDiscoveryNode node, ProtobufConnectionProfile connectionProfile) {
+    public void connectToNode(final DiscoveryNode node, ProtobufConnectionProfile connectionProfile) {
         PlainActionFuture.get(fut -> connectToNode(node, connectionProfile, ActionListener.map(fut, x -> null)));
     }
 
-    public void connectToExtensionNode(final ProtobufDiscoveryNode node, ProtobufConnectionProfile connectionProfile) {
+    public void connectToExtensionNode(final DiscoveryNode node, ProtobufConnectionProfile connectionProfile) {
         PlainActionFuture.get(fut -> connectToExtensionNode(node, connectionProfile, ActionListener.map(fut, x -> null)));
     }
 
@@ -402,11 +407,11 @@ public void connectToExtensionNode(final ProtobufDiscoveryNode node, ProtobufCon
     * @param node the node to connect to
     * @param listener the action listener to notify
     */
-    public void connectToNode(ProtobufDiscoveryNode node, ActionListener<Void> listener) throws ProtobufConnectTransportException {
+    public void connectToNode(DiscoveryNode node, ActionListener<Void> listener) throws ProtobufConnectTransportException {
         connectToNode(node, null, listener);
     }
 
-    public void connectToExtensionNode(ProtobufDiscoveryNode node, ActionListener<Void> listener) throws ProtobufConnectTransportException {
+    public void connectToExtensionNode(DiscoveryNode node, ActionListener<Void> listener) throws ProtobufConnectTransportException {
         connectToExtensionNode(node, null, listener);
     }
 
@@ -418,11 +423,7 @@ public void connectToExtensionNode(ProtobufDiscoveryNode node, ActionListener<Vo
     * @param connectionProfile the connection profile to use when connecting to this node
     * @param listener the action listener to notify
     */
-    public void connectToNode(
-        final ProtobufDiscoveryNode node,
-        ProtobufConnectionProfile connectionProfile,
-        ActionListener<Void> listener
-    ) {
+    public void connectToNode(final DiscoveryNode node, ProtobufConnectionProfile connectionProfile, ActionListener<Void> listener) {
         if (isLocalNode(node)) {
             listener.onResponse(null);
             return;
@@ -431,7 +432,7 @@ public void connectToNode(
     }
 
     public void connectToExtensionNode(
-        final ProtobufDiscoveryNode node,
+        final DiscoveryNode node,
         ProtobufConnectionProfile connectionProfile,
         ActionListener<Void> listener
     ) {
@@ -442,11 +443,11 @@ public void connectToExtensionNode(
         connectionManager.connectToNode(node, connectionProfile, extensionConnectionValidator(node), listener);
     }
 
-    public ProtobufConnectionManager.ConnectionValidator connectionValidator(ProtobufDiscoveryNode node) {
+    public ProtobufConnectionManager.ConnectionValidator connectionValidator(DiscoveryNode node) {
         return (newConnection, actualProfile, listener) -> {
             // We don't validate cluster names to allow for CCS connections.
             handshake(newConnection, actualProfile.getHandshakeTimeout().millis(), cn -> true, ActionListener.map(listener, resp -> {
-                final ProtobufDiscoveryNode remote = resp.discoveryNode;
+                final DiscoveryNode remote = resp.discoveryNode;
 
                 if (node.equals(remote) == false) {
                     throw new ProtobufConnectTransportException(node, "handshake failed. unexpected remote node " + remote);
@@ -457,11 +458,11 @@ public ProtobufConnectionManager.ConnectionValidator connectionValidator(Protobu
         };
     }
 
-    public ProtobufConnectionManager.ConnectionValidator extensionConnectionValidator(ProtobufDiscoveryNode node) {
+    public ProtobufConnectionManager.ConnectionValidator extensionConnectionValidator(DiscoveryNode node) {
         return (newConnection, actualProfile, listener) -> {
             // We don't validate cluster names to allow for CCS connections.
             handshake(newConnection, actualProfile.getHandshakeTimeout().millis(), cn -> true, ActionListener.map(listener, resp -> {
-                final ProtobufDiscoveryNode remote = resp.discoveryNode;
+                final DiscoveryNode remote = resp.discoveryNode;
                 logger.info("Connection validation was skipped");
                 return null;
             }));
@@ -475,7 +476,7 @@ public ProtobufConnectionManager.ConnectionValidator extensionConnectionValidato
     * @param node the node to connect to
     * @param connectionProfile the connection profile to use
     */
-    public Transport.ProtobufConnection openConnection(final ProtobufDiscoveryNode node, ProtobufConnectionProfile connectionProfile) {
+    public Transport.ProtobufConnection openConnection(final DiscoveryNode node, ProtobufConnectionProfile connectionProfile) {
         return PlainActionFuture.get(fut -> openConnection(node, connectionProfile, fut));
     }
 
@@ -488,7 +489,7 @@ public Transport.ProtobufConnection openConnection(final ProtobufDiscoveryNode n
     * @param listener the action listener to notify
     */
     public void openConnection(
-        final ProtobufDiscoveryNode node,
+        final DiscoveryNode node,
         ProtobufConnectionProfile connectionProfile,
         ActionListener<Transport.ProtobufConnection> listener
     ) {
@@ -515,7 +516,7 @@ public void openConnection(
     public void handshake(
         final Transport.ProtobufConnection connection,
         final long handshakeTimeout,
-        final ActionListener<ProtobufDiscoveryNode> listener
+        final ActionListener<DiscoveryNode> listener
     ) {
         handshake(
             connection,
@@ -541,10 +542,10 @@ public void handshake(
     public void handshake(
         final Transport.ProtobufConnection connection,
         final long handshakeTimeout,
-        Predicate<ProtobufClusterName> clusterNamePredicate,
+        Predicate<ClusterName> clusterNamePredicate,
         final ActionListener<HandshakeResponse> listener
     ) {
-        final ProtobufDiscoveryNode node = connection.getNode();
+        final DiscoveryNode node = connection.getNode();
         sendRequest(
             connection,
             HANDSHAKE_ACTION_NAME,
@@ -616,11 +617,11 @@ private HandshakeRequest() {}
     * @opensearch.internal
     */
     public static class HandshakeResponse extends ProtobufTransportResponse {
-        private final ProtobufDiscoveryNode discoveryNode;
-        private final ProtobufClusterName clusterName;
+        private final DiscoveryNode discoveryNode;
+        private final ClusterName clusterName;
         private final Version version;
 
-        public HandshakeResponse(ProtobufDiscoveryNode discoveryNode, ProtobufClusterName clusterName, Version version) {
+        public HandshakeResponse(DiscoveryNode discoveryNode, ClusterName clusterName, Version version) {
             this.discoveryNode = discoveryNode;
             this.version = version;
             this.clusterName = clusterName;
@@ -629,8 +630,8 @@ public HandshakeResponse(ProtobufDiscoveryNode discoveryNode, ProtobufClusterNam
         public HandshakeResponse(CodedInputStream in) throws IOException {
             super(in);
             ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-            discoveryNode = protobufStreamInput.readOptionalWriteable(ProtobufDiscoveryNode::new);
-            clusterName = new ProtobufClusterName(in);
+            discoveryNode = protobufStreamInput.readOptionalWriteable(DiscoveryNode::new);
+            clusterName = new ClusterName(in);
             version = Version.readVersionProtobuf(in);
         }
 
@@ -642,16 +643,16 @@ public void writeTo(CodedOutputStream out) throws IOException {
             out.writeInt32NoTag(version.id);
         }
 
-        public ProtobufDiscoveryNode getDiscoveryNode() {
+        public DiscoveryNode getDiscoveryNode() {
             return discoveryNode;
         }
 
-        public ProtobufClusterName getClusterName() {
+        public ClusterName getClusterName() {
             return clusterName;
         }
     }
 
-    public void disconnectFromNode(ProtobufDiscoveryNode node) {
+    public void disconnectFromNode(DiscoveryNode node) {
         if (isLocalNode(node)) {
             return;
         }
@@ -675,7 +676,7 @@ public void removeConnectionListener(ProtobufTransportConnectionListener listene
     }
 
     public <T extends ProtobufTransportResponse> TransportFuture<T> submitRequest(
-        ProtobufDiscoveryNode node,
+        DiscoveryNode node,
         String action,
         ProtobufTransportRequest request,
         ProtobufTransportResponseHandler<T> handler
@@ -684,7 +685,7 @@ public <T extends ProtobufTransportResponse> TransportFuture<T> submitRequest(
     }
 
     public <T extends ProtobufTransportResponse> TransportFuture<T> submitRequest(
-        ProtobufDiscoveryNode node,
+        DiscoveryNode node,
         String action,
         ProtobufTransportRequest request,
         TransportRequestOptions options,
@@ -702,7 +703,7 @@ public <T extends ProtobufTransportResponse> TransportFuture<T> submitRequest(
     }
 
     public <T extends ProtobufTransportResponse> void sendRequest(
-        final ProtobufDiscoveryNode node,
+        final DiscoveryNode node,
         final String action,
         final ProtobufTransportRequest request,
         final ProtobufTransportResponseHandler<T> handler
@@ -719,7 +720,7 @@ public <T extends ProtobufTransportResponse> void sendRequest(
     }
 
     public final <T extends ProtobufTransportResponse> void sendRequest(
-        final ProtobufDiscoveryNode node,
+        final DiscoveryNode node,
         final String action,
         final ProtobufTransportRequest request,
         final TransportRequestOptions options,
@@ -758,7 +759,10 @@ public final <T extends ProtobufTransportResponse> void sendRequest(
             final ProtobufTransportResponseHandler<T> delegate;
             if (request.getParentTask().isSet()) {
                 // TODO: capture the connection instead so that we can cancel child tasks on the remote connections.
-                final Releasable unregisterChildNode = taskManager.registerProtobufChildNode(request.getParentTask().getId(), connection.getNode());
+                final Releasable unregisterChildNode = taskManager.registerProtobufChildNode(
+                    request.getParentTask().getId(),
+                    connection.getNode()
+                );
                 delegate = new ProtobufTransportResponseHandler<T>() {
                     @Override
                     public void handleResponse(T response) {
@@ -807,7 +811,7 @@ public String toString() {
      * Returns either a real transport connection or a local node connection if we are using the local node optimization.
     * @throws ProtobufNodeNotConnectedException if the given node is not connected
     */
-    public Transport.ProtobufConnection getConnection(ProtobufDiscoveryNode node) {
+    public Transport.ProtobufConnection getConnection(DiscoveryNode node) {
         if (isLocalNode(node)) {
             return localNodeConnection;
         } else {
@@ -816,7 +820,7 @@ public Transport.ProtobufConnection getConnection(ProtobufDiscoveryNode node) {
     }
 
     public final <T extends ProtobufTransportResponse> void sendChildRequest(
-        final ProtobufDiscoveryNode node,
+        final DiscoveryNode node,
         final String action,
         final ProtobufTransportRequest request,
         final ProtobufTask parentTask,
@@ -866,7 +870,7 @@ private <T extends ProtobufTransportResponse> void sendRequestInternal(
         if (connection == null) {
             throw new IllegalStateException("can't send request to a null connection");
         }
-        ProtobufDiscoveryNode node = connection.getNode();
+        DiscoveryNode node = connection.getNode();
 
         Supplier<ThreadContext.StoredContext> storedContextSupplier = threadPool.getThreadContext().newRestorableContext(true);
         ContextRestoreResponseHandler<T> responseHandler = new ContextRestoreResponseHandler<>(storedContextSupplier, handler);
@@ -1024,8 +1028,8 @@ public static boolean shouldTraceAction(String action, String[] include, String[
         return true;
     }
 
-    public ProtobufTransportAddress[] addressesFromString(String address) throws UnknownHostException {
-        return transport.addressesFromStringProtobuf(address);
+    public TransportAddress[] addressesFromString(String address) throws UnknownHostException {
+        return transport.addressesFromString(address);
     }
 
     /**
@@ -1149,7 +1153,7 @@ public void onRequestReceived(long requestId, String action) {
     /** called by the {@link Transport} implementation once a request has been sent */
     @Override
     public void onRequestSent(
-        ProtobufDiscoveryNode node,
+        DiscoveryNode node,
         long requestId,
         String action,
         ProtobufTransportRequest request,
@@ -1195,7 +1199,7 @@ public ProtobufRequestHandlerRegistry<? extends ProtobufTransportRequest> getReq
 
     private void checkForTimeout(long requestId) {
         // lets see if its in the timeout holder, but sync on mutex to make sure any ongoing timeout handling has finished
-        final ProtobufDiscoveryNode sourceNode;
+        final DiscoveryNode sourceNode;
         final String action;
         assert responseHandlers.contains(requestId) == false;
         TimeoutInfoHolder timeoutInfoHolder = timeoutInfoHandlers.remove(requestId);
@@ -1261,10 +1265,10 @@ final class TimeoutHandler implements Runnable {
         private final long requestId;
         private final long sentTime = threadPool.relativeTimeInMillis();
         private final String action;
-        private final ProtobufDiscoveryNode node;
+        private final DiscoveryNode node;
         volatile Scheduler.Cancellable cancellable;
 
-        TimeoutHandler(long requestId, ProtobufDiscoveryNode node, String action) {
+        TimeoutHandler(long requestId, DiscoveryNode node, String action) {
             this.requestId = requestId;
             this.node = node;
             this.action = action;
@@ -1325,19 +1329,19 @@ private void scheduleTimeout(TimeValue timeout) {
     */
     static class TimeoutInfoHolder {
 
-        private final ProtobufDiscoveryNode node;
+        private final DiscoveryNode node;
         private final String action;
         private final long sentTime;
         private final long timeoutTime;
 
-        TimeoutInfoHolder(ProtobufDiscoveryNode node, String action, long sentTime, long timeoutTime) {
+        TimeoutInfoHolder(DiscoveryNode node, String action, long sentTime, long timeoutTime) {
             this.node = node;
             this.action = action;
             this.sentTime = sentTime;
             this.timeoutTime = timeoutTime;
         }
 
-        public ProtobufDiscoveryNode node() {
+        public DiscoveryNode node() {
             return node;
         }
 
@@ -1421,14 +1425,14 @@ void setTimeoutHandler(TimeoutHandler handler) {
     * @opensearch.internal
     */
     static class DirectResponseChannel implements ProtobufTransportChannel {
-        final ProtobufDiscoveryNode localNode;
+        final DiscoveryNode localNode;
         private final String action;
         private final long requestId;
         final ProtobufTransportService service;
         final ThreadPool threadPool;
 
         DirectResponseChannel(
-            ProtobufDiscoveryNode localNode,
+            DiscoveryNode localNode,
             String action,
             long requestId,
             ProtobufTransportService service,
@@ -1510,7 +1514,7 @@ protected ProtobufRemoteTransportException wrapInRemote(Exception e) {
             if (e instanceof ProtobufRemoteTransportException) {
                 return (ProtobufRemoteTransportException) e;
             }
-            return new ProtobufRemoteTransportException(localNode.getName(), localNode.getAddress(), action, e);
+            return new ProtobufRemoteTransportException(localNode.getName(), localNode.getProtobufAddress(), action, e);
         }
 
         protected void processException(final ProtobufTransportResponseHandler handler, final ProtobufRemoteTransportException rtx) {
@@ -1542,7 +1546,7 @@ public ThreadPool getThreadPool() {
         return threadPool;
     }
 
-    private boolean isLocalNode(ProtobufDiscoveryNode discoveryNode) {
+    private boolean isLocalNode(DiscoveryNode discoveryNode) {
         return Objects.requireNonNull(discoveryNode, "discovery node must not be null").equals(localNode);
     }
 
@@ -1573,7 +1577,7 @@ public void onResponseSent(long requestId, String action, Exception error) {
 
         @Override
         public void onRequestSent(
-            ProtobufDiscoveryNode node,
+            DiscoveryNode node,
             long requestId,
             String action,
             ProtobufTransportRequest request,
diff --git a/server/src/main/java/org/opensearch/transport/RemoteClusterService.java b/server/src/main/java/org/opensearch/transport/RemoteClusterService.java
index ae4a98b04fdef..5ed96e9d85943 100644
--- a/server/src/main/java/org/opensearch/transport/RemoteClusterService.java
+++ b/server/src/main/java/org/opensearch/transport/RemoteClusterService.java
@@ -42,7 +42,7 @@
 import org.opensearch.client.ProtobufClient;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.Strings;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
@@ -164,7 +164,7 @@ public boolean isEnabled() {
 
     RemoteClusterService(Settings settings, ProtobufTransportService transportService) {
         super(settings);
-        this.enabled = ProtobufDiscoveryNode.isRemoteClusterClient(settings);
+        this.enabled = DiscoveryNode.isRemoteClusterClient(settings);
         this.protobufTransportService = transportService;
         this.transportService = null;
     }
@@ -236,7 +236,7 @@ public Transport.Connection getConnection(DiscoveryNode node, String cluster) {
      *
      * @throws IllegalArgumentException if the remote cluster is unknown
      */
-    public Transport.ProtobufConnection getConnectionProtobuf(ProtobufDiscoveryNode node, String cluster) {
+    public Transport.ProtobufConnection getConnectionProtobuf(DiscoveryNode node, String cluster) {
         return getRemoteClusterConnectionProtobuf(cluster).getConnection(node);
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/TcpTransport.java b/server/src/main/java/org/opensearch/transport/TcpTransport.java
index a72ba2b78fef6..07fd66367b8c5 100644
--- a/server/src/main/java/org/opensearch/transport/TcpTransport.java
+++ b/server/src/main/java/org/opensearch/transport/TcpTransport.java
@@ -39,7 +39,7 @@
 import org.opensearch.action.ActionListener;
 import org.opensearch.action.support.ThreadedActionListener;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.Booleans;
 import org.opensearch.core.common.breaker.CircuitBreaker;
 import org.opensearch.core.common.bytes.BytesArray;
@@ -138,6 +138,7 @@ public abstract class TcpTransport extends AbstractLifecycleComponent implements
     private final CircuitBreakerService circuitBreakerService;
 
     private final ConcurrentMap<String, BoundTransportAddress> profileBoundAddresses = newConcurrentMap();
+    private final ConcurrentMap<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses = newConcurrentMap();
     private final Map<String, List<TcpServerChannel>> serverChannels = newConcurrentMap();
     private final Set<TcpChannel> acceptedChannels = ConcurrentCollections.newConcurrentSet();
 
@@ -145,6 +146,7 @@ public abstract class TcpTransport extends AbstractLifecycleComponent implements
     // connections while no connect operations is going on
     private final ReadWriteLock closeLock = new ReentrantReadWriteLock();
     private volatile BoundTransportAddress boundAddress;
+    private volatile ProtobufBoundTransportAddress protobufBoundAddress;
 
     private final TransportHandshaker handshaker;
     private final TransportKeepAlive keepAlive;
@@ -398,6 +400,16 @@ public Map<String, BoundTransportAddress> profileBoundAddresses() {
         return unmodifiableMap(new HashMap<>(profileBoundAddresses));
     }
 
+    @Override
+    public ProtobufBoundTransportAddress boundProtobufAddress() {
+        return this.protobufBoundAddress;
+    }
+
+    @Override
+    public Map<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses() {
+        return unmodifiableMap(new HashMap<>(profileProtobufBoundAddresses));
+    }
+
     @Override
     public List<String> getDefaultSeedAddresses() {
         List<String> local = new ArrayList<>();
@@ -436,11 +448,14 @@ protected void bindServer(ProfileSettings profileSettings) {
         }
 
         final BoundTransportAddress boundTransportAddress = createBoundTransportAddress(profileSettings, boundAddresses);
+        final ProtobufBoundTransportAddress protobufBoundTransportAddress = createProtobufBoundTransportAddress(boundTransportAddress);
 
         if (profileSettings.isDefaultProfile) {
             this.boundAddress = boundTransportAddress;
+            this.protobufBoundAddress = protobufBoundTransportAddress;
         } else {
             profileBoundAddresses.put(profileSettings.profileName, boundTransportAddress);
+            profileProtobufBoundAddresses.put(profileSettings.profileName, protobufBoundTransportAddress);
         }
     }
 
@@ -510,6 +525,43 @@ private BoundTransportAddress createBoundTransportAddress(ProfileSettings profil
         return new BoundTransportAddress(transportBoundAddresses, publishAddress);
     }
 
+    private ProtobufBoundTransportAddress createProtobufBoundTransportAddress(BoundTransportAddress boundTransportAddress) {
+        TransportAddress[] transportBoundAddresses = boundTransportAddress.boundAddresses();
+        TransportAddress publishAddress = boundTransportAddress.publishAddress();
+        ProtobufTransportAddress[] transportBoundAddressesProtobuf = new ProtobufTransportAddress[transportBoundAddresses.length];
+        for (int i = 0; i < transportBoundAddresses.length; i++) {
+            transportBoundAddressesProtobuf[i] = new ProtobufTransportAddress(transportBoundAddresses[i].address());
+        }
+        return new ProtobufBoundTransportAddress(transportBoundAddressesProtobuf, new ProtobufTransportAddress(publishAddress.address()));
+        // String[] boundAddressesHostStrings = new String[boundAddresses.size()];
+        // ProtobufTransportAddress[] transportBoundAddresses = new ProtobufTransportAddress[boundAddresses.size()];
+        // for (int i = 0; i < boundAddresses.size(); i++) {
+        // InetSocketAddress boundAddress = boundAddresses.get(i);
+        // boundAddressesHostStrings[i] = boundAddress.getHostString();
+        // transportBoundAddresses[i] = new ProtobufTransportAddress(boundAddress);
+        // }
+
+        // List<String> publishHosts = profileSettings.publishHosts;
+        // if (profileSettings.isDefaultProfile == false && publishHosts.isEmpty()) {
+        // publishHosts = Arrays.asList(boundAddressesHostStrings);
+        // }
+        // if (publishHosts.isEmpty()) {
+        // publishHosts = NetworkService.GLOBAL_NETWORK_PUBLISH_HOST_SETTING.get(settings);
+        // }
+
+        // final InetAddress publishInetAddress;
+        // try {
+        // publishInetAddress = networkService.resolvePublishHostAddresses(publishHosts.toArray(Strings.EMPTY_ARRAY));
+        // } catch (Exception e) {
+        // throw new BindTransportException("Failed to resolve publish address", e);
+        // }
+
+        // final int publishPort = resolvePublishPort(profileSettings, boundAddresses, publishInetAddress);
+        // final ProtobufTransportAddress publishAddress = new ProtobufTransportAddress(new InetSocketAddress(publishInetAddress,
+        // publishPort));
+        // return new ProtobufBoundTransportAddress(transportBoundAddresses, publishAddress);
+    }
+
     // package private for tests
     static int resolvePublishPort(ProfileSettings profileSettings, List<InetSocketAddress> boundAddresses, InetAddress publishInetAddress) {
         int publishPort = profileSettings.publishPort;
@@ -1022,20 +1074,8 @@ public final RequestHandlers getRequestHandlers() {
 
     @Override
     public void setMessageListener(ProtobufTransportMessageListener listener) {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'setMessageListener'");
-    }
-
-    @Override
-    public ProtobufBoundTransportAddress boundProtobufAddress() {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'boundProtobufAddress'");
-    }
-
-    @Override
-    public Map<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses() {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'profileProtobufBoundAddresses'");
+        outboundHandler.setProtobufMessageListener(listener);
+        inboundHandler.setProtobufMessageListener(listener);
     }
 
     @Override
@@ -1045,8 +1085,7 @@ public ProtobufTransportAddress[] addressesFromStringProtobuf(String address) th
     }
 
     @Override
-    public void openProtobufConnection(ProtobufDiscoveryNode node, ProtobufConnectionProfile profile,
-            ActionListener<ProtobufConnection> listener) {
+    public void openProtobufConnection(DiscoveryNode node, ProtobufConnectionProfile profile, ActionListener<ProtobufConnection> listener) {
         // TODO Auto-generated method stub
         throw new UnsupportedOperationException("Unimplemented method 'openProtobufConnection'");
     }
diff --git a/server/src/main/java/org/opensearch/transport/Transport.java b/server/src/main/java/org/opensearch/transport/Transport.java
index 079934562a03d..09c8cc1334147 100644
--- a/server/src/main/java/org/opensearch/transport/Transport.java
+++ b/server/src/main/java/org/opensearch/transport/Transport.java
@@ -35,7 +35,7 @@
 import org.opensearch.Version;
 import org.opensearch.action.ActionListener;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.collect.MapBuilder;
 import org.opensearch.common.lifecycle.LifecycleComponent;
 import org.opensearch.common.transport.BoundTransportAddress;
@@ -119,7 +119,6 @@ default boolean isSecure() {
     */
     ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException;
 
-
     /**
      * Returns a list of all local addresses for this transport
      */
@@ -136,7 +135,7 @@ default boolean isSecure() {
      * The ActionListener will be called on the calling thread or the generic thread pool.
      */
     void openProtobufConnection(
-        ProtobufDiscoveryNode node,
+        DiscoveryNode node,
         ProtobufConnectionProfile profile,
         ActionListener<Transport.ProtobufConnection> listener
     );
@@ -204,13 +203,13 @@ default Object getCacheKey() {
     }
 
     /**
-     * A unidirectional connection to a {@link ProtobufDiscoveryNode}
+     * A unidirectional connection to a {@link DiscoveryNode}
     */
     interface ProtobufConnection extends Closeable {
         /**
          * The node this connection is associated with
         */
-        ProtobufDiscoveryNode getNode();
+        DiscoveryNode getNode();
 
         /**
          * Sends the request to the node this connection is associated with
@@ -484,8 +483,8 @@ final class RequestHandlers {
 
         private volatile Map<String, RequestHandlerRegistry<? extends TransportRequest>> requestHandlers = Collections.emptyMap();
 
-        private volatile Map<String, ProtobufRequestHandlerRegistry<? extends ProtobufTransportRequest>> protobufRequestHandlers = Collections
-            .emptyMap();
+        private volatile Map<String, ProtobufRequestHandlerRegistry<? extends ProtobufTransportRequest>> protobufRequestHandlers =
+            Collections.emptyMap();
 
         synchronized <Request extends TransportRequest> void registerHandler(RequestHandlerRegistry<Request> reg) {
             if (requestHandlers.containsKey(reg.getAction())) {
diff --git a/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java b/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java
index a284269dc4151..27832c3c633ec 100644
--- a/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java
@@ -49,6 +49,8 @@
 import org.opensearch.common.lifecycle.LifecycleListener;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.MockLogAppender;
@@ -57,6 +59,10 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ConnectTransportException;
 import org.opensearch.transport.ConnectionProfile;
+import org.opensearch.transport.ProtobufConnectionProfile;
+import org.opensearch.transport.ProtobufTransportMessageListener;
+import org.opensearch.transport.ProtobufTransportRequest;
+import org.opensearch.transport.ProtobufTransportStats;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportMessageListener;
@@ -67,6 +73,7 @@
 import org.junit.After;
 import org.junit.Before;
 
+import java.net.UnknownHostException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
@@ -592,6 +599,8 @@ public void connectToNode(DiscoveryNode node, ActionListener<Void> listener) thr
     private static final class MockTransport implements Transport {
         private final ResponseHandlers responseHandlers = new ResponseHandlers();
         private final RequestHandlers requestHandlers = new RequestHandlers();
+        private final ProtobufResponseHandlers protobufResponseHandlers = new ProtobufResponseHandlers();
+        private final ProtobufRequestHandlers protobufRequestHandlers = new ProtobufRequestHandlers();
         private volatile boolean randomConnectionExceptions = false;
         private final ThreadPool threadPool;
 
@@ -685,5 +694,75 @@ public ResponseHandlers getResponseHandlers() {
         public RequestHandlers getRequestHandlers() {
             return requestHandlers;
         }
+
+        @Override
+        public void setMessageListener(ProtobufTransportMessageListener listener) {}
+
+        @Override
+        public ProtobufBoundTransportAddress boundProtobufAddress() {
+            return null;
+        }
+
+        @Override
+        public Map<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses() {
+            return null;
+        }
+
+        @Override
+        public ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException {
+            return new ProtobufTransportAddress[0];
+        }
+
+        @Override
+        public void openProtobufConnection(
+            DiscoveryNode node,
+            ProtobufConnectionProfile profile,
+            ActionListener<ProtobufConnection> listener
+        ) {
+            if (profile == null && randomConnectionExceptions && randomBoolean()) {
+                threadPool.generic().execute(() -> listener.onFailure(new ConnectTransportException(node, "simulated")));
+            } else {
+                threadPool.generic().execute(() -> listener.onResponse(new ProtobufConnection() {
+                    @Override
+                    public DiscoveryNode getNode() {
+                        return node;
+                    }
+
+                    @Override
+                    public void sendRequest(
+                        long requestId,
+                        String action,
+                        ProtobufTransportRequest request,
+                        TransportRequestOptions options
+                    ) throws TransportException {}
+
+                    @Override
+                    public void addCloseListener(ActionListener<Void> listener) {}
+
+                    @Override
+                    public void close() {}
+
+                    @Override
+                    public boolean isClosed() {
+                        return false;
+                    }
+                }));
+            }
+        }
+
+        @Override
+        public ProtobufTransportStats getProtobufStats() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public ProtobufResponseHandlers getProtobufResponseHandlers() {
+            return protobufResponseHandlers;
+        }
+
+        @Override
+        public ProtobufRequestHandlers getProtobufRequestHandlers() {
+            return protobufRequestHandlers;
+        }
     }
 }
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/NoOpClusterApplier.java b/server/src/test/java/org/opensearch/cluster/coordination/NoOpClusterApplier.java
index 9b865ace3b082..420223fa35178 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/NoOpClusterApplier.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/NoOpClusterApplier.java
@@ -32,6 +32,7 @@
 package org.opensearch.cluster.coordination;
 
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.ProtobufClusterState;
 import org.opensearch.cluster.service.ClusterApplier;
 
 import java.util.function.Supplier;
@@ -46,4 +47,9 @@ public void setInitialState(ClusterState initialState) {
     public void onNewClusterState(String source, Supplier<ClusterState> clusterStateSupplier, ClusterApplyListener listener) {
         listener.onSuccess(source);
     }
+
+    @Override
+    public void setInitialProtobufState(ProtobufClusterState initialState) {
+
+    }
 }
diff --git a/server/src/test/java/org/opensearch/common/network/NetworkModuleTests.java b/server/src/test/java/org/opensearch/common/network/NetworkModuleTests.java
index f795df2f48b22..f52efbe0c5848 100644
--- a/server/src/test/java/org/opensearch/common/network/NetworkModuleTests.java
+++ b/server/src/test/java/org/opensearch/common/network/NetworkModuleTests.java
@@ -45,6 +45,8 @@
 import org.opensearch.http.HttpServerTransport;
 import org.opensearch.http.HttpStats;
 import org.opensearch.http.NullDispatcher;
+import org.opensearch.http.ProtobufHttpInfo;
+import org.opensearch.http.ProtobufHttpStats;
 import org.opensearch.core.indices.breaker.CircuitBreakerService;
 import org.opensearch.plugins.NetworkPlugin;
 import org.opensearch.test.OpenSearchTestCase;
@@ -103,6 +105,16 @@ public HttpInfo info() {
         public HttpStats stats() {
             return null;
         }
+
+        @Override
+        public ProtobufHttpInfo protobufInfo() {
+            return null;
+        }
+
+        @Override
+        public ProtobufHttpStats protobufStats() {
+            return null;
+        }
     }
 
     public void testRegisterTransport() {
diff --git a/server/src/test/java/org/opensearch/rest/RestControllerTests.java b/server/src/test/java/org/opensearch/rest/RestControllerTests.java
index 25a8637479ec5..1d54ff6012da9 100644
--- a/server/src/test/java/org/opensearch/rest/RestControllerTests.java
+++ b/server/src/test/java/org/opensearch/rest/RestControllerTests.java
@@ -54,6 +54,8 @@
 import org.opensearch.http.HttpServerTransport;
 import org.opensearch.http.HttpStats;
 import org.opensearch.identity.IdentityService;
+import org.opensearch.http.ProtobufHttpInfo;
+import org.opensearch.http.ProtobufHttpStats;
 import org.opensearch.indices.breaker.HierarchyCircuitBreakerService;
 import org.opensearch.rest.action.admin.indices.RestCreateIndexAction;
 import org.opensearch.test.OpenSearchTestCase;
@@ -228,7 +230,7 @@ public void testRegisterAsDeprecatedHandler() {
 
         controller.registerAsDeprecatedHandler(method, path, handler, deprecationMessage);
 
-        verify(controller).registerProtobufHandler(eq(method), eq(path), any(DeprecationRestHandler.class));
+        verify(controller).registerHandler(eq(method), eq(path), any(DeprecationRestHandler.class));
     }
 
     public void testRegisterWithDeprecatedHandler() {
@@ -255,7 +257,7 @@ public void testRegisterWithDeprecatedHandler() {
 
         controller.registerWithDeprecatedHandler(method, path, handler, deprecatedMethod, deprecatedPath);
 
-        verify(controller).registerProtobufHandler(method, path, handler);
+        verify(controller).registerHandler(method, path, handler);
         verify(controller).registerAsDeprecatedHandler(deprecatedMethod, deprecatedPath, handler, deprecationMessage);
     }
 
@@ -691,6 +693,16 @@ public HttpInfo info() {
         public HttpStats stats() {
             return null;
         }
+
+        @Override
+        public ProtobufHttpInfo protobufInfo() {
+            return null;
+        }
+
+        @Override
+        public ProtobufHttpStats protobufStats() {
+            return null;
+        }
     }
 
     public static final class AssertingChannel extends AbstractRestChannel {
diff --git a/server/src/test/java/org/opensearch/test/NoopDiscovery.java b/server/src/test/java/org/opensearch/test/NoopDiscovery.java
index f7365d7d71693..5779ebd03aabd 100644
--- a/server/src/test/java/org/opensearch/test/NoopDiscovery.java
+++ b/server/src/test/java/org/opensearch/test/NoopDiscovery.java
@@ -37,6 +37,7 @@
 import org.opensearch.common.lifecycle.LifecycleListener;
 import org.opensearch.discovery.Discovery;
 import org.opensearch.discovery.DiscoveryStats;
+import org.opensearch.discovery.ProtobufDiscoveryStats;
 
 public class NoopDiscovery implements Discovery {
 
@@ -78,4 +79,9 @@ public void stop() {}
 
     @Override
     public void close() {}
+
+    @Override
+    public ProtobufDiscoveryStats protobufStats() {
+        return null;
+    }
 }
diff --git a/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java b/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java
index e156449adc184..51a9ee248e1ca 100644
--- a/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java
@@ -34,10 +34,14 @@
 
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
 import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.http.HttpInfo;
 import org.opensearch.http.HttpServerTransport;
 import org.opensearch.http.HttpStats;
+import org.opensearch.http.ProtobufHttpInfo;
+import org.opensearch.http.ProtobufHttpStats;
 import org.opensearch.plugins.Plugin;
 
 /**
@@ -57,8 +61,18 @@ public static class TestPlugin extends Plugin {}
         new TransportAddress[] { DUMMY_TRANSPORT_ADDRESS },
         DUMMY_TRANSPORT_ADDRESS
     );
+    private static final ProtobufTransportAddress DUMMY_PROTOBUF_TRANSPORT_ADDRESS = new ProtobufTransportAddress(
+        ProtobufTransportAddress.META_ADDRESS,
+        0
+    );
+    private static final ProtobufBoundTransportAddress DUMMY_PROTOBUF_BOUND_ADDRESS = new ProtobufBoundTransportAddress(
+        new ProtobufTransportAddress[] { DUMMY_PROTOBUF_TRANSPORT_ADDRESS },
+        DUMMY_PROTOBUF_TRANSPORT_ADDRESS
+    );
     private static final HttpInfo DUMMY_HTTP_INFO = new HttpInfo(DUMMY_BOUND_ADDRESS, 0);
     private static final HttpStats DUMMY_HTTP_STATS = new HttpStats(0, 0);
+    private static final ProtobufHttpInfo DUMMY_PROTOBUF_HTTP_INFO = new ProtobufHttpInfo(DUMMY_PROTOBUF_BOUND_ADDRESS, 0);
+    private static final ProtobufHttpStats DUMMY_PROTOBUF_HTTP_STATS = new ProtobufHttpStats(0, 0);
 
     @Override
     protected void doStart() {}
@@ -83,4 +97,14 @@ public HttpInfo info() {
     public HttpStats stats() {
         return DUMMY_HTTP_STATS;
     }
+
+    @Override
+    public ProtobufHttpInfo protobufInfo() {
+        return DUMMY_PROTOBUF_HTTP_INFO;
+    }
+
+    @Override
+    public ProtobufHttpStats protobufStats() {
+        return DUMMY_PROTOBUF_HTTP_STATS;
+    }
 }
diff --git a/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java b/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
index b70a143cff948..42e9ae078dae8 100644
--- a/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
@@ -34,7 +34,7 @@
 
 import org.opensearch.action.ActionListener;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
 import org.opensearch.common.transport.BoundTransportAddress;
 import org.opensearch.common.transport.ProtobufBoundTransportAddress;
@@ -163,8 +163,7 @@ public ProtobufTransportAddress[] addressesFromStringProtobuf(String address) th
     }
 
     @Override
-    public void openProtobufConnection(ProtobufDiscoveryNode node, ProtobufConnectionProfile profile,
-            ActionListener<ProtobufConnection> listener) {
+    public void openProtobufConnection(DiscoveryNode node, ProtobufConnectionProfile profile, ActionListener<ProtobufConnection> listener) {
         // TODO Auto-generated method stub
         throw new UnsupportedOperationException("Unimplemented method 'openProtobufConnection'");
     }
diff --git a/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java b/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
index 9770e9e93d1e6..11ef579a3ac42 100644
--- a/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
@@ -35,7 +35,7 @@
 import org.opensearch.Version;
 import org.opensearch.action.ActionListener;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.ProtobufDiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.lifecycle.Lifecycle;
 import org.opensearch.common.lifecycle.LifecycleListener;
 import org.opensearch.common.transport.BoundTransportAddress;
@@ -342,8 +342,7 @@ public ProtobufTransportAddress[] addressesFromStringProtobuf(String address) th
     }
 
     @Override
-    public void openProtobufConnection(ProtobufDiscoveryNode node, ProtobufConnectionProfile profile,
-            ActionListener<ProtobufConnection> listener) {
+    public void openProtobufConnection(DiscoveryNode node, ProtobufConnectionProfile profile, ActionListener<ProtobufConnection> listener) {
         // TODO Auto-generated method stub
         throw new UnsupportedOperationException("Unimplemented method 'openProtobufConnection'");
     }

From e6f61909a48175bd4b539bed93f8fd99c1b39735 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Mon, 10 Jul 2023 22:31:12 +0000
Subject: [PATCH 12/37] ProtobufClusterState to ClusterState

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../datastream/GetDataStreamAction.java       | 10 ++-
 .../admin/indices/rollover/RolloverInfo.java  | 10 ++-
 .../support/ProtobufTransportAction.java      |  2 +-
 ...obufTransportClusterManagerNodeAction.java | 15 ++--
 .../TransportClusterManagerNodeAction.java    |  5 ++
 .../opensearch/cluster/AbstractDiffable.java  | 68 ++++++++++++++++++-
 .../cluster/ProtobufAbstractDiffable.java     |  4 +-
 .../cluster/ProtobufClusterChangedEvent.java  |  9 +--
 .../cluster/ProtobufClusterState.java         | 33 ++++-----
 .../opensearch/cluster/ProtobufDiffable.java  |  2 +-
 .../cluster/ProtobufDiffableUtils.java        |  2 +-
 .../cluster/block/ClusterBlocks.java          | 10 ++-
 .../cluster/coordination/Coordinator.java     |  6 +-
 .../cluster/metadata/AliasMetadata.java       | 10 ++-
 .../cluster/metadata/ComponentTemplate.java   | 10 ++-
 .../metadata/ComposableIndexTemplate.java     | 10 ++-
 .../cluster/metadata/DataStream.java          | 10 ++-
 .../metadata/IndexTemplateMetadata.java       | 10 ++-
 .../cluster/metadata/MappingMetadata.java     | 10 ++-
 .../opensearch/cluster/metadata/Template.java | 10 ++-
 .../cluster/node/DiscoveryNodes.java          | 48 ++++++++++++-
 .../cluster/node/ProtobufDiscoveryNodes.java  |  2 +-
 .../cluster/routing/IndexRoutingTable.java    |  9 ++-
 .../ingest/PipelineConfiguration.java         | 11 ++-
 .../main/java/org/opensearch/node/Node.java   |  5 ++
 .../action/cat/ProtobufRestNodesAction.java   |  4 +-
 .../opensearch/script/StoredScriptSource.java | 15 +++-
 .../pipeline/PipelineConfiguration.java       | 10 ++-
 .../org/opensearch/tasks/TaskManager.java     | 19 ++----
 .../ProtobufRemoteClusterConnection.java      |  4 +-
 30 files changed, 308 insertions(+), 65 deletions(-)

diff --git a/server/src/main/java/org/opensearch/action/admin/indices/datastream/GetDataStreamAction.java b/server/src/main/java/org/opensearch/action/admin/indices/datastream/GetDataStreamAction.java
index 543783b3de367..bab12921aa42e 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/datastream/GetDataStreamAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/datastream/GetDataStreamAction.java
@@ -64,6 +64,8 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -166,7 +168,7 @@ public static class Response extends ActionResponse implements ToXContentObject
          *
          * @opensearch.internal
          */
-        public static class DataStreamInfo extends AbstractDiffable<DataStreamInfo> implements ToXContentObject {
+        public static class DataStreamInfo extends AbstractDiffable<DataStreamInfo, DataStreamInfo> implements ToXContentObject {
 
             public static final ParseField STATUS_FIELD = new ParseField("status");
             public static final ParseField INDEX_TEMPLATE_FIELD = new ParseField("template");
@@ -235,6 +237,12 @@ public boolean equals(Object o) {
             public int hashCode() {
                 return Objects.hash(dataStream, dataStreamStatus, indexTemplate);
             }
+
+            @Override
+            public void writeTo(CodedOutputStream out) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
+            }
         }
 
         private final List<DataStreamInfo> dataStreams;
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverInfo.java b/server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverInfo.java
index f58c842be374b..b21fbdbc29d99 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverInfo.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverInfo.java
@@ -45,6 +45,8 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
 
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.List;
 import java.util.Objects;
@@ -54,7 +56,7 @@
  *
  * @opensearch.internal
  */
-public class RolloverInfo extends AbstractDiffable<RolloverInfo> implements Writeable, ToXContentFragment {
+public class RolloverInfo extends AbstractDiffable<RolloverInfo, RolloverInfo> implements Writeable, ToXContentFragment {
 
     public static final ParseField CONDITION_FIELD = new ParseField("met_conditions");
     public static final ParseField TIME_FIELD = new ParseField("time");
@@ -151,4 +153,10 @@ public boolean equals(Object obj) {
     public String toString() {
         return Strings.toString(XContentType.JSON, this);
     }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java b/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
index 6f0356fb0dabc..b23b7c8e78106 100644
--- a/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
@@ -48,7 +48,7 @@ protected ProtobufTransportAction(String actionName, ProtobufActionFilters actio
 
     private Releasable registerChildNode(ProtobufTaskId parentTask) {
         if (parentTask.isSet()) {
-            return taskManager.registerProtobufChildNode(parentTask.getId(), taskManager.localProtobufNode());
+            return taskManager.registerProtobufChildNode(parentTask.getId(), taskManager.localNode());
         } else {
             return () -> {};
         }
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
index 55c915522b404..426af1f265898 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
@@ -30,7 +30,7 @@
 import org.opensearch.cluster.metadata.ProcessClusterEventTimeoutException;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
-import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
+import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.service.ClusterManagerTaskThrottler;
 import org.opensearch.cluster.service.ClusterManagerThrottlingException;
 import org.opensearch.cluster.service.ClusterService;
@@ -215,9 +215,13 @@ public Exception getTimeoutException(Exception e) {
 
         protected void doStart(ProtobufClusterState clusterState) {
             try {
-                final ProtobufDiscoveryNodes nodes = clusterState.nodes();
-                final DiscoveryNodes discoveryNodes = clusterService.state().nodes();
-                if (discoveryNodes.isLocalNodeElectedClusterManager() || localExecute(request)) {
+                System.out.println("ProtobufTransportClusterManagerNodeAction.doStart");
+                //this needs fixing
+                final DiscoveryNodes nodes = clusterService.state().nodes();
+                System.out.println("nodes: " + nodes);
+                // final DiscoveryNodes discoveryNodes = clusterService.state().nodes();
+                if (nodes.isLocalNodeElectedClusterManager() || localExecute(request)) {
+                    System.out.println("ProtobufTransportClusterManagerNodeAction.doStart.isLocalNodeElectedClusterManager");
                     // check for block, if blocked, retry, else, execute locally
                     final ClusterBlockException blockException = checkBlock(request, clusterState);
                     if (blockException != null) {
@@ -256,10 +260,13 @@ protected void doStart(ProtobufClusterState clusterState) {
                             .execute(ActionRunnable.wrap(delegate, l -> clusterManagerOperation(task, request, clusterState, l)));
                     }
                 } else {
+                    System.out.println("In else");
                     if (nodes.getClusterManagerNode() == null) {
+                        System.out.println("In else if");
                         logger.debug("no known cluster-manager node, scheduling a retry");
                         retryOnMasterChange(clusterState, null);
                     } else {
+                        System.out.println("In else else");
                         DiscoveryNode clusterManagerNode = nodes.getClusterManagerNode();
                         final String actionName = getClusterManagerActionName(clusterManagerNode);
                         transportService.sendRequest(
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
index 13c576bd120c7..5c00957f07d79 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
@@ -231,8 +231,11 @@ public Exception getTimeoutException(Exception e) {
 
         protected void doStart(ClusterState clusterState) {
             try {
+                System.out.println("TransportClusterManagerNodeAction.doStart");
                 final DiscoveryNodes nodes = clusterState.nodes();
+                System.out.println("nodes: " + nodes);
                 if (nodes.isLocalNodeElectedClusterManager() || localExecute(request)) {
+                    System.out.println("TransportClusterManagerNodeAction.doStart.isLocalNodeElectedClusterManager");
                     // check for block, if blocked, retry, else, execute locally
                     final ClusterBlockException blockException = checkBlock(request, clusterState);
                     if (blockException != null) {
@@ -271,7 +274,9 @@ protected void doStart(ClusterState clusterState) {
                             .execute(ActionRunnable.wrap(delegate, l -> clusterManagerOperation(task, request, clusterState, l)));
                     }
                 } else {
+                    System.out.println("In else");
                     if (nodes.getClusterManagerNode() == null) {
+                        System.out.println("In else if");
                         logger.debug("no known cluster-manager node, scheduling a retry");
                         retryOnMasterChange(clusterState, null);
                     } else {
diff --git a/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java b/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java
index 74af3472433ba..4f49ac5a0f7eb 100644
--- a/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java
+++ b/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java
@@ -33,9 +33,13 @@
 package org.opensearch.cluster;
 
 import org.opensearch.common.Nullable;
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 
 /**
@@ -44,7 +48,7 @@
  *
  * @opensearch.internal
  */
-public abstract class AbstractDiffable<T extends Diffable<T>> implements Diffable<T> {
+public abstract class AbstractDiffable<T extends Diffable<T>, V extends ProtobufDiffable<V>> implements Diffable<T>, ProtobufDiffable<V> {
 
     private static final Diff<?> EMPTY = new CompleteDiff<>();
 
@@ -58,6 +62,16 @@ public Diff<T> diff(T previousState) {
         }
     }
 
+    @SuppressWarnings("unchecked")
+    @Override
+    public ProtobufDiff<V> protobufDiff(V previousState) {
+        if (this.equals(previousState)) {
+            return (ProtobufDiff<V>) EMPTY;
+        } else {
+            return new CompleteDiffProtobuf<>((V) this);
+        }
+    }
+
     @SuppressWarnings("unchecked")
     public static <T extends Diffable<T>> Diff<T> readDiffFrom(Reader<T> reader, StreamInput in) throws IOException {
         if (in.readBoolean()) {
@@ -66,6 +80,14 @@ public static <T extends Diffable<T>> Diff<T> readDiffFrom(Reader<T> reader, Str
         return (Diff<T>) EMPTY;
     }
 
+    @SuppressWarnings("unchecked")
+    public static <V extends ProtobufDiffable<V>> ProtobufDiff<V> readDiffFromProtobuf(ProtobufWriteable.Reader<V> reader, CodedInputStream in) throws IOException {
+        if (in.readBool()) {
+            return new CompleteDiffProtobuf<>(reader.read(in));
+        }
+        return (ProtobufDiff<V>) EMPTY;
+    }
+
     /**
      * A complete diff.
      *
@@ -109,4 +131,48 @@ public T apply(T part) {
             }
         }
     }
+
+    /**
+     * A complete diff.
+    *
+    * @opensearch.internal
+    */
+    private static class CompleteDiffProtobuf<T extends ProtobufDiffable<T>> implements ProtobufDiff<T> {
+
+        @Nullable
+        private final T part;
+
+        /**
+         * Creates simple diff with changes
+        */
+        CompleteDiffProtobuf(T part) {
+            this.part = part;
+        }
+
+        /**
+         * Creates simple diff without changes
+        */
+        CompleteDiffProtobuf() {
+            this.part = null;
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            if (part != null) {
+                out.writeBoolNoTag(true);
+                part.writeTo(out);
+            } else {
+                out.writeBoolNoTag(false);
+            }
+        }
+
+        @Override
+        public T apply(T part) {
+            if (this.part != null) {
+                return this.part;
+            } else {
+                return part;
+            }
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufAbstractDiffable.java b/server/src/main/java/org/opensearch/cluster/ProtobufAbstractDiffable.java
index 9af03c8bc9463..3e90bb2a7d377 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufAbstractDiffable.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufAbstractDiffable.java
@@ -10,6 +10,8 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
+
+import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.common.Nullable;
 
 import java.io.IOException;
@@ -26,7 +28,7 @@ public abstract class ProtobufAbstractDiffable<T extends ProtobufDiffable<T>> im
 
     @SuppressWarnings("unchecked")
     @Override
-    public ProtobufDiff<T> diff(T previousState) {
+    public ProtobufDiff<T> protobufDiff(T previousState) {
         if (this.equals(previousState)) {
             return (ProtobufDiff<T>) EMPTY;
         } else {
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterChangedEvent.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterChangedEvent.java
index 59f6f7bfeb29e..eab4bade647fe 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufClusterChangedEvent.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufClusterChangedEvent.java
@@ -12,7 +12,8 @@
 import org.opensearch.cluster.metadata.IndexGraveyard.IndexGraveyardDiff;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.Metadata;
-import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.gateway.GatewayService;
 import org.opensearch.index.Index;
 
@@ -38,7 +39,7 @@ public class ProtobufClusterChangedEvent {
 
     private final ProtobufClusterState state;
 
-    private final ProtobufDiscoveryNodes.Delta nodesDelta;
+    private final DiscoveryNodes.Delta nodesDelta;
 
     public ProtobufClusterChangedEvent(String source, ProtobufClusterState state, ProtobufClusterState previousState) {
         Objects.requireNonNull(source, "source must not be null");
@@ -201,10 +202,10 @@ public boolean localNodeMaster() {
     }
 
     /**
-     * Returns the {@link org.opensearch.cluster.node.ProtobufDiscoveryNodes.Delta} between
+     * Returns the {@link org.opensearch.cluster.node.DiscoveryNodes.Delta} between
     * the previous cluster state and the new cluster state.
     */
-    public ProtobufDiscoveryNodes.Delta nodesDelta() {
+    public DiscoveryNodes.Delta nodesDelta() {
         return this.nodesDelta;
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java
index d1faa196a8dd3..b2354e5714494 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java
@@ -25,8 +25,9 @@
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
+import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.routing.IndexRoutingTable;
 import org.opensearch.cluster.routing.IndexShardRoutingTable;
 import org.opensearch.cluster.routing.RoutingNodes;
@@ -151,7 +152,7 @@ default boolean isPrivate() {
 
     private final RoutingTable routingTable;
 
-    private final ProtobufDiscoveryNodes nodes;
+    private final DiscoveryNodes nodes;
 
     private final Metadata metadata;
 
@@ -189,7 +190,7 @@ public ProtobufClusterState(
         String stateUUID,
         Metadata metadata,
         RoutingTable routingTable,
-        ProtobufDiscoveryNodes nodes,
+        DiscoveryNodes nodes,
         ClusterBlocks blocks,
         ImmutableOpenMap<String, Custom> customs,
         int minimumClusterManagerNodesOnPublishingClusterManager,
@@ -234,11 +235,11 @@ public String stateUUID() {
         return this.stateUUID;
     }
 
-    public ProtobufDiscoveryNodes nodes() {
+    public DiscoveryNodes nodes() {
         return this.nodes;
     }
 
-    public ProtobufDiscoveryNodes getNodes() {
+    public DiscoveryNodes getNodes() {
         return nodes();
     }
 
@@ -578,7 +579,7 @@ public static class Builder {
         private String uuid = UNKNOWN_UUID;
         private Metadata metadata = Metadata.EMPTY_METADATA;
         private RoutingTable routingTable = RoutingTable.EMPTY_ROUTING_TABLE;
-        private ProtobufDiscoveryNodes nodes = ProtobufDiscoveryNodes.EMPTY_NODES;
+        private DiscoveryNodes nodes = DiscoveryNodes.EMPTY_NODES;
         private ClusterBlocks blocks = ClusterBlocks.EMPTY_CLUSTER_BLOCK;
         private final ImmutableOpenMap.Builder<String, Custom> customs;
         private boolean fromDiff;
@@ -602,16 +603,16 @@ public Builder(ClusterName clusterName) {
             this.clusterName = clusterName;
         }
 
-        public Builder nodes(ProtobufDiscoveryNodes.Builder nodesBuilder) {
+        public Builder nodes(DiscoveryNodes.Builder nodesBuilder) {
             return nodes(nodesBuilder.build());
         }
 
-        public Builder nodes(ProtobufDiscoveryNodes nodes) {
+        public Builder nodes(DiscoveryNodes nodes) {
             this.nodes = nodes;
             return this;
         }
 
-        public ProtobufDiscoveryNodes nodes() {
+        public DiscoveryNodes nodes() {
             return nodes;
         }
 
@@ -717,7 +718,7 @@ public ProtobufClusterState build() {
     }
 
     @Override
-    public ProtobufDiff<ProtobufClusterState> diff(ProtobufClusterState previousState) {
+    public ProtobufDiff<ProtobufClusterState> protobufDiff(ProtobufClusterState previousState) {
         return new ClusterStateDiff(previousState, this);
     }
 
@@ -733,7 +734,7 @@ public static ProtobufClusterState readFrom(CodedInputStream in, DiscoveryNode l
         builder.uuid = in.readString();
         // builder.metadata = Metadata.readFrom(in);
         // builder.routingTable = RoutingTable.readFrom(in);
-        // builder.nodes = ProtobufDiscoveryNodes.readFrom(in, localNode);
+        builder.nodes = DiscoveryNodes.readFromProtobuf(in, localNode);
         // builder.blocks = ClusterBlocks.readFrom(in);
         int customSize = in.readInt32();
         for (int i = 0; i < customSize; i++) {
@@ -752,7 +753,7 @@ public void writeTo(CodedOutputStream out) throws IOException {
         out.writeStringNoTag(stateUUID);
         // metadata.writeTo(out);
         // routingTable.writeTo(out);
-        // nodes.writeTo(out);
+        nodes.writeTo(out);
         // blocks.writeTo(out);
         // filter out custom states not supported by the other node
         int numberOfCustoms = 0;
@@ -787,7 +788,7 @@ private static class ClusterStateDiff implements ProtobufDiff<ProtobufClusterSta
 
         private final ProtobufDiff<RoutingTable> routingTable;
 
-        private final ProtobufDiff<ProtobufDiscoveryNodes> nodes;
+        private final ProtobufDiff<DiscoveryNodes> nodes;
 
         private final ProtobufDiff<Metadata> metadata;
 
@@ -803,7 +804,7 @@ private static class ClusterStateDiff implements ProtobufDiff<ProtobufClusterSta
             toVersion = after.version;
             clusterName = after.clusterName;
             routingTable = null;
-            nodes = null;
+            nodes = after.nodes.protobufDiff(before.nodes);;
             metadata = null;
             blocks = null;
             customs = ProtobufDiffableUtils.diff(
@@ -821,7 +822,7 @@ private static class ClusterStateDiff implements ProtobufDiff<ProtobufClusterSta
             toUuid = in.readString();
             toVersion = in.readInt64();
             routingTable = null;
-            nodes = null;
+            nodes = DiscoveryNodes.readDiffFrom(in, localNode);
             metadata = null;
             blocks = null;
             customs = ProtobufDiffableUtils.readImmutableOpenMapDiff(
@@ -839,7 +840,7 @@ public void writeTo(CodedOutputStream out) throws IOException {
             out.writeStringNoTag(toUuid);
             out.writeInt64NoTag(toVersion);
             // routingTable.writeTo(out);
-            // nodes.writeTo(out);
+            nodes.writeTo(out);
             // metadata.writeTo(out);
             // blocks.writeTo(out);
             // customs.writeTo(out);
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java b/server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java
index 80adeb739fbec..4f1f2c83ef19f 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java
@@ -25,6 +25,6 @@ public interface ProtobufDiffable<T> extends ProtobufWriteable {
     /**
      * Returns serializable object representing differences between this and previousState
     */
-    ProtobufDiff<T> diff(T previousState);
+    ProtobufDiff<T> protobufDiff(T previousState);
 
 }
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufDiffableUtils.java b/server/src/main/java/org/opensearch/cluster/ProtobufDiffableUtils.java
index 32eecd526f997..fef838ff6eefa 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufDiffableUtils.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufDiffableUtils.java
@@ -713,7 +713,7 @@ public boolean supportsDiffableValues() {
 
         @Override
         public ProtobufDiff<V> diff(V value, V beforePart) {
-            return value.diff(beforePart);
+            return value.protobufDiff(beforePart);
         }
 
         @Override
diff --git a/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java b/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java
index 33d55e6e747a3..d5295aae148bc 100644
--- a/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java
+++ b/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java
@@ -32,6 +32,8 @@
 
 package org.opensearch.cluster.block;
 
+import com.google.protobuf.CodedOutputStream;
+
 import org.opensearch.cluster.AbstractDiffable;
 import org.opensearch.cluster.Diff;
 import org.opensearch.cluster.metadata.IndexMetadata;
@@ -61,7 +63,7 @@
  *
  * @opensearch.internal
  */
-public class ClusterBlocks extends AbstractDiffable<ClusterBlocks> {
+public class ClusterBlocks extends AbstractDiffable<ClusterBlocks, ClusterBlocks> {
     public static final ClusterBlocks EMPTY_CLUSTER_BLOCK = new ClusterBlocks(emptySet(), Map.of());
 
     private final Set<ClusterBlock> global;
@@ -478,4 +480,10 @@ public ClusterBlocks build() {
             return new ClusterBlocks(unmodifiableSet(new HashSet<>(global)), indicesBuilder);
         }
     }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
index ba2e4560beec1..3df16442b9fa7 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
@@ -42,7 +42,6 @@
 import org.opensearch.cluster.ClusterStateTaskConfig;
 import org.opensearch.cluster.ClusterStateUpdateTask;
 import org.opensearch.cluster.LocalClusterUpdateTask;
-import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ProtobufClusterState;
 import org.opensearch.cluster.block.ClusterBlocks;
 import org.opensearch.cluster.coordination.ClusterFormationFailureHelper.ClusterFormationState;
@@ -54,7 +53,6 @@
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
-import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
 import org.opensearch.cluster.routing.RerouteService;
 import org.opensearch.cluster.routing.allocation.AllocationService;
 import org.opensearch.cluster.service.ClusterApplier;
@@ -861,8 +859,10 @@ protected void doStart() {
                         .addGlobalBlock(STATE_NOT_RECOVERED_BLOCK)
                         .addGlobalBlock(noClusterManagerBlockService.getNoClusterManagerBlock())
                 )
-                .nodes(ProtobufDiscoveryNodes.builder().add(getLocalNode()).localNodeId(getLocalNode().getId()))
+                .nodes(DiscoveryNodes.builder().add(getLocalNode()).localNodeId(getLocalNode().getId()))
                 .build();
+            System.out.println("cluster state initial: " + initialState);
+            System.out.println("protobuf cluster state initial: " + protobufInitialState);
             applierState = initialState;
             clusterApplier.setInitialState(initialState);
             clusterApplier.setInitialProtobufState(protobufInitialState);
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/AliasMetadata.java b/server/src/main/java/org/opensearch/cluster/metadata/AliasMetadata.java
index 27ecca0358bd8..05ea4ff948386 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/AliasMetadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/AliasMetadata.java
@@ -51,6 +51,8 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
 
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.Collections;
 import java.util.Map;
@@ -64,7 +66,7 @@
  *
  * @opensearch.internal
  */
-public class AliasMetadata extends AbstractDiffable<AliasMetadata> implements ToXContentFragment {
+public class AliasMetadata extends AbstractDiffable<AliasMetadata, AliasMetadata> implements ToXContentFragment {
 
     private final String alias;
 
@@ -431,4 +433,10 @@ public static AliasMetadata fromXContent(XContentParser parser) throws IOExcepti
             return builder.build();
         }
     }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/ComponentTemplate.java b/server/src/main/java/org/opensearch/cluster/metadata/ComponentTemplate.java
index 52096422248a5..03aedc2635e20 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/ComponentTemplate.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/ComponentTemplate.java
@@ -45,6 +45,8 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
 
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.Map;
 import java.util.Objects;
@@ -57,7 +59,7 @@
  *
  * @opensearch.internal
  */
-public class ComponentTemplate extends AbstractDiffable<ComponentTemplate> implements ToXContentObject {
+public class ComponentTemplate extends AbstractDiffable<ComponentTemplate, ComponentTemplate> implements ToXContentObject {
     private static final ParseField TEMPLATE = new ParseField("template");
     private static final ParseField VERSION = new ParseField("version");
     private static final ParseField METADATA = new ParseField("_meta");
@@ -168,4 +170,10 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         builder.endObject();
         return builder;
     }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java b/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java
index 15e5cb5873719..b7d7ffecd5001 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java
@@ -49,6 +49,8 @@
 import org.opensearch.index.mapper.DataStreamFieldMapper;
 import org.opensearch.index.mapper.MapperService;
 
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
@@ -65,7 +67,7 @@
  *
  * @opensearch.internal
  */
-public class ComposableIndexTemplate extends AbstractDiffable<ComposableIndexTemplate> implements ToXContentObject {
+public class ComposableIndexTemplate extends AbstractDiffable<ComposableIndexTemplate, ComposableIndexTemplate> implements ToXContentObject {
     private static final ParseField INDEX_PATTERNS = new ParseField("index_patterns");
     private static final ParseField TEMPLATE = new ParseField("template");
     private static final ParseField PRIORITY = new ParseField("priority");
@@ -358,4 +360,10 @@ public int hashCode() {
             return Objects.hash(timestampField);
         }
     }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/DataStream.java b/server/src/main/java/org/opensearch/cluster/metadata/DataStream.java
index 76e1a0197bc1c..391f005e224d1 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/DataStream.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/DataStream.java
@@ -47,6 +47,8 @@
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.core.index.Index;
 
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -61,7 +63,7 @@
  *
  * @opensearch.internal
  */
-public final class DataStream extends AbstractDiffable<DataStream> implements ToXContentObject {
+public final class DataStream extends AbstractDiffable<DataStream, DataStream> implements ToXContentObject {
 
     public static final String BACKING_INDEX_PREFIX = ".ds-";
     public static final String TIMESERIES_FIELDNAME = "@timestamp";
@@ -318,4 +320,10 @@ public int hashCode() {
             return Objects.hash(name);
         }
     }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java b/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java
index e430ba5465499..bb286cde40781 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java
@@ -31,6 +31,8 @@
 
 package org.opensearch.cluster.metadata;
 
+import com.google.protobuf.CodedOutputStream;
+
 import org.opensearch.OpenSearchParseException;
 import org.opensearch.cluster.AbstractDiffable;
 import org.opensearch.cluster.Diff;
@@ -66,7 +68,7 @@
  *
  * @opensearch.internal
  */
-public class IndexTemplateMetadata extends AbstractDiffable<IndexTemplateMetadata> {
+public class IndexTemplateMetadata extends AbstractDiffable<IndexTemplateMetadata, IndexTemplateMetadata> {
 
     private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(IndexTemplateMetadata.class);
 
@@ -542,4 +544,10 @@ private static String skipTemplateName(XContentParser parser) throws IOException
         }
     }
 
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/MappingMetadata.java b/server/src/main/java/org/opensearch/cluster/metadata/MappingMetadata.java
index c77d2d6b8b2b3..2074511a1f075 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/MappingMetadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/MappingMetadata.java
@@ -45,6 +45,8 @@
 import org.opensearch.index.mapper.DocumentMapper;
 import org.opensearch.index.mapper.MapperService;
 
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.util.Collections;
@@ -58,7 +60,7 @@
  *
  * @opensearch.internal
  */
-public class MappingMetadata extends AbstractDiffable<MappingMetadata> {
+public class MappingMetadata extends AbstractDiffable<MappingMetadata, MappingMetadata> {
     public static final MappingMetadata EMPTY_MAPPINGS = new MappingMetadata(MapperService.SINGLE_MAPPING_NAME, Collections.emptyMap());
 
     private final String type;
@@ -191,4 +193,10 @@ public MappingMetadata(StreamInput in) throws IOException {
     public static Diff<MappingMetadata> readDiffFrom(StreamInput in) throws IOException {
         return readDiffFrom(MappingMetadata::new, in);
     }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/Template.java b/server/src/main/java/org/opensearch/cluster/metadata/Template.java
index 45d11dd9250e8..326711ffc8274 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/Template.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/Template.java
@@ -49,6 +49,8 @@
 import org.opensearch.common.xcontent.XContentType;
 import org.opensearch.index.mapper.MapperService;
 
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
@@ -61,7 +63,7 @@
  *
  * @opensearch.internal
  */
-public class Template extends AbstractDiffable<Template> implements ToXContentObject {
+public class Template extends AbstractDiffable<Template, Template> implements ToXContentObject {
     private static final ParseField SETTINGS = new ParseField("settings");
     private static final ParseField MAPPINGS = new ParseField("mappings");
     private static final ParseField ALIASES = new ParseField("aliases");
@@ -214,4 +216,10 @@ private static Map<String, Object> reduceMapping(Map<String, Object> mapping) {
             return mapping;
         }
     }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java
index 060c7c5eb8d1a..1916da47e2f00 100644
--- a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java
+++ b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java
@@ -32,9 +32,14 @@
 
 package org.opensearch.cluster.node;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import org.opensearch.Version;
 import org.opensearch.cluster.AbstractDiffable;
 import org.opensearch.cluster.Diff;
+import org.opensearch.cluster.ProtobufAbstractDiffable;
+import org.opensearch.cluster.ProtobufDiff;
 import org.opensearch.common.Booleans;
 import org.opensearch.common.Nullable;
 import org.opensearch.core.common.io.stream.StreamInput;
@@ -43,6 +48,7 @@
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.util.set.Sets;
 import org.opensearch.core.common.Strings;
+import org.opensearch.discovery.Discovery;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -64,7 +70,7 @@
  *
  * @opensearch.internal
  */
-public class DiscoveryNodes extends AbstractDiffable<DiscoveryNodes> implements Iterable<DiscoveryNode> {
+public class DiscoveryNodes extends AbstractDiffable<DiscoveryNodes, DiscoveryNodes> implements Iterable<DiscoveryNode> {
 
     public static final DiscoveryNodes EMPTY_NODES = builder().build();
 
@@ -697,6 +703,19 @@ public void writeTo(StreamOutput out) throws IOException {
         }
     }
 
+    public void writeTo(CodedOutputStream out) throws IOException {
+        if (clusterManagerNodeId == null) {
+            out.writeBoolNoTag(false);
+        } else {
+            out.writeBoolNoTag(true);
+            out.writeStringNoTag(clusterManagerNodeId);
+        }
+        out.writeInt32NoTag(nodes.size());
+        for (DiscoveryNode node : this) {
+            node.writeTo(out);
+        }
+    }
+
     public static DiscoveryNodes readFrom(StreamInput in, DiscoveryNode localNode) throws IOException {
         Builder builder = new Builder();
         if (in.readBoolean()) {
@@ -720,10 +739,37 @@ public static DiscoveryNodes readFrom(StreamInput in, DiscoveryNode localNode) t
         return builder.build();
     }
 
+    public static DiscoveryNodes readFromProtobuf(CodedInputStream in, DiscoveryNode localNode) throws IOException {
+        Builder builder = new Builder();
+        if (in.readBool()) {
+            builder.clusterManagerNodeId(in.readString());
+        }
+        if (localNode != null) {
+            builder.localNodeId(localNode.getId());
+        }
+        int size = in.readInt32();
+        for (int i = 0; i < size; i++) {
+            DiscoveryNode node = new DiscoveryNode(in);
+            if (localNode != null && node.getId().equals(localNode.getId())) {
+                // reuse the same instance of our address and local node id for faster equality
+                node = localNode;
+            }
+            // some one already built this and validated it's OK, skip the n2 scans
+            assert builder.validateAdd(node) == null : "building disco nodes from network doesn't pass preflight: "
+                + builder.validateAdd(node);
+            builder.putUnsafe(node);
+        }
+        return builder.build();
+    }
+
     public static Diff<DiscoveryNodes> readDiffFrom(StreamInput in, DiscoveryNode localNode) throws IOException {
         return AbstractDiffable.readDiffFrom(in1 -> readFrom(in1, localNode), in);
     }
 
+    public static ProtobufDiff<DiscoveryNodes> readDiffFrom(CodedInputStream in, DiscoveryNode localNode) throws IOException {
+        return AbstractDiffable.readDiffFromProtobuf(in1 -> readFromProtobuf(in1, localNode), in);
+    }
+
     public static Builder builder() {
         return new Builder();
     }
diff --git a/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java b/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java
index b49a286178ae1..b4fe824b933e2 100644
--- a/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java
+++ b/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java
@@ -36,7 +36,7 @@
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
-/**
+/** not used
  * This class holds all {@link DiscoveryNode} in the cluster and provides convenience methods to
 * access, modify merge / diff discovery nodes.
 *
diff --git a/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java b/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java
index bbb3ee61d719d..3462b58507f0a 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java
@@ -33,6 +33,7 @@
 package org.opensearch.cluster.routing;
 
 import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
 
 import org.apache.lucene.util.CollectionUtil;
 import org.opensearch.cluster.AbstractDiffable;
@@ -79,7 +80,7 @@
  *
  * @opensearch.internal
  */
-public class IndexRoutingTable extends AbstractDiffable<IndexRoutingTable> implements Iterable<IndexShardRoutingTable> {
+public class IndexRoutingTable extends AbstractDiffable<IndexRoutingTable, IndexRoutingTable> implements Iterable<IndexShardRoutingTable> {
 
     private final Index index;
     private final ShardShuffler shuffler;
@@ -676,4 +677,10 @@ public String prettyPrint() {
         return sb.toString();
     }
 
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/ingest/PipelineConfiguration.java b/server/src/main/java/org/opensearch/ingest/PipelineConfiguration.java
index 3b918592053c1..464c29e8a0c92 100644
--- a/server/src/main/java/org/opensearch/ingest/PipelineConfiguration.java
+++ b/server/src/main/java/org/opensearch/ingest/PipelineConfiguration.java
@@ -45,6 +45,9 @@
 import org.opensearch.core.xcontent.ObjectParser;
 import org.opensearch.core.xcontent.ToXContentObject;
 import org.opensearch.core.xcontent.XContentBuilder;
+
+import com.google.protobuf.CodedOutputStream;
+
 import org.opensearch.common.xcontent.XContentHelper;
 import org.opensearch.common.xcontent.XContentType;
 
@@ -57,7 +60,7 @@
  *
  * @opensearch.internal
  */
-public final class PipelineConfiguration extends AbstractDiffable<PipelineConfiguration> implements ToXContentObject {
+public final class PipelineConfiguration extends AbstractDiffable<PipelineConfiguration, PipelineConfiguration> implements ToXContentObject {
 
     private static final ObjectParser<Builder, Void> PARSER = new ObjectParser<>("pipeline_config", true, Builder::new);
     static {
@@ -183,4 +186,10 @@ public int hashCode() {
         result = 31 * result + getConfigAsMap().hashCode();
         return result;
     }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/node/Node.java b/server/src/main/java/org/opensearch/node/Node.java
index 0ec80f0bfda21..d0c527a2914e8 100644
--- a/server/src/main/java/org/opensearch/node/Node.java
+++ b/server/src/main/java/org/opensearch/node/Node.java
@@ -1463,6 +1463,11 @@ public Node start() throws NodeValidationException {
         configureNodeAndClusterIdStateListener(clusterService);
         configureProtobufNodeAndClusterIdStateListener(clusterService);
 
+        ClusterState clusterState1 = clusterService.state();
+        System.out.println("Cluster state: " + clusterState1);
+        ProtobufClusterState protobufClusterState1 = clusterService.protobufState();
+        System.out.println("Protobuf Cluster state: " + protobufClusterState1);
+
         if (initialStateTimeout.millis() > 0) {
             final ThreadPool thread = injector.getInstance(ThreadPool.class);
             ClusterState clusterState = clusterService.state();
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
index ce45b1942d35a..d03185d66dfaa 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
@@ -19,7 +19,7 @@
 import org.opensearch.client.node.ProtobufNodeClient;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
-import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
+import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.common.Strings;
 import org.opensearch.common.Table;
 import org.opensearch.common.logging.DeprecationLogger;
@@ -335,7 +335,7 @@ Table buildTable(
         ProtobufNodesInfoResponse nodesInfo,
         ProtobufNodesStatsResponse nodesStats
     ) {
-        ProtobufDiscoveryNodes nodes = state.getState().nodes();
+        DiscoveryNodes nodes = state.getState().nodes();
         String clusterManagerId = nodes.getClusterManagerNodeId();
         Table table = getTableWithHeader(req);
 
diff --git a/server/src/main/java/org/opensearch/script/StoredScriptSource.java b/server/src/main/java/org/opensearch/script/StoredScriptSource.java
index 9d3af9e4c9caf..383e445dd385a 100644
--- a/server/src/main/java/org/opensearch/script/StoredScriptSource.java
+++ b/server/src/main/java/org/opensearch/script/StoredScriptSource.java
@@ -53,6 +53,9 @@
 import org.opensearch.common.xcontent.XContentFactory;
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.core.xcontent.XContentParser.Token;
+
+import com.google.protobuf.CodedOutputStream;
+
 import org.opensearch.common.xcontent.XContentType;
 
 import java.io.IOException;
@@ -69,7 +72,7 @@
  *
  * @opensearch.internal
  */
-public class StoredScriptSource extends AbstractDiffable<StoredScriptSource> implements Writeable, ToXContentObject {
+public class StoredScriptSource extends AbstractDiffable<StoredScriptSource, StoredScriptSource> implements Writeable, ToXContentObject {
 
     /**
      * Standard deprecation logger for used to deprecate allowance of empty templates.
@@ -387,6 +390,16 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeMap(options);
     }
 
+    /**
+     * Writes a {@link StoredScriptSource} to a stream. Will write
+     * all of the lang, source, and options parameters.
+     */
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+         // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
+    }
+
     /**
      * This will write XContent from a {@link StoredScriptSource}. The following format will be written:
      *
diff --git a/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java b/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java
index 33686139039b9..4fbfe3b79749c 100644
--- a/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java
+++ b/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java
@@ -24,6 +24,8 @@
 import org.opensearch.core.xcontent.ToXContentObject;
 import org.opensearch.core.xcontent.XContentBuilder;
 
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.Map;
 import java.util.Objects;
@@ -33,7 +35,7 @@
  *
  * See if we can refactor into a common class. I suspect not, just because this one will hold
  */
-public class PipelineConfiguration extends AbstractDiffable<PipelineConfiguration> implements ToXContentObject {
+public class PipelineConfiguration extends AbstractDiffable<PipelineConfiguration, PipelineConfiguration> implements ToXContentObject {
     private static final ObjectParser<Builder, Void> PARSER = new ObjectParser<>(
         "pipeline_config",
         true,
@@ -162,4 +164,10 @@ public int hashCode() {
         result = 31 * result + getConfigAsMap().hashCode();
         return result;
     }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/tasks/TaskManager.java b/server/src/main/java/org/opensearch/tasks/TaskManager.java
index c3bcb316d16e9..34d2247de4aef 100644
--- a/server/src/main/java/org/opensearch/tasks/TaskManager.java
+++ b/server/src/main/java/org/opensearch/tasks/TaskManager.java
@@ -49,8 +49,6 @@
 import org.opensearch.cluster.ProtobufClusterStateApplier;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
-import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
 import org.opensearch.common.SetOnce;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
@@ -135,7 +133,6 @@ public class TaskManager implements ClusterStateApplier, ProtobufClusterStateApp
     private final SetOnce<ProtobufTaskResourceTrackingService> protobufTaskResourceTrackingService = new SetOnce<>();
 
     private volatile DiscoveryNodes lastDiscoveryNodes = DiscoveryNodes.EMPTY_NODES;
-    private volatile ProtobufDiscoveryNodes lastDiscoveryNodesProtobuf = ProtobufDiscoveryNodes.EMPTY_NODES;
 
     private final ByteSizeValue maxHeaderSize;
     private final Map<TcpChannel, ChannelPendingTaskTracker> channelPendingTaskTrackers = ConcurrentCollections.newConcurrentMap();
@@ -557,10 +554,6 @@ public Releasable registerProtobufChildNode(long taskId, DiscoveryNode node) {
         return () -> {};
     }
 
-    public DiscoveryNode localProtobufNode() {
-        return lastDiscoveryNodesProtobuf.getLocalNode();
-    }
-
     /**
      * Stores the task failure
      */
@@ -601,7 +594,7 @@ public <Response extends ProtobufActionResponse> void storeResultProtobuf(
         Exception error,
         ActionListener<Response> listener
     ) {
-        DiscoveryNode localNode = lastDiscoveryNodesProtobuf.getLocalNode();
+        DiscoveryNode localNode = lastDiscoveryNodes.getLocalNode();
         if (localNode == null) {
             // too early to store anything, shouldn't really be here - just pass the error along
             listener.onFailure(error);
@@ -671,7 +664,7 @@ public <Response extends ProtobufActionResponse> void storeResultProtobuf(
         Response response,
         ActionListener<Response> listener
     ) {
-        DiscoveryNode localNode = lastDiscoveryNodesProtobuf.getLocalNode();
+        DiscoveryNode localNode = lastDiscoveryNodes.getLocalNode();
         if (localNode == null) {
             // too early to store anything, shouldn't really be here - just pass the response along
             logger.warn("couldn't store response {}, the node didn't join the cluster yet", response);
@@ -875,7 +868,7 @@ public List<ProtobufCancellableTask> setBanProtobuf(ProtobufTaskId parentTaskId,
 
         // Set the ban first, so the newly created tasks cannot be registered
         synchronized (banedParentsProtobuf) {
-            if (lastDiscoveryNodesProtobuf.nodeExists(parentTaskId.getNodeId())) {
+            if (lastDiscoveryNodes.nodeExists(parentTaskId.getNodeId())) {
                 // Only set the ban if the node is the part of the cluster
                 banedParentsProtobuf.put(parentTaskId, reason);
             }
@@ -944,15 +937,15 @@ public void applyClusterState(ClusterChangedEvent event) {
 
     @Override
     public void applyProtobufClusterState(ProtobufClusterChangedEvent event) {
-        lastDiscoveryNodesProtobuf = event.state().getNodes();
+        lastDiscoveryNodes = event.state().getNodes();
         if (event.nodesRemoved()) {
             synchronized (banedParentsProtobuf) {
-                lastDiscoveryNodesProtobuf = event.state().getNodes();
+                lastDiscoveryNodes = event.state().getNodes();
                 // Remove all bans that were registered by nodes that are no longer in the cluster state
                 Iterator<ProtobufTaskId> banIterator = banedParentsProtobuf.keySet().iterator();
                 while (banIterator.hasNext()) {
                     ProtobufTaskId taskId = banIterator.next();
-                    if (lastDiscoveryNodesProtobuf.nodeExists(taskId.getNodeId()) == false) {
+                    if (lastDiscoveryNodes.nodeExists(taskId.getNodeId()) == false) {
                         logger.debug(
                             "Removing ban for the parent [{}] on the node [{}], reason: the parent node is gone",
                             taskId,
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
index 71fc6c9154b73..5cc607ee3bce8 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
@@ -15,7 +15,7 @@
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
 import org.opensearch.action.support.ContextPreservingActionListener;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.ProtobufDiscoveryNodes;
+import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.ThreadContext;
@@ -142,7 +142,7 @@ public ProtobufClusterStateResponse read(CodedInputStream in) throws IOException
 
                         @Override
                         public void handleResponse(ProtobufClusterStateResponse response) {
-                            ProtobufDiscoveryNodes nodes = response.getState().nodes();
+                            DiscoveryNodes nodes = response.getState().nodes();
                             contextPreservingActionListener.onResponse(nodes::get);
                         }
 

From b94a49e66773ffc9fcd1bc8599fba0fd62a9b040 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Mon, 10 Jul 2023 22:51:55 +0000
Subject: [PATCH 13/37] Fixing cluster manager x to *

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../state/ProtobufClusterStateResponse.java   |  13 +-
 .../ProtobufTransportClusterStateAction.java  |  28 +-
 ...obufTransportClusterManagerNodeAction.java |  45 +-
 ...TransportClusterManagerNodeReadAction.java |   6 +-
 .../ClusterManagerNodeChangePredicate.java    |  23 -
 .../org/opensearch/cluster/ClusterState.java  | 176 +++-
 .../cluster/ProtobufClusterChangedEvent.java  | 616 +++++++-------
 .../cluster/ProtobufClusterState.java         |   2 +-
 .../cluster/ProtobufClusterStateApplier.java  |  50 +-
 .../cluster/ProtobufClusterStateListener.java |  38 +-
 .../cluster/ProtobufClusterStateObserver.java | 768 +++++++++---------
 .../ProtobufTimeoutClusterStateListener.java  |  98 +--
 .../cluster/coordination/Coordinator.java     |  22 +-
 .../cluster/service/ClusterApplier.java       |  10 +-
 .../service/ClusterApplierService.java        |  40 +-
 .../cluster/service/ClusterService.java       |  14 +-
 ...ProtobufNodeAndClusterIdStateListener.java | 116 +--
 .../main/java/org/opensearch/node/Node.java   |  92 +--
 .../org/opensearch/tasks/TaskManager.java     |  49 +-
 .../coordination/NoOpClusterApplier.java      |   6 +-
 20 files changed, 1165 insertions(+), 1047 deletions(-)

diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
index af24e5dc13b2c..119cd41ad4f15 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
@@ -18,7 +18,7 @@
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterName;
-import org.opensearch.cluster.ProtobufClusterState;
+import org.opensearch.cluster.ClusterState;
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
 
@@ -32,18 +32,18 @@
 public class ProtobufClusterStateResponse extends ProtobufActionResponse {
 
     private ClusterName clusterName;
-    private ProtobufClusterState clusterState;
+    private ClusterState clusterState;
     private boolean waitForTimedOut = false;
 
     public ProtobufClusterStateResponse(CodedInputStream in) throws IOException {
         super(in);
         ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
         clusterName = new ClusterName(in);
-        clusterState = protobufStreamInput.readOptionalWriteable(innerIn -> ProtobufClusterState.readFrom(innerIn, null));
+        clusterState = protobufStreamInput.readOptionalWriteable(innerIn -> ClusterState.readFrom(innerIn, null));
         waitForTimedOut = in.readBool();
     }
 
-    public ProtobufClusterStateResponse(ClusterName clusterName, ProtobufClusterState clusterState, boolean waitForTimedOut) {
+    public ProtobufClusterStateResponse(ClusterName clusterName, ClusterState clusterState, boolean waitForTimedOut) {
         this.clusterName = clusterName;
         this.clusterState = clusterState;
         this.waitForTimedOut = waitForTimedOut;
@@ -53,7 +53,7 @@ public ProtobufClusterStateResponse(ClusterName clusterName, ProtobufClusterStat
      * The requested cluster state.  Only the parts of the cluster state that were
     * requested are included in the returned {@link ClusterState} instance.
     */
-    public ProtobufClusterState getState() {
+    public ClusterState getState() {
         return this.clusterState;
     }
 
@@ -74,6 +74,7 @@ public boolean isWaitForTimedOut() {
 
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
+        System.out.println("Inside writeTo of ProtobufClusterStateResponse");
         ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         clusterName.writeTo(out);
         protobufStreamOutput.writeOptionalWriteable(clusterState);
@@ -82,6 +83,6 @@ public void writeTo(CodedOutputStream out) throws IOException {
 
     @Override
     public String toString() {
-        return "ClusterStateResponse{" + "clusterState=" + clusterState + '}';
+        return "ProtobufClusterStateResponse{" + "clusterState=" + clusterState + '}';
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
index 117dd3032331e..6247d45fac534 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
@@ -15,12 +15,12 @@
 import org.opensearch.action.ActionListener;
 import org.opensearch.action.support.ProtobufActionFilters;
 import org.opensearch.action.support.clustermanager.ProtobufTransportClusterManagerNodeReadAction;
-import org.opensearch.cluster.ProtobufClusterState;
-import org.opensearch.cluster.ProtobufClusterStateObserver;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.ClusterStateObserver;
 import org.opensearch.cluster.NotClusterManagerException;
 import org.opensearch.cluster.block.ClusterBlockException;
 import org.opensearch.cluster.metadata.IndexMetadata;
-import org.opensearch.cluster.metadata.ProtobufIndexNameExpressionResolver;
+import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.metadata.Metadata.Custom;
 import org.opensearch.cluster.routing.RoutingTable;
@@ -59,7 +59,7 @@ public ProtobufTransportClusterStateAction(
         ClusterService clusterService,
         ThreadPool threadPool,
         ProtobufActionFilters actionFilters,
-        ProtobufIndexNameExpressionResolver indexNameExpressionResolver
+        IndexNameExpressionResolver indexNameExpressionResolver
     ) {
         super(
             ClusterStateAction.NAME,
@@ -85,7 +85,7 @@ protected ProtobufClusterStateResponse read(CodedInputStream in) throws IOExcept
     }
 
     @Override
-    protected ClusterBlockException checkBlock(ProtobufClusterStateRequest request, ProtobufClusterState state) {
+    protected ClusterBlockException checkBlock(ProtobufClusterStateRequest request, ClusterState state) {
         // cluster state calls are done also on a fully blocked cluster to figure out what is going
         // on in the cluster. For example, which nodes have joined yet the recovery has not yet kicked
         // in, we need to make sure we allow those calls
@@ -96,15 +96,15 @@ protected ClusterBlockException checkBlock(ProtobufClusterStateRequest request,
     @Override
     protected void clusterManagerOperation(
         final ProtobufClusterStateRequest request,
-        final ProtobufClusterState state,
+        final ClusterState state,
         final ActionListener<ProtobufClusterStateResponse> listener
     ) throws IOException {
 
-        final Predicate<ProtobufClusterState> acceptableClusterStatePredicate = request.waitForMetadataVersion() == null
+        final Predicate<ClusterState> acceptableClusterStatePredicate = request.waitForMetadataVersion() == null
             ? clusterState -> true
             : clusterState -> clusterState.metadata().version() >= request.waitForMetadataVersion();
 
-        final Predicate<ProtobufClusterState> acceptableClusterStateOrNotMasterPredicate = request.local()
+        final Predicate<ClusterState> acceptableClusterStateOrNotMasterPredicate = request.local()
             ? acceptableClusterStatePredicate
             : acceptableClusterStatePredicate.or(clusterState -> clusterState.nodes().isLocalNodeElectedClusterManager() == false);
 
@@ -112,11 +112,11 @@ protected void clusterManagerOperation(
             ActionListener.completeWith(listener, () -> buildResponse(request, state));
         } else {
             assert acceptableClusterStateOrNotMasterPredicate.test(state) == false;
-            new ProtobufClusterStateObserver(state, clusterService, request.waitForTimeout(), logger, threadPool.getThreadContext())
-                .waitForNextChange(new ProtobufClusterStateObserver.Listener() {
+            new ClusterStateObserver(state, clusterService, request.waitForTimeout(), logger, threadPool.getThreadContext())
+                .waitForNextChange(new ClusterStateObserver.Listener() {
 
                     @Override
-                    public void onNewClusterState(ProtobufClusterState newState) {
+                    public void onNewClusterState(ClusterState newState) {
                         if (acceptableClusterStatePredicate.test(newState)) {
                             ActionListener.completeWith(listener, () -> buildResponse(request, newState));
                         } else {
@@ -145,9 +145,9 @@ public void onTimeout(TimeValue timeout) {
         }
     }
 
-    private ProtobufClusterStateResponse buildResponse(final ProtobufClusterStateRequest request, final ProtobufClusterState currentState) {
+    private ProtobufClusterStateResponse buildResponse(final ProtobufClusterStateRequest request, final ClusterState currentState) {
         logger.trace("Serving cluster state request using version {}", currentState.version());
-        ProtobufClusterState.Builder builder = ProtobufClusterState.builder(currentState.getClusterName());
+        ClusterState.Builder builder = ClusterState.builder(currentState.getClusterName());
         builder.version(currentState.version());
         builder.stateUUID(currentState.stateUUID());
 
@@ -200,7 +200,7 @@ private ProtobufClusterStateResponse buildResponse(final ProtobufClusterStateReq
         builder.metadata(mdBuilder);
 
         if (request.customs()) {
-            for (ObjectObjectCursor<String, ProtobufClusterState.Custom> custom : currentState.customs()) {
+            for (ObjectObjectCursor<String, ClusterState.Custom> custom : currentState.customs()) {
                 if (custom.value.isPrivate() == false) {
                     builder.putCustom(custom.key, custom.value);
                 }
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
index 426af1f265898..119ab35688ddd 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
@@ -20,13 +20,14 @@
 import org.opensearch.action.support.ProtobufActionFilters;
 import org.opensearch.action.support.ProtobufHandledTransportAction;
 import org.opensearch.action.support.RetryableAction;
-import org.opensearch.cluster.ProtobufClusterState;
-import org.opensearch.cluster.ProtobufClusterStateObserver;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.ClusterStateObserver;
+import org.opensearch.cluster.ClusterStateObserver;
 import org.opensearch.cluster.ClusterManagerNodeChangePredicate;
 import org.opensearch.cluster.NotClusterManagerException;
 import org.opensearch.cluster.block.ClusterBlockException;
 import org.opensearch.cluster.coordination.FailedToCommitClusterStateException;
-import org.opensearch.cluster.metadata.ProtobufIndexNameExpressionResolver;
+import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
 import org.opensearch.cluster.metadata.ProcessClusterEventTimeoutException;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
@@ -62,7 +63,7 @@ public abstract class ProtobufTransportClusterManagerNodeAction<
     protected final ThreadPool threadPool;
     protected final ProtobufTransportService transportService;
     protected final ClusterService clusterService;
-    protected final ProtobufIndexNameExpressionResolver indexNameExpressionResolver;
+    protected final IndexNameExpressionResolver indexNameExpressionResolver;
 
     private final String executor;
 
@@ -73,7 +74,7 @@ protected ProtobufTransportClusterManagerNodeAction(
         ThreadPool threadPool,
         ProtobufActionFilters actionFilters,
         ProtobufWriteable.Reader<Request> request,
-        ProtobufIndexNameExpressionResolver indexNameExpressionResolver
+        IndexNameExpressionResolver indexNameExpressionResolver
     ) {
         this(actionName, true, transportService, clusterService, threadPool, actionFilters, request, indexNameExpressionResolver);
     }
@@ -86,7 +87,7 @@ protected ProtobufTransportClusterManagerNodeAction(
         ThreadPool threadPool,
         ProtobufActionFilters actionFilters,
         ProtobufWriteable.Reader<Request> request,
-        ProtobufIndexNameExpressionResolver indexNameExpressionResolver
+        IndexNameExpressionResolver indexNameExpressionResolver
     ) {
         super(actionName, canTripCircuitBreaker, transportService, actionFilters, request);
         this.transportService = transportService;
@@ -101,25 +102,25 @@ protected ProtobufTransportClusterManagerNodeAction(
     protected abstract Response read(CodedInputStream in) throws IOException;
 
     /**
-     * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #clusterManagerOperation(ProtobufClusterManagerNodeRequest, ProtobufClusterState, ActionListener)}
+     * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #clusterManagerOperation(ProtobufClusterManagerNodeRequest, ClusterState, ActionListener)}
      */
     @Deprecated
-    protected void masterOperation(Request request, ProtobufClusterState state, ActionListener<Response> listener) throws Exception {
+    protected void masterOperation(Request request, ClusterState state, ActionListener<Response> listener) throws Exception {
         throw new UnsupportedOperationException("Must be overridden");
     }
 
     // TODO: Add abstract keyword after removing the deprecated masterOperation()
-    protected void clusterManagerOperation(Request request, ProtobufClusterState state, ActionListener<Response> listener)
+    protected void clusterManagerOperation(Request request, ClusterState state, ActionListener<Response> listener)
         throws Exception {
         masterOperation(request, state, listener);
     }
 
     /**
      * Override this operation if access to the task parameter is needed
-     * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #clusterManagerOperation(ProtobufTask, ProtobufClusterManagerNodeRequest, ProtobufClusterState, ActionListener)}
+     * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #clusterManagerOperation(ProtobufTask, ProtobufClusterManagerNodeRequest, ClusterState, ActionListener)}
      */
     @Deprecated
-    protected void masterOperation(ProtobufTask task, Request request, ProtobufClusterState state, ActionListener<Response> listener)
+    protected void masterOperation(ProtobufTask task, Request request, ClusterState state, ActionListener<Response> listener)
         throws Exception {
         clusterManagerOperation(request, state, listener);
     }
@@ -131,7 +132,7 @@ protected void masterOperation(ProtobufTask task, Request request, ProtobufClust
     protected void clusterManagerOperation(
         ProtobufTask task,
         Request request,
-        ProtobufClusterState state,
+        ClusterState state,
         ActionListener<Response> listener
     ) throws Exception {
         masterOperation(task, request, state, listener);
@@ -141,7 +142,7 @@ protected boolean localExecute(Request request) {
         return false;
     }
 
-    protected abstract ClusterBlockException checkBlock(Request request, ProtobufClusterState state);
+    protected abstract ClusterBlockException checkBlock(Request request, ClusterState state);
 
     @Override
     protected void doExecute(ProtobufTask task, final Request request, ActionListener<Response> listener) {
@@ -160,7 +161,7 @@ class AsyncSingleAction extends RetryableAction {
 
         private ActionListener<Response> listener;
         private final Request request;
-        private ProtobufClusterStateObserver observer;
+        private ClusterStateObserver observer;
         private final long startTime;
         private final ProtobufTask task;
 
@@ -184,7 +185,7 @@ class AsyncSingleAction extends RetryableAction {
 
         @Override
         public void tryAction(ActionListener retryListener) {
-            ProtobufClusterState state = clusterService.protobufState();
+            ClusterState state = clusterService.state();
             logger.trace("starting processing request [{}] with cluster state version [{}]", request, state.version());
             this.listener = retryListener;
             doStart(state);
@@ -213,7 +214,7 @@ public Exception getTimeoutException(Exception e) {
             return new ProcessClusterEventTimeoutException(request.masterNodeTimeout, actionName);
         }
 
-        protected void doStart(ProtobufClusterState clusterState) {
+        protected void doStart(ClusterState clusterState) {
             try {
                 System.out.println("ProtobufTransportClusterManagerNodeAction.doStart");
                 //this needs fixing
@@ -304,11 +305,11 @@ public void handleException(final ProtobufTransportException exp) {
             }
         }
 
-        private void retryOnMasterChange(ProtobufClusterState state, Throwable failure) {
-            retry(state, failure, ClusterManagerNodeChangePredicate.buildProtobuf(state));
+        private void retryOnMasterChange(ClusterState state, Throwable failure) {
+            retry(state, failure, ClusterManagerNodeChangePredicate.build(state));
         }
 
-        private void retry(ProtobufClusterState state, final Throwable failure, final Predicate<ProtobufClusterState> statePredicate) {
+        private void retry(ClusterState state, final Throwable failure, final Predicate<ClusterState> statePredicate) {
             if (observer == null) {
                 final long remainingTimeoutMS = request.clusterManagerNodeTimeout().millis() - (threadPool.relativeTimeInMillis()
                     - startTime);
@@ -317,7 +318,7 @@ private void retry(ProtobufClusterState state, final Throwable failure, final Pr
                     listener.onFailure(new ClusterManagerNotDiscoveredException(failure));
                     return;
                 }
-                this.observer = new ProtobufClusterStateObserver(
+                this.observer = new ClusterStateObserver(
                     state,
                     clusterService,
                     TimeValue.timeValueMillis(remainingTimeoutMS),
@@ -325,9 +326,9 @@ private void retry(ProtobufClusterState state, final Throwable failure, final Pr
                     threadPool.getThreadContext()
                 );
             }
-            observer.waitForNextChange(new ProtobufClusterStateObserver.Listener() {
+            observer.waitForNextChange(new ClusterStateObserver.Listener() {
                 @Override
-                public void onNewClusterState(ProtobufClusterState state) {
+                public void onNewClusterState(ClusterState state) {
                     doStart(state);
                 }
 
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeReadAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeReadAction.java
index 18475a6ce6283..f4fb0ed6fb03e 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeReadAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeReadAction.java
@@ -10,7 +10,7 @@
 
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.action.support.ProtobufActionFilters;
-import org.opensearch.cluster.metadata.ProtobufIndexNameExpressionResolver;
+import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.threadpool.ThreadPool;
@@ -33,7 +33,7 @@ protected ProtobufTransportClusterManagerNodeReadAction(
         ThreadPool threadPool,
         ProtobufActionFilters actionFilters,
         ProtobufWriteable.Reader<Request> request,
-        ProtobufIndexNameExpressionResolver indexNameExpressionResolver
+        IndexNameExpressionResolver indexNameExpressionResolver
     ) {
         this(actionName, true, transportService, clusterService, threadPool, actionFilters, request, indexNameExpressionResolver);
     }
@@ -46,7 +46,7 @@ protected ProtobufTransportClusterManagerNodeReadAction(
         ThreadPool threadPool,
         ProtobufActionFilters actionFilters,
         ProtobufWriteable.Reader<Request> request,
-        ProtobufIndexNameExpressionResolver indexNameExpressionResolver
+        IndexNameExpressionResolver indexNameExpressionResolver
     ) {
         super(
             actionName,
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterManagerNodeChangePredicate.java b/server/src/main/java/org/opensearch/cluster/ClusterManagerNodeChangePredicate.java
index 36efc16f00930..b5c65dacb9542 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterManagerNodeChangePredicate.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterManagerNodeChangePredicate.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.cluster;
 
-import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNode;
 
 import java.util.function.Predicate;
@@ -69,26 +68,4 @@ public static Predicate<ClusterState> build(ClusterState currentState) {
             return accept;
         };
     }
-
-    /**
-     * builds a predicate that will accept a cluster state only if it was generated after the current has
-     * (re-)joined the master
-     */
-    public static Predicate<ProtobufClusterState> buildProtobuf(ProtobufClusterState currentState) {
-        final long currentVersion = currentState.version();
-        final DiscoveryNode clusterManagerNode = currentState.nodes().getClusterManagerNode();
-        final String currentMasterId = clusterManagerNode == null ? null : clusterManagerNode.getEphemeralId();
-        return newState -> {
-            final DiscoveryNode newClusterManager = newState.nodes().getClusterManagerNode();
-            final boolean accept;
-            if (newClusterManager == null) {
-                accept = false;
-            } else if (newClusterManager.getEphemeralId().equals(currentMasterId) == false) {
-                accept = true;
-            } else {
-                accept = newState.version() > currentVersion;
-            }
-            return accept;
-        };
-    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterState.java b/server/src/main/java/org/opensearch/cluster/ClusterState.java
index e7c552dfdee60..ea400f7859cf7 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterState.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterState.java
@@ -32,6 +32,8 @@
 
 package org.opensearch.cluster;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
 
 import org.opensearch.cluster.block.ClusterBlock;
 import org.opensearch.cluster.block.ClusterBlocks;
@@ -54,6 +56,8 @@
 import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.core.common.io.stream.NamedWriteableAwareStreamInput;
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.VersionedNamedWriteable;
@@ -100,7 +104,7 @@
  *
  * @opensearch.internal
  */
-public class ClusterState implements ToXContentFragment, Diffable<ClusterState> {
+public class ClusterState implements ToXContentFragment, Diffable<ClusterState>, ProtobufDiffable<ClusterState> {
 
     public static final ClusterState EMPTY_STATE = builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).build();
 
@@ -749,6 +753,11 @@ public Diff<ClusterState> diff(ClusterState previousState) {
         return new ClusterStateDiff(previousState, this);
     }
 
+    @Override
+    public ProtobufDiff<ClusterState> protobufDiff(ClusterState previousState) {
+        return new ClusterStateDiffProtobuf(previousState, this);
+    }
+
     public static Diff<ClusterState> readDiffFrom(StreamInput in, DiscoveryNode localNode) throws IOException {
         return new ClusterStateDiff(in, localNode);
     }
@@ -771,27 +780,28 @@ public static ClusterState readFrom(StreamInput in, DiscoveryNode localNode) thr
         return builder.build();
     }
 
-    // public static ClusterState readFrom(CodedInputStream in, DiscoveryNode localNode) throws IOException {
-    // ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-    // ClusterName clusterName = new ClusterName(in);
-    // Builder builder = new Builder(clusterName);
-    // builder.version = in.readInt64();
-    // builder.uuid = in.readString();
-    // builder.metadata = Metadata.readFrom(in);
-    // builder.routingTable = RoutingTable.readFrom(in);
-    // builder.nodes = ProtobufDiscoveryNodes.readFrom(in, localNode);
-    // builder.blocks = ClusterBlocks.readFrom(in);
-    // int customSize = in.readInt32();
-    // for (int i = 0; i < customSize; i++) {
-    // Custom customIndexMetadata = protobufStreamInput.readNamedWriteable(Custom.class);
-    // builder.putCustom(customIndexMetadata.getWriteableName(), customIndexMetadata);
-    // }
-    // builder.minimumClusterManagerNodesOnPublishingClusterManager = in.readInt32();
-    // return builder.build();
-    // }
+    public static ClusterState readFrom(CodedInputStream in, DiscoveryNode localNode) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        ClusterName clusterName = new ClusterName(in);
+        Builder builder = new Builder(clusterName);
+        builder.version = in.readInt64();
+        builder.uuid = in.readString();
+        // builder.metadata = Metadata.readFrom(in);
+        // builder.routingTable = RoutingTable.readFrom(in);
+        builder.nodes = DiscoveryNodes.readFromProtobuf(in, localNode);
+        // builder.blocks = ClusterBlocks.readFrom(in);
+        int customSize = in.readInt32();
+        // for (int i = 0; i < customSize; i++) {
+        //     Custom customIndexMetadata = protobufStreamInput.readNamedWriteable(Custom.class);
+        //     builder.putCustom(customIndexMetadata.getWriteableName(), customIndexMetadata);
+        // }
+        builder.minimumClusterManagerNodesOnPublishingClusterManager = in.readInt32();
+        return builder.build();
+    }
 
     @Override
     public void writeTo(StreamOutput out) throws IOException {
+        System.out.println("writeTo");
         clusterName.writeTo(out);
         out.writeLong(version);
         out.writeString(stateUUID);
@@ -815,6 +825,33 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeVInt(minimumClusterManagerNodesOnPublishingClusterManager);
     }
 
+     @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        System.out.println("writeTo CodedOutputStream");
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        clusterName.writeTo(out);
+        out.writeInt64NoTag(version);
+        out.writeStringNoTag(stateUUID);
+        // metadata.writeTo(out);
+        // routingTable.writeTo(out);
+        nodes.writeTo(out);
+        // blocks.writeTo(out);
+        // filter out custom states not supported by the other node
+        int numberOfCustoms = 0;
+        // for (final ObjectCursor<Custom> cursor : customs.values()) {
+        //     if (FeatureAware.shouldSerialize(out, cursor.value)) {
+        //         numberOfCustoms++;
+        //     }
+        // }
+        out.writeInt32NoTag(numberOfCustoms);
+        // for (final ObjectCursor<Custom> cursor : customs.values()) {
+        //     if (FeatureAware.shouldSerialize(out, cursor.value)) {
+        //         protobufStreamOutput.writeNamedWriteable(cursor.value);
+        //     }
+        // }
+        out.writeInt32NoTag(minimumClusterManagerNodesOnPublishingClusterManager);
+    }
+
     /**
      * The cluster state diff.
      *
@@ -904,4 +941,105 @@ public ClusterState apply(ClusterState state) {
             return builder.build();
         }
     }
+
+    /**
+     * The cluster state diff.
+    *
+    * @opensearch.internal
+    */
+    private static class ClusterStateDiffProtobuf implements ProtobufDiff<ClusterState> {
+
+        private final long toVersion;
+
+        private final String fromUuid;
+
+        private final String toUuid;
+
+        private final ClusterName clusterName;
+
+        private final ProtobufDiff<RoutingTable> routingTable;
+
+        private final ProtobufDiff<DiscoveryNodes> nodes;
+
+        private final ProtobufDiff<Metadata> metadata;
+
+        private final ProtobufDiff<ClusterBlocks> blocks;
+
+        private final ProtobufDiff<ImmutableOpenMap<String, Custom>> customs;
+
+        private final int minimumClusterManagerNodesOnPublishingClusterManager;
+
+        ClusterStateDiffProtobuf(ClusterState before, ClusterState after) {
+            fromUuid = before.stateUUID;
+            toUuid = after.stateUUID;
+            toVersion = after.version;
+            clusterName = after.clusterName;
+            routingTable = null;
+            nodes = after.nodes.protobufDiff(before.nodes);;
+            metadata = null;
+            blocks = null;
+            // customs = ProtobufDiffableUtils.diff(
+            //     before.customs,
+            //     after.customs,
+            //     ProtobufDiffableUtils.getStringKeySerializer(),
+            //     CUSTOM_VALUE_SERIALIZER
+            // );
+            customs = null;
+            minimumClusterManagerNodesOnPublishingClusterManager = after.minimumClusterManagerNodesOnPublishingClusterManager;
+        }
+
+        ClusterStateDiffProtobuf(CodedInputStream in, DiscoveryNode localNode) throws IOException {
+            clusterName = new ClusterName(in);
+            fromUuid = in.readString();
+            toUuid = in.readString();
+            toVersion = in.readInt64();
+            routingTable = null;
+            nodes = DiscoveryNodes.readDiffFrom(in, localNode);
+            metadata = null;
+            blocks = null;
+            // customs = ProtobufDiffableUtils.readImmutableOpenMapDiff(
+            //     in,
+            //     ProtobufDiffableUtils.getStringKeySerializer(),
+            //     CUSTOM_VALUE_SERIALIZER
+            // );
+            customs = null;
+            minimumClusterManagerNodesOnPublishingClusterManager = in.readInt32();
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            clusterName.writeTo(out);
+            out.writeStringNoTag(fromUuid);
+            out.writeStringNoTag(toUuid);
+            out.writeInt64NoTag(toVersion);
+            // routingTable.writeTo(out);
+            nodes.writeTo(out);
+            // metadata.writeTo(out);
+            // blocks.writeTo(out);
+            // customs.writeTo(out);
+            // out.writeVInt(minimumClusterManagerNodesOnPublishingClusterManager);
+        }
+
+        @Override
+        public ClusterState apply(ClusterState state) {
+            Builder builder = new Builder(clusterName);
+            if (toUuid.equals(state.stateUUID)) {
+                // no need to read the rest - cluster state didn't change
+                return state;
+            }
+            if (fromUuid.equals(state.stateUUID) == false) {
+                throw new IncompatibleClusterStateVersionException(state.version, state.stateUUID, toVersion, fromUuid);
+            }
+            builder.stateUUID(toUuid);
+            builder.version(toVersion);
+            builder.routingTable(routingTable.apply(state.routingTable));
+            builder.nodes(nodes.apply(state.nodes));
+            builder.metadata(metadata.apply(state.metadata));
+            builder.blocks(blocks.apply(state.blocks));
+            builder.customs(customs.apply(state.customs));
+            builder.minimumClusterManagerNodesOnPublishingClusterManager(minimumClusterManagerNodesOnPublishingClusterManager);
+            builder.fromDiff(true);
+            return builder.build();
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterChangedEvent.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterChangedEvent.java
index eab4bade647fe..ca58668147e26 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufClusterChangedEvent.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufClusterChangedEvent.java
@@ -1,308 +1,308 @@
-/*
-* 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.
-*/
-
-package org.opensearch.cluster;
-
-import org.opensearch.cluster.metadata.IndexGraveyard;
-import org.opensearch.cluster.metadata.IndexGraveyard.IndexGraveyardDiff;
-import org.opensearch.cluster.metadata.IndexMetadata;
-import org.opensearch.cluster.metadata.Metadata;
-import org.opensearch.cluster.node.DiscoveryNodes;
-import org.opensearch.cluster.node.DiscoveryNodes;
-import org.opensearch.gateway.GatewayService;
-import org.opensearch.index.Index;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-/**
- * An event received by the local node, signaling that the cluster state has changed.
-*
-* @opensearch.internal
-*/
-public class ProtobufClusterChangedEvent {
-
-    private final String source;
-
-    private final ProtobufClusterState previousState;
-
-    private final ProtobufClusterState state;
-
-    private final DiscoveryNodes.Delta nodesDelta;
-
-    public ProtobufClusterChangedEvent(String source, ProtobufClusterState state, ProtobufClusterState previousState) {
-        Objects.requireNonNull(source, "source must not be null");
-        Objects.requireNonNull(state, "state must not be null");
-        Objects.requireNonNull(previousState, "previousState must not be null");
-        this.source = source;
-        this.state = state;
-        this.previousState = previousState;
-        this.nodesDelta = state.nodes().delta(previousState.nodes());
-    }
-
-    /**
-     * The source that caused this cluster event to be raised.
-    */
-    public String source() {
-        return this.source;
-    }
-
-    /**
-     * The new cluster state that caused this change event.
-    */
-    public ProtobufClusterState state() {
-        return this.state;
-    }
-
-    /**
-     * The previous cluster state for this change event.
-    */
-    public ProtobufClusterState previousState() {
-        return this.previousState;
-    }
-
-    /**
-     * Returns <code>true</code> iff the routing tables (for all indices) have
-    * changed between the previous cluster state and the current cluster state.
-    * Note that this is an object reference equality test, not an equals test.
-    */
-    public boolean routingTableChanged() {
-        return state.routingTable() != previousState.routingTable();
-    }
-
-    /**
-     * Returns <code>true</code> iff the routing table has changed for the given index.
-    * Note that this is an object reference equality test, not an equals test.
-    */
-    public boolean indexRoutingTableChanged(String index) {
-        Objects.requireNonNull(index, "index must not be null");
-        if (!state.routingTable().hasIndex(index) && !previousState.routingTable().hasIndex(index)) {
-            return false;
-        }
-        if (state.routingTable().hasIndex(index) && previousState.routingTable().hasIndex(index)) {
-            return state.routingTable().index(index) != previousState.routingTable().index(index);
-        }
-        return true;
-    }
-
-    /**
-     * Returns the indices created in this event
-    */
-    public List<String> indicesCreated() {
-        if (!metadataChanged()) {
-            return Collections.emptyList();
-        }
-        List<String> created = null;
-        for (final String index : state.metadata().indices().keySet()) {
-            if (!previousState.metadata().hasIndex(index)) {
-                if (created == null) {
-                    created = new ArrayList<>();
-                }
-                created.add(index);
-            }
-        }
-        return created == null ? Collections.<String>emptyList() : created;
-    }
-
-    /**
-     * Returns the indices deleted in this event
-    */
-    public List<Index> indicesDeleted() {
-        if (previousState.blocks().hasGlobalBlock(GatewayService.STATE_NOT_RECOVERED_BLOCK)) {
-            // working off of a non-initialized previous state, so use the tombstones for index deletions
-            return indicesDeletedFromTombstones();
-        } else {
-            // examine the diffs in index metadata between the previous and new cluster states to get the deleted indices
-            return indicesDeletedFromClusterState();
-        }
-    }
-
-    /**
-     * Returns <code>true</code> iff the metadata for the cluster has changed between
-    * the previous cluster state and the new cluster state. Note that this is an object
-    * reference equality test, not an equals test.
-    */
-    public boolean metadataChanged() {
-        return state.metadata() != previousState.metadata();
-    }
-
-    /**
-     * Returns a set of custom meta data types when any custom metadata for the cluster has changed
-    * between the previous cluster state and the new cluster state. custom meta data types are
-    * returned iff they have been added, updated or removed between the previous and the current state
-    */
-    public Set<String> changedCustomMetadataSet() {
-        Set<String> result = new HashSet<>();
-        Map<String, Metadata.Custom> currentCustoms = state.metadata().customs();
-        Map<String, Metadata.Custom> previousCustoms = previousState.metadata().customs();
-        if (currentCustoms.equals(previousCustoms) == false) {
-            for (Map.Entry<String, Metadata.Custom> currentCustomMetadata : currentCustoms.entrySet()) {
-                // new custom md added or existing custom md changed
-                if (previousCustoms.containsKey(currentCustomMetadata.getKey()) == false
-                    || currentCustomMetadata.getValue().equals(previousCustoms.get(currentCustomMetadata.getKey())) == false) {
-                    result.add(currentCustomMetadata.getKey());
-                }
-            }
-            // existing custom md deleted
-            for (Map.Entry<String, Metadata.Custom> previousCustomMetadata : previousCustoms.entrySet()) {
-                if (currentCustoms.containsKey(previousCustomMetadata.getKey()) == false) {
-                    result.add(previousCustomMetadata.getKey());
-                }
-            }
-        }
-        return result;
-    }
-
-    /**
-     * Returns <code>true</code> iff the {@link IndexMetadata} for a given index
-    * has changed between the previous cluster state and the new cluster state.
-    * Note that this is an object reference equality test, not an equals test.
-    */
-    public static boolean indexMetadataChanged(IndexMetadata metadata1, IndexMetadata metadata2) {
-        assert metadata1 != null && metadata2 != null;
-        // no need to check on version, since disco modules will make sure to use the
-        // same instance if its a version match
-        return metadata1 != metadata2;
-    }
-
-    /**
-     * Returns <code>true</code> iff the cluster level blocks have changed between cluster states.
-    * Note that this is an object reference equality test, not an equals test.
-    */
-    public boolean blocksChanged() {
-        return state.blocks() != previousState.blocks();
-    }
-
-    /**
-     * Returns <code>true</code> iff the local node is the mater node of the cluster.
-    */
-    public boolean localNodeClusterManager() {
-        return state.nodes().isLocalNodeElectedClusterManager();
-    }
-
-    /**
-     * Returns <code>true</code> iff the local node is the mater node of the cluster.
-    *
-    * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #localNodeClusterManager()}
-    */
-    @Deprecated
-    public boolean localNodeMaster() {
-        return localNodeClusterManager();
-    }
-
-    /**
-     * Returns the {@link org.opensearch.cluster.node.DiscoveryNodes.Delta} between
-    * the previous cluster state and the new cluster state.
-    */
-    public DiscoveryNodes.Delta nodesDelta() {
-        return this.nodesDelta;
-    }
-
-    /**
-     * Returns <code>true</code> iff nodes have been removed from the cluster since the last cluster state.
-    */
-    public boolean nodesRemoved() {
-        return nodesDelta.removed();
-    }
-
-    /**
-     * Returns <code>true</code> iff nodes have been added from the cluster since the last cluster state.
-    */
-    public boolean nodesAdded() {
-        return nodesDelta.added();
-    }
-
-    /**
-     * Returns <code>true</code> iff nodes have been changed (added or removed) from the cluster since the last cluster state.
-    */
-    public boolean nodesChanged() {
-        return nodesRemoved() || nodesAdded();
-    }
-
-    /**
-     * Determines whether or not the current cluster state represents an entirely
-    * new cluster, either when a node joins a cluster for the first time or when
-    * the node receives a cluster state update from a brand new cluster (different
-    * UUID from the previous cluster), which will happen when a cluster-manager node is
-    * elected that has never been part of the cluster before.
-    */
-    public boolean isNewCluster() {
-        final String prevClusterUUID = previousState.metadata().clusterUUID();
-        final String currClusterUUID = state.metadata().clusterUUID();
-        return prevClusterUUID.equals(currClusterUUID) == false;
-    }
-
-    // Get the deleted indices by comparing the index metadatas in the previous and new cluster states.
-    // If an index exists in the previous cluster state, but not in the new cluster state, it must have been deleted.
-    private List<Index> indicesDeletedFromClusterState() {
-        // If the new cluster state has a new cluster UUID, the likely scenario is that a node was elected cluster-manager
-        // that has had its data directory wiped out, in which case we don't want to delete the indices and lose data;
-        // rather we want to import them as dangling indices instead. So we check here if the cluster UUID differs from the previous
-        // cluster UUID, in which case, we don't want to delete indices that the cluster-manager erroneously believes shouldn't exist.
-        // See test DiscoveryWithServiceDisruptionsIT.testIndicesDeleted()
-        // See discussion on https://github.com/elastic/elasticsearch/pull/9952 and
-        // https://github.com/elastic/elasticsearch/issues/11665
-        if (metadataChanged() == false || isNewCluster()) {
-            return Collections.emptyList();
-        }
-        Set<Index> deleted = null;
-        final Metadata previousMetadata = previousState.metadata();
-        final Metadata currentMetadata = state.metadata();
-
-        for (final IndexMetadata index : previousMetadata.indices().values()) {
-            IndexMetadata current = currentMetadata.index(index.getIndex());
-            if (current == null) {
-                if (deleted == null) {
-                    deleted = new HashSet<>();
-                }
-                deleted.add(index.getIndex());
-            }
-        }
-
-        final IndexGraveyard currentGraveyard = currentMetadata.indexGraveyard();
-        final IndexGraveyard previousGraveyard = previousMetadata.indexGraveyard();
-
-        // Look for new entries in the index graveyard, where there's no corresponding index in the
-        // previous metadata. This indicates that a dangling index has been explicitly deleted, so
-        // each node should make sure to delete any related data.
-        if (currentGraveyard != previousGraveyard) {
-            final IndexGraveyardDiff indexGraveyardDiff = (IndexGraveyardDiff) currentGraveyard.diff(previousGraveyard);
-
-            final List<IndexGraveyard.Tombstone> added = indexGraveyardDiff.getAdded();
-
-            if (added.isEmpty() == false) {
-                if (deleted == null) {
-                    deleted = new HashSet<>();
-                }
-                for (IndexGraveyard.Tombstone tombstone : added) {
-                    deleted.add(tombstone.getIndex());
-                }
-            }
-        }
-
-        return deleted == null ? Collections.<Index>emptyList() : new ArrayList<>(deleted);
-    }
-
-    private List<Index> indicesDeletedFromTombstones() {
-        // We look at the full tombstones list to see which indices need to be deleted. In the case of
-        // a valid previous cluster state, indicesDeletedFromClusterState() will be used to get the deleted
-        // list, so a diff doesn't make sense here. When a node (re)joins the cluster, its possible for it
-        // to re-process the same deletes or process deletes about indices it never knew about. This is not
-        // an issue because there are safeguards in place in the delete store operation in case the index
-        // folder doesn't exist on the file system.
-        List<IndexGraveyard.Tombstone> tombstones = state.metadata().indexGraveyard().getTombstones();
-        return tombstones.stream().map(IndexGraveyard.Tombstone::getIndex).collect(Collectors.toList());
-    }
-
-}
+// /*
+// * 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.
+// */
+
+// package org.opensearch.cluster;
+
+// import org.opensearch.cluster.metadata.IndexGraveyard;
+// import org.opensearch.cluster.metadata.IndexGraveyard.IndexGraveyardDiff;
+// import org.opensearch.cluster.metadata.IndexMetadata;
+// import org.opensearch.cluster.metadata.Metadata;
+// import org.opensearch.cluster.node.DiscoveryNodes;
+// import org.opensearch.cluster.node.DiscoveryNodes;
+// import org.opensearch.gateway.GatewayService;
+// import org.opensearch.index.Index;
+
+// import java.util.ArrayList;
+// import java.util.Collections;
+// import java.util.HashSet;
+// import java.util.List;
+// import java.util.Map;
+// import java.util.Objects;
+// import java.util.Set;
+// import java.util.stream.Collectors;
+
+// /**
+//  * An event received by the local node, signaling that the cluster state has changed.
+// *
+// * @opensearch.internal
+// */
+// public class ProtobufClusterChangedEvent {
+
+//     private final String source;
+
+//     private final ProtobufClusterState previousState;
+
+//     private final ProtobufClusterState state;
+
+//     private final DiscoveryNodes.Delta nodesDelta;
+
+//     public ProtobufClusterChangedEvent(String source, ProtobufClusterState state, ProtobufClusterState previousState) {
+//         Objects.requireNonNull(source, "source must not be null");
+//         Objects.requireNonNull(state, "state must not be null");
+//         Objects.requireNonNull(previousState, "previousState must not be null");
+//         this.source = source;
+//         this.state = state;
+//         this.previousState = previousState;
+//         this.nodesDelta = state.nodes().delta(previousState.nodes());
+//     }
+
+//     /**
+//      * The source that caused this cluster event to be raised.
+//     */
+//     public String source() {
+//         return this.source;
+//     }
+
+//     /**
+//      * The new cluster state that caused this change event.
+//     */
+//     public ProtobufClusterState state() {
+//         return this.state;
+//     }
+
+//     /**
+//      * The previous cluster state for this change event.
+//     */
+//     public ProtobufClusterState previousState() {
+//         return this.previousState;
+//     }
+
+//     /**
+//      * Returns <code>true</code> iff the routing tables (for all indices) have
+//     * changed between the previous cluster state and the current cluster state.
+//     * Note that this is an object reference equality test, not an equals test.
+//     */
+//     public boolean routingTableChanged() {
+//         return state.routingTable() != previousState.routingTable();
+//     }
+
+//     /**
+//      * Returns <code>true</code> iff the routing table has changed for the given index.
+//     * Note that this is an object reference equality test, not an equals test.
+//     */
+//     public boolean indexRoutingTableChanged(String index) {
+//         Objects.requireNonNull(index, "index must not be null");
+//         if (!state.routingTable().hasIndex(index) && !previousState.routingTable().hasIndex(index)) {
+//             return false;
+//         }
+//         if (state.routingTable().hasIndex(index) && previousState.routingTable().hasIndex(index)) {
+//             return state.routingTable().index(index) != previousState.routingTable().index(index);
+//         }
+//         return true;
+//     }
+
+//     /**
+//      * Returns the indices created in this event
+//     */
+//     public List<String> indicesCreated() {
+//         if (!metadataChanged()) {
+//             return Collections.emptyList();
+//         }
+//         List<String> created = null;
+//         for (final String index : state.metadata().indices().keySet()) {
+//             if (!previousState.metadata().hasIndex(index)) {
+//                 if (created == null) {
+//                     created = new ArrayList<>();
+//                 }
+//                 created.add(index);
+//             }
+//         }
+//         return created == null ? Collections.<String>emptyList() : created;
+//     }
+
+//     /**
+//      * Returns the indices deleted in this event
+//     */
+//     public List<Index> indicesDeleted() {
+//         if (previousState.blocks().hasGlobalBlock(GatewayService.STATE_NOT_RECOVERED_BLOCK)) {
+//             // working off of a non-initialized previous state, so use the tombstones for index deletions
+//             return indicesDeletedFromTombstones();
+//         } else {
+//             // examine the diffs in index metadata between the previous and new cluster states to get the deleted indices
+//             return indicesDeletedFromClusterState();
+//         }
+//     }
+
+//     /**
+//      * Returns <code>true</code> iff the metadata for the cluster has changed between
+//     * the previous cluster state and the new cluster state. Note that this is an object
+//     * reference equality test, not an equals test.
+//     */
+//     public boolean metadataChanged() {
+//         return state.metadata() != previousState.metadata();
+//     }
+
+//     /**
+//      * Returns a set of custom meta data types when any custom metadata for the cluster has changed
+//     * between the previous cluster state and the new cluster state. custom meta data types are
+//     * returned iff they have been added, updated or removed between the previous and the current state
+//     */
+//     public Set<String> changedCustomMetadataSet() {
+//         Set<String> result = new HashSet<>();
+//         Map<String, Metadata.Custom> currentCustoms = state.metadata().customs();
+//         Map<String, Metadata.Custom> previousCustoms = previousState.metadata().customs();
+//         if (currentCustoms.equals(previousCustoms) == false) {
+//             for (Map.Entry<String, Metadata.Custom> currentCustomMetadata : currentCustoms.entrySet()) {
+//                 // new custom md added or existing custom md changed
+//                 if (previousCustoms.containsKey(currentCustomMetadata.getKey()) == false
+//                     || currentCustomMetadata.getValue().equals(previousCustoms.get(currentCustomMetadata.getKey())) == false) {
+//                     result.add(currentCustomMetadata.getKey());
+//                 }
+//             }
+//             // existing custom md deleted
+//             for (Map.Entry<String, Metadata.Custom> previousCustomMetadata : previousCustoms.entrySet()) {
+//                 if (currentCustoms.containsKey(previousCustomMetadata.getKey()) == false) {
+//                     result.add(previousCustomMetadata.getKey());
+//                 }
+//             }
+//         }
+//         return result;
+//     }
+
+//     /**
+//      * Returns <code>true</code> iff the {@link IndexMetadata} for a given index
+//     * has changed between the previous cluster state and the new cluster state.
+//     * Note that this is an object reference equality test, not an equals test.
+//     */
+//     public static boolean indexMetadataChanged(IndexMetadata metadata1, IndexMetadata metadata2) {
+//         assert metadata1 != null && metadata2 != null;
+//         // no need to check on version, since disco modules will make sure to use the
+//         // same instance if its a version match
+//         return metadata1 != metadata2;
+//     }
+
+//     /**
+//      * Returns <code>true</code> iff the cluster level blocks have changed between cluster states.
+//     * Note that this is an object reference equality test, not an equals test.
+//     */
+//     public boolean blocksChanged() {
+//         return state.blocks() != previousState.blocks();
+//     }
+
+//     /**
+//      * Returns <code>true</code> iff the local node is the mater node of the cluster.
+//     */
+//     public boolean localNodeClusterManager() {
+//         return state.nodes().isLocalNodeElectedClusterManager();
+//     }
+
+//     /**
+//      * Returns <code>true</code> iff the local node is the mater node of the cluster.
+//     *
+//     * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #localNodeClusterManager()}
+//     */
+//     @Deprecated
+//     public boolean localNodeMaster() {
+//         return localNodeClusterManager();
+//     }
+
+//     /**
+//      * Returns the {@link org.opensearch.cluster.node.DiscoveryNodes.Delta} between
+//     * the previous cluster state and the new cluster state.
+//     */
+//     public DiscoveryNodes.Delta nodesDelta() {
+//         return this.nodesDelta;
+//     }
+
+//     /**
+//      * Returns <code>true</code> iff nodes have been removed from the cluster since the last cluster state.
+//     */
+//     public boolean nodesRemoved() {
+//         return nodesDelta.removed();
+//     }
+
+//     /**
+//      * Returns <code>true</code> iff nodes have been added from the cluster since the last cluster state.
+//     */
+//     public boolean nodesAdded() {
+//         return nodesDelta.added();
+//     }
+
+//     /**
+//      * Returns <code>true</code> iff nodes have been changed (added or removed) from the cluster since the last cluster state.
+//     */
+//     public boolean nodesChanged() {
+//         return nodesRemoved() || nodesAdded();
+//     }
+
+//     /**
+//      * Determines whether or not the current cluster state represents an entirely
+//     * new cluster, either when a node joins a cluster for the first time or when
+//     * the node receives a cluster state update from a brand new cluster (different
+//     * UUID from the previous cluster), which will happen when a cluster-manager node is
+//     * elected that has never been part of the cluster before.
+//     */
+//     public boolean isNewCluster() {
+//         final String prevClusterUUID = previousState.metadata().clusterUUID();
+//         final String currClusterUUID = state.metadata().clusterUUID();
+//         return prevClusterUUID.equals(currClusterUUID) == false;
+//     }
+
+//     // Get the deleted indices by comparing the index metadatas in the previous and new cluster states.
+//     // If an index exists in the previous cluster state, but not in the new cluster state, it must have been deleted.
+//     private List<Index> indicesDeletedFromClusterState() {
+//         // If the new cluster state has a new cluster UUID, the likely scenario is that a node was elected cluster-manager
+//         // that has had its data directory wiped out, in which case we don't want to delete the indices and lose data;
+//         // rather we want to import them as dangling indices instead. So we check here if the cluster UUID differs from the previous
+//         // cluster UUID, in which case, we don't want to delete indices that the cluster-manager erroneously believes shouldn't exist.
+//         // See test DiscoveryWithServiceDisruptionsIT.testIndicesDeleted()
+//         // See discussion on https://github.com/elastic/elasticsearch/pull/9952 and
+//         // https://github.com/elastic/elasticsearch/issues/11665
+//         if (metadataChanged() == false || isNewCluster()) {
+//             return Collections.emptyList();
+//         }
+//         Set<Index> deleted = null;
+//         final Metadata previousMetadata = previousState.metadata();
+//         final Metadata currentMetadata = state.metadata();
+
+//         for (final IndexMetadata index : previousMetadata.indices().values()) {
+//             IndexMetadata current = currentMetadata.index(index.getIndex());
+//             if (current == null) {
+//                 if (deleted == null) {
+//                     deleted = new HashSet<>();
+//                 }
+//                 deleted.add(index.getIndex());
+//             }
+//         }
+
+//         final IndexGraveyard currentGraveyard = currentMetadata.indexGraveyard();
+//         final IndexGraveyard previousGraveyard = previousMetadata.indexGraveyard();
+
+//         // Look for new entries in the index graveyard, where there's no corresponding index in the
+//         // previous metadata. This indicates that a dangling index has been explicitly deleted, so
+//         // each node should make sure to delete any related data.
+//         if (currentGraveyard != previousGraveyard) {
+//             final IndexGraveyardDiff indexGraveyardDiff = (IndexGraveyardDiff) currentGraveyard.diff(previousGraveyard);
+
+//             final List<IndexGraveyard.Tombstone> added = indexGraveyardDiff.getAdded();
+
+//             if (added.isEmpty() == false) {
+//                 if (deleted == null) {
+//                     deleted = new HashSet<>();
+//                 }
+//                 for (IndexGraveyard.Tombstone tombstone : added) {
+//                     deleted.add(tombstone.getIndex());
+//                 }
+//             }
+//         }
+
+//         return deleted == null ? Collections.<Index>emptyList() : new ArrayList<>(deleted);
+//     }
+
+//     private List<Index> indicesDeletedFromTombstones() {
+//         // We look at the full tombstones list to see which indices need to be deleted. In the case of
+//         // a valid previous cluster state, indicesDeletedFromClusterState() will be used to get the deleted
+//         // list, so a diff doesn't make sense here. When a node (re)joins the cluster, its possible for it
+//         // to re-process the same deletes or process deletes about indices it never knew about. This is not
+//         // an issue because there are safeguards in place in the delete store operation in case the index
+//         // folder doesn't exist on the file system.
+//         List<IndexGraveyard.Tombstone> tombstones = state.metadata().indexGraveyard().getTombstones();
+//         return tombstones.stream().map(IndexGraveyard.Tombstone::getIndex).collect(Collectors.toList());
+//     }
+
+// }
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java
index b2354e5714494..4bfd0ab460719 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java
@@ -56,7 +56,7 @@
 
 import static org.opensearch.cluster.coordination.Coordinator.ZEN1_BWC_TERM;
 
-/**
+/** not used
  * Represents the current state of the cluster.
 * <p>
 * The cluster state object is immutable with the exception of the {@link RoutingNodes} structure, which is
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateApplier.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateApplier.java
index 3d502f396c0c6..ed3abc2165943 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateApplier.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateApplier.java
@@ -1,29 +1,29 @@
-/*
-* 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.
-*/
+// /*
+// * 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.
+// */
 
-package org.opensearch.cluster;
+// package org.opensearch.cluster;
 
-import org.opensearch.cluster.service.ClusterService;
+// import org.opensearch.cluster.service.ClusterService;
 
-/**
- * A component that is in charge of applying an incoming cluster state to the node internal data structures.
-* The single apply method is called before the cluster state becomes visible via {@link ClusterService#state()}.
-*
-* @opensearch.internal
-*/
-public interface ProtobufClusterStateApplier {
+// /**
+//  * A component that is in charge of applying an incoming cluster state to the node internal data structures.
+// * The single apply method is called before the cluster state becomes visible via {@link ClusterService#state()}.
+// *
+// * @opensearch.internal
+// */
+// public interface ProtobufClusterStateApplier {
 
-    /**
-     * Called when a new cluster state ({@link ProtobufClusterChangedEvent#state()} needs to be applied. The cluster state to be applied is already
-    * committed when this method is called, so an applier must therefore be prepared to deal with any state it receives without throwing
-    * an exception. Throwing an exception from an applier is very bad because it will stop the application of this state before it has
-    * reached all the other appliers, and will likely result in another attempt to apply the same (or very similar) cluster state which
-    * might continue until this node is removed from the cluster.
-    */
-    void applyProtobufClusterState(ProtobufClusterChangedEvent event);
-}
+//     /**
+//      * Called when a new cluster state ({@link ProtobufClusterChangedEvent#state()} needs to be applied. The cluster state to be applied is already
+//     * committed when this method is called, so an applier must therefore be prepared to deal with any state it receives without throwing
+//     * an exception. Throwing an exception from an applier is very bad because it will stop the application of this state before it has
+//     * reached all the other appliers, and will likely result in another attempt to apply the same (or very similar) cluster state which
+//     * might continue until this node is removed from the cluster.
+//     */
+//     void applyProtobufClusterState(ProtobufClusterChangedEvent event);
+// }
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateListener.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateListener.java
index b5638d6de0611..eb22a3aa01b7e 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateListener.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateListener.java
@@ -1,22 +1,22 @@
-/*
- * 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.
- */
+// /*
+//  * 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.
+//  */
 
-package org.opensearch.cluster;
+// package org.opensearch.cluster;
 
-/**
- * A listener to be notified when a cluster state changes.
- *
- * @opensearch.internal
- */
-public interface ProtobufClusterStateListener {
+// /**
+//  * A listener to be notified when a cluster state changes.
+//  *
+//  * @opensearch.internal
+//  */
+// public interface ProtobufClusterStateListener {
 
-    /**
-     * Called when cluster state changes.
-     */
-    void clusterChanged(ProtobufClusterChangedEvent event);
-}
+//     /**
+//      * Called when cluster state changes.
+//      */
+//     void clusterChanged(ProtobufClusterChangedEvent event);
+// }
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateObserver.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateObserver.java
index ca453f239bf01..a551df93bd80d 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateObserver.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateObserver.java
@@ -1,384 +1,384 @@
-/*
- * 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.
- */
-
-package org.opensearch.cluster;
-
-import org.apache.logging.log4j.Logger;
-import org.opensearch.OpenSearchException;
-import org.opensearch.cluster.service.ClusterApplierService;
-import org.opensearch.cluster.service.ClusterService;
-import org.opensearch.common.Nullable;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.threadpool.ThreadPool;
-
-import java.util.Objects;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.Predicate;
-import java.util.function.Supplier;
-
-/**
- * A utility class which simplifies interacting with the cluster state in cases where
- * one tries to take action based on the current state but may want to wait for a new state
- * and retry upon failure.
- *
- * @opensearch.internal
- */
-public class ProtobufClusterStateObserver {
-
-    protected final Logger logger;
-
-    private final Predicate<ProtobufClusterState> MATCH_ALL_CHANGES_PREDICATE = state -> true;
-
-    private final ClusterApplierService clusterApplierService;
-    private final ThreadPool threadPool;
-    private final ThreadContext contextHolder;
-    volatile TimeValue timeOutValue;
-
-    final AtomicReference<StoredState> lastObservedState;
-    final ProtobufTimeoutClusterStateListener clusterStateListener = new ObserverClusterStateListener();
-    // observingContext is not null when waiting on cluster state changes
-    final AtomicReference<ObservingContext> observingContext = new AtomicReference<>(null);
-    volatile Long startTimeMS;
-    volatile boolean timedOut;
-
-    public ProtobufClusterStateObserver(ClusterService clusterService, Logger logger, ThreadContext contextHolder) {
-        this(clusterService, new TimeValue(60000), logger, contextHolder);
-    }
-
-    /**
-     * @param timeout        a global timeout for this observer. After it has expired the observer
-     *                       will fail any existing or new #waitForNextChange calls. Set to null
-     *                       to wait indefinitely
-     */
-    public ProtobufClusterStateObserver(
-        ClusterService clusterService,
-        @Nullable TimeValue timeout,
-        Logger logger,
-        ThreadContext contextHolder
-    ) {
-        this(clusterService.protobufState(), clusterService, timeout, logger, contextHolder);
-    }
-
-    /**
-     * @param timeout        a global timeout for this observer. After it has expired the observer
-     *                       will fail any existing or new #waitForNextChange calls. Set to null
-     *                       to wait indefinitely
-     */
-    public ProtobufClusterStateObserver(
-        ProtobufClusterState initialState,
-        ClusterService clusterService,
-        @Nullable TimeValue timeout,
-        Logger logger,
-        ThreadContext contextHolder
-    ) {
-        this(initialState, clusterService.getClusterApplierService(), timeout, logger, contextHolder);
-    }
-
-    public ProtobufClusterStateObserver(
-        ProtobufClusterState initialState,
-        ClusterApplierService clusterApplierService,
-        @Nullable TimeValue timeout,
-        Logger logger,
-        ThreadContext contextHolder
-    ) {
-        this.clusterApplierService = clusterApplierService;
-        this.threadPool = clusterApplierService.threadPool();
-        this.lastObservedState = new AtomicReference<>(new StoredState(initialState));
-        this.timeOutValue = timeout;
-        if (timeOutValue != null) {
-            this.startTimeMS = threadPool.relativeTimeInMillis();
-        }
-        this.logger = logger;
-        this.contextHolder = contextHolder;
-    }
-
-    /** sets the last observed state to the currently applied cluster state and returns it */
-    public ProtobufClusterState setAndGetObservedState() {
-        if (observingContext.get() != null) {
-            throw new OpenSearchException("cannot set current cluster state while waiting for a cluster state change");
-        }
-        ProtobufClusterState clusterState = clusterApplierService.protobufState();
-        lastObservedState.set(new StoredState(clusterState));
-        return clusterState;
-    }
-
-    /** indicates whether this observer has timed out */
-    public boolean isTimedOut() {
-        return timedOut;
-    }
-
-    public void waitForNextChange(Listener listener) {
-        waitForNextChange(listener, MATCH_ALL_CHANGES_PREDICATE);
-    }
-
-    public void waitForNextChange(Listener listener, @Nullable TimeValue timeOutValue) {
-        waitForNextChange(listener, MATCH_ALL_CHANGES_PREDICATE, timeOutValue);
-    }
-
-    public void waitForNextChange(Listener listener, Predicate<ProtobufClusterState> statePredicate) {
-        waitForNextChange(listener, statePredicate, null);
-    }
-
-    /**
-     * Wait for the next cluster state which satisfies statePredicate
-     *
-     * @param listener        callback listener
-     * @param statePredicate predicate to check whether cluster state changes are relevant and the callback should be called
-     * @param timeOutValue    a timeout for waiting. If null the global observer timeout will be used.
-     */
-    public void waitForNextChange(Listener listener, Predicate<ProtobufClusterState> statePredicate, @Nullable TimeValue timeOutValue) {
-        listener = new ContextPreservingListener(listener, contextHolder.newRestorableContext(false));
-        if (observingContext.get() != null) {
-            throw new OpenSearchException("already waiting for a cluster state change");
-        }
-
-        Long timeoutTimeLeftMS;
-        if (timeOutValue == null) {
-            timeOutValue = this.timeOutValue;
-            if (timeOutValue != null) {
-                long timeSinceStartMS = threadPool.relativeTimeInMillis() - startTimeMS;
-                timeoutTimeLeftMS = timeOutValue.millis() - timeSinceStartMS;
-                if (timeoutTimeLeftMS <= 0L) {
-                    // things have timeout while we were busy -> notify
-                    logger.trace(
-                        "observer timed out. notifying listener. timeout setting [{}], time since start [{}]",
-                        timeOutValue,
-                        new TimeValue(timeSinceStartMS)
-                    );
-                    // update to latest, in case people want to retry
-                    timedOut = true;
-                    lastObservedState.set(new StoredState(clusterApplierService.protobufState()));
-                    listener.onTimeout(timeOutValue);
-                    return;
-                }
-            } else {
-                timeoutTimeLeftMS = null;
-            }
-        } else {
-            this.startTimeMS = threadPool.relativeTimeInMillis();
-            this.timeOutValue = timeOutValue;
-            timeoutTimeLeftMS = timeOutValue.millis();
-            timedOut = false;
-        }
-
-        // sample a new state. This state maybe *older* than the supplied state if we are called from an applier,
-        // which wants to wait for something else to happen
-        ProtobufClusterState newState = clusterApplierService.protobufState();
-        if (lastObservedState.get().isOlderOrDifferentClusterManager(newState) && statePredicate.test(newState)) {
-            // good enough, let's go.
-            logger.trace("observer: sampled state accepted by predicate ({})", newState);
-            lastObservedState.set(new StoredState(newState));
-            listener.onNewClusterState(newState);
-        } else {
-            logger.trace("observer: sampled state rejected by predicate ({}). adding listener to ClusterService", newState);
-            final ObservingContext context = new ObservingContext(listener, statePredicate);
-            if (!observingContext.compareAndSet(null, context)) {
-                throw new OpenSearchException("already waiting for a cluster state change");
-            }
-            // clusterApplierService.addTimeoutListener(
-            // timeoutTimeLeftMS == null ? null : new TimeValue(timeoutTimeLeftMS),
-            // clusterStateListener
-            // );
-        }
-    }
-
-    /**
-     * An observer of the cluster state for changes.
-     *
-     * @opensearch.internal
-     */
-    class ObserverClusterStateListener implements ProtobufTimeoutClusterStateListener {
-
-        @Override
-        public void clusterChanged(ProtobufClusterChangedEvent event) {
-            ObservingContext context = observingContext.get();
-            if (context == null) {
-                // No need to remove listener as it is the responsibility of the thread that set observingContext to null
-                return;
-            }
-            final ProtobufClusterState state = event.state();
-            if (context.statePredicate.test(state)) {
-                if (observingContext.compareAndSet(context, null)) {
-                    // clusterApplierService.removeTimeoutListener(this);
-                    logger.trace("observer: accepting cluster state change ({})", state);
-                    lastObservedState.set(new StoredState(state));
-                    context.listener.onNewClusterState(state);
-                } else {
-                    logger.trace(
-                        "observer: predicate approved change but observing context has changed "
-                            + "- ignoring (new cluster state version [{}])",
-                        state.version()
-                    );
-                }
-            } else {
-                logger.trace("observer: predicate rejected change (new cluster state version [{}])", state.version());
-            }
-        }
-
-        @Override
-        public void postAdded() {
-            ObservingContext context = observingContext.get();
-            if (context == null) {
-                // No need to remove listener as it is the responsibility of the thread that set observingContext to null
-                return;
-            }
-            ProtobufClusterState newState = clusterApplierService.protobufState();
-            if (lastObservedState.get().isOlderOrDifferentClusterManager(newState) && context.statePredicate.test(newState)) {
-                // double check we're still listening
-                if (observingContext.compareAndSet(context, null)) {
-                    logger.trace("observer: post adding listener: accepting current cluster state ({})", newState);
-                    // clusterApplierService.removeTimeoutListener(this);
-                    lastObservedState.set(new StoredState(newState));
-                    context.listener.onNewClusterState(newState);
-                } else {
-                    logger.trace(
-                        "observer: postAdded - predicate approved state but observing context has changed - ignoring ({})",
-                        newState
-                    );
-                }
-            } else {
-                logger.trace("observer: postAdded - predicate rejected state ({})", newState);
-            }
-        }
-
-        @Override
-        public void onClose() {
-            ObservingContext context = observingContext.getAndSet(null);
-
-            if (context != null) {
-                logger.trace("observer: cluster service closed. notifying listener.");
-                // clusterApplierService.removeTimeoutListener(this);
-                context.listener.onClusterServiceClose();
-            }
-        }
-
-        @Override
-        public void onTimeout(TimeValue timeout) {
-            ObservingContext context = observingContext.getAndSet(null);
-            if (context != null) {
-                // clusterApplierService.removeTimeoutListener(this);
-                long timeSinceStartMS = threadPool.relativeTimeInMillis() - startTimeMS;
-                logger.trace(
-                    "observer: timeout notification from cluster service. timeout setting [{}], time since start [{}]",
-                    timeOutValue,
-                    new TimeValue(timeSinceStartMS)
-                );
-                // update to latest, in case people want to retry
-                lastObservedState.set(new StoredState(clusterApplierService.protobufState()));
-                timedOut = true;
-                context.listener.onTimeout(timeOutValue);
-            }
-        }
-
-        @Override
-        public String toString() {
-            return "ProtobufClusterStateObserver[" + observingContext.get() + "]";
-        }
-    }
-
-    /**
-     * The observer considers two cluster states to be the same if they have the same version and cluster-manager node id (i.e. null or set)
-     *
-     * @opensearch.internal
-     */
-    private static class StoredState {
-        private final String clusterManagerNodeId;
-        private final long version;
-
-        StoredState(ProtobufClusterState clusterState) {
-            this.clusterManagerNodeId = clusterState.nodes().getClusterManagerNodeId();
-            this.version = clusterState.version();
-        }
-
-        /**
-         * returns true if stored state is older then given state or they are from a different cluster-manager, meaning they can't be compared
-         * */
-        public boolean isOlderOrDifferentClusterManager(ProtobufClusterState clusterState) {
-            return version < clusterState.version()
-                || Objects.equals(clusterManagerNodeId, clusterState.nodes().getClusterManagerNodeId()) == false;
-        }
-    }
-
-    /**
-     * Listener for the observer.
-     *
-     * @opensearch.internal
-     */
-    public interface Listener {
-
-        /** called when a new state is observed */
-        void onNewClusterState(ProtobufClusterState state);
-
-        /** called when the cluster service is closed */
-        void onClusterServiceClose();
-
-        void onTimeout(TimeValue timeout);
-    }
-
-    /**
-     * Context for the observer.
-     *
-     * @opensearch.internal
-     */
-    static class ObservingContext {
-        public final Listener listener;
-        public final Predicate<ProtobufClusterState> statePredicate;
-
-        ObservingContext(Listener listener, Predicate<ProtobufClusterState> statePredicate) {
-            this.listener = listener;
-            this.statePredicate = statePredicate;
-        }
-
-        @Override
-        public String toString() {
-            return "ObservingContext[" + listener + "]";
-        }
-    }
-
-    /**
-     * A context preserving listener.
-     *
-     * @opensearch.internal
-     */
-    private static final class ContextPreservingListener implements Listener {
-        private final Listener delegate;
-        private final Supplier<ThreadContext.StoredContext> contextSupplier;
-
-        private ContextPreservingListener(Listener delegate, Supplier<ThreadContext.StoredContext> contextSupplier) {
-            this.contextSupplier = contextSupplier;
-            this.delegate = delegate;
-        }
-
-        @Override
-        public void onNewClusterState(ProtobufClusterState state) {
-            try (ThreadContext.StoredContext context = contextSupplier.get()) {
-                delegate.onNewClusterState(state);
-            }
-        }
-
-        @Override
-        public void onClusterServiceClose() {
-            try (ThreadContext.StoredContext context = contextSupplier.get()) {
-                delegate.onClusterServiceClose();
-            }
-        }
-
-        @Override
-        public void onTimeout(TimeValue timeout) {
-            try (ThreadContext.StoredContext context = contextSupplier.get()) {
-                delegate.onTimeout(timeout);
-            }
-        }
-
-        @Override
-        public String toString() {
-            return "ContextPreservingListener[" + delegate + "]";
-        }
-    }
-}
+// /*
+//  * 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.
+//  */
+
+// package org.opensearch.cluster;
+
+// import org.apache.logging.log4j.Logger;
+// import org.opensearch.OpenSearchException;
+// import org.opensearch.cluster.service.ClusterApplierService;
+// import org.opensearch.cluster.service.ClusterService;
+// import org.opensearch.common.Nullable;
+// import org.opensearch.common.unit.TimeValue;
+// import org.opensearch.common.util.concurrent.ThreadContext;
+// import org.opensearch.threadpool.ThreadPool;
+
+// import java.util.Objects;
+// import java.util.concurrent.atomic.AtomicReference;
+// import java.util.function.Predicate;
+// import java.util.function.Supplier;
+
+// /**
+//  * A utility class which simplifies interacting with the cluster state in cases where
+//  * one tries to take action based on the current state but may want to wait for a new state
+//  * and retry upon failure.
+//  *
+//  * @opensearch.internal
+//  */
+// public class ProtobufClusterStateObserver {
+
+//     protected final Logger logger;
+
+//     private final Predicate<ProtobufClusterState> MATCH_ALL_CHANGES_PREDICATE = state -> true;
+
+//     private final ClusterApplierService clusterApplierService;
+//     private final ThreadPool threadPool;
+//     private final ThreadContext contextHolder;
+//     volatile TimeValue timeOutValue;
+
+//     final AtomicReference<StoredState> lastObservedState;
+//     final ProtobufTimeoutClusterStateListener clusterStateListener = new ObserverClusterStateListener();
+//     // observingContext is not null when waiting on cluster state changes
+//     final AtomicReference<ObservingContext> observingContext = new AtomicReference<>(null);
+//     volatile Long startTimeMS;
+//     volatile boolean timedOut;
+
+//     public ProtobufClusterStateObserver(ClusterService clusterService, Logger logger, ThreadContext contextHolder) {
+//         this(clusterService, new TimeValue(60000), logger, contextHolder);
+//     }
+
+//     /**
+//      * @param timeout        a global timeout for this observer. After it has expired the observer
+//      *                       will fail any existing or new #waitForNextChange calls. Set to null
+//      *                       to wait indefinitely
+//      */
+//     public ProtobufClusterStateObserver(
+//         ClusterService clusterService,
+//         @Nullable TimeValue timeout,
+//         Logger logger,
+//         ThreadContext contextHolder
+//     ) {
+//         this(clusterService.protobufState(), clusterService, timeout, logger, contextHolder);
+//     }
+
+//     /**
+//      * @param timeout        a global timeout for this observer. After it has expired the observer
+//      *                       will fail any existing or new #waitForNextChange calls. Set to null
+//      *                       to wait indefinitely
+//      */
+//     public ProtobufClusterStateObserver(
+//         ProtobufClusterState initialState,
+//         ClusterService clusterService,
+//         @Nullable TimeValue timeout,
+//         Logger logger,
+//         ThreadContext contextHolder
+//     ) {
+//         this(initialState, clusterService.getClusterApplierService(), timeout, logger, contextHolder);
+//     }
+
+//     public ProtobufClusterStateObserver(
+//         ProtobufClusterState initialState,
+//         ClusterApplierService clusterApplierService,
+//         @Nullable TimeValue timeout,
+//         Logger logger,
+//         ThreadContext contextHolder
+//     ) {
+//         this.clusterApplierService = clusterApplierService;
+//         this.threadPool = clusterApplierService.threadPool();
+//         this.lastObservedState = new AtomicReference<>(new StoredState(initialState));
+//         this.timeOutValue = timeout;
+//         if (timeOutValue != null) {
+//             this.startTimeMS = threadPool.relativeTimeInMillis();
+//         }
+//         this.logger = logger;
+//         this.contextHolder = contextHolder;
+//     }
+
+//     /** sets the last observed state to the currently applied cluster state and returns it */
+//     public ProtobufClusterState setAndGetObservedState() {
+//         if (observingContext.get() != null) {
+//             throw new OpenSearchException("cannot set current cluster state while waiting for a cluster state change");
+//         }
+//         ProtobufClusterState clusterState = clusterApplierService.protobufState();
+//         lastObservedState.set(new StoredState(clusterState));
+//         return clusterState;
+//     }
+
+//     /** indicates whether this observer has timed out */
+//     public boolean isTimedOut() {
+//         return timedOut;
+//     }
+
+//     public void waitForNextChange(Listener listener) {
+//         waitForNextChange(listener, MATCH_ALL_CHANGES_PREDICATE);
+//     }
+
+//     public void waitForNextChange(Listener listener, @Nullable TimeValue timeOutValue) {
+//         waitForNextChange(listener, MATCH_ALL_CHANGES_PREDICATE, timeOutValue);
+//     }
+
+//     public void waitForNextChange(Listener listener, Predicate<ProtobufClusterState> statePredicate) {
+//         waitForNextChange(listener, statePredicate, null);
+//     }
+
+//     /**
+//      * Wait for the next cluster state which satisfies statePredicate
+//      *
+//      * @param listener        callback listener
+//      * @param statePredicate predicate to check whether cluster state changes are relevant and the callback should be called
+//      * @param timeOutValue    a timeout for waiting. If null the global observer timeout will be used.
+//      */
+//     public void waitForNextChange(Listener listener, Predicate<ProtobufClusterState> statePredicate, @Nullable TimeValue timeOutValue) {
+//         listener = new ContextPreservingListener(listener, contextHolder.newRestorableContext(false));
+//         if (observingContext.get() != null) {
+//             throw new OpenSearchException("already waiting for a cluster state change");
+//         }
+
+//         Long timeoutTimeLeftMS;
+//         if (timeOutValue == null) {
+//             timeOutValue = this.timeOutValue;
+//             if (timeOutValue != null) {
+//                 long timeSinceStartMS = threadPool.relativeTimeInMillis() - startTimeMS;
+//                 timeoutTimeLeftMS = timeOutValue.millis() - timeSinceStartMS;
+//                 if (timeoutTimeLeftMS <= 0L) {
+//                     // things have timeout while we were busy -> notify
+//                     logger.trace(
+//                         "observer timed out. notifying listener. timeout setting [{}], time since start [{}]",
+//                         timeOutValue,
+//                         new TimeValue(timeSinceStartMS)
+//                     );
+//                     // update to latest, in case people want to retry
+//                     timedOut = true;
+//                     lastObservedState.set(new StoredState(clusterApplierService.protobufState()));
+//                     listener.onTimeout(timeOutValue);
+//                     return;
+//                 }
+//             } else {
+//                 timeoutTimeLeftMS = null;
+//             }
+//         } else {
+//             this.startTimeMS = threadPool.relativeTimeInMillis();
+//             this.timeOutValue = timeOutValue;
+//             timeoutTimeLeftMS = timeOutValue.millis();
+//             timedOut = false;
+//         }
+
+//         // sample a new state. This state maybe *older* than the supplied state if we are called from an applier,
+//         // which wants to wait for something else to happen
+//         ProtobufClusterState newState = clusterApplierService.protobufState();
+//         if (lastObservedState.get().isOlderOrDifferentClusterManager(newState) && statePredicate.test(newState)) {
+//             // good enough, let's go.
+//             logger.trace("observer: sampled state accepted by predicate ({})", newState);
+//             lastObservedState.set(new StoredState(newState));
+//             listener.onNewClusterState(newState);
+//         } else {
+//             logger.trace("observer: sampled state rejected by predicate ({}). adding listener to ClusterService", newState);
+//             final ObservingContext context = new ObservingContext(listener, statePredicate);
+//             if (!observingContext.compareAndSet(null, context)) {
+//                 throw new OpenSearchException("already waiting for a cluster state change");
+//             }
+//             // clusterApplierService.addTimeoutListener(
+//             // timeoutTimeLeftMS == null ? null : new TimeValue(timeoutTimeLeftMS),
+//             // clusterStateListener
+//             // );
+//         }
+//     }
+
+//     /**
+//      * An observer of the cluster state for changes.
+//      *
+//      * @opensearch.internal
+//      */
+//     class ObserverClusterStateListener implements ProtobufTimeoutClusterStateListener {
+
+//         @Override
+//         public void clusterChanged(ProtobufClusterChangedEvent event) {
+//             ObservingContext context = observingContext.get();
+//             if (context == null) {
+//                 // No need to remove listener as it is the responsibility of the thread that set observingContext to null
+//                 return;
+//             }
+//             final ProtobufClusterState state = event.state();
+//             if (context.statePredicate.test(state)) {
+//                 if (observingContext.compareAndSet(context, null)) {
+//                     // clusterApplierService.removeTimeoutListener(this);
+//                     logger.trace("observer: accepting cluster state change ({})", state);
+//                     lastObservedState.set(new StoredState(state));
+//                     context.listener.onNewClusterState(state);
+//                 } else {
+//                     logger.trace(
+//                         "observer: predicate approved change but observing context has changed "
+//                             + "- ignoring (new cluster state version [{}])",
+//                         state.version()
+//                     );
+//                 }
+//             } else {
+//                 logger.trace("observer: predicate rejected change (new cluster state version [{}])", state.version());
+//             }
+//         }
+
+//         @Override
+//         public void postAdded() {
+//             ObservingContext context = observingContext.get();
+//             if (context == null) {
+//                 // No need to remove listener as it is the responsibility of the thread that set observingContext to null
+//                 return;
+//             }
+//             ProtobufClusterState newState = clusterApplierService.protobufState();
+//             if (lastObservedState.get().isOlderOrDifferentClusterManager(newState) && context.statePredicate.test(newState)) {
+//                 // double check we're still listening
+//                 if (observingContext.compareAndSet(context, null)) {
+//                     logger.trace("observer: post adding listener: accepting current cluster state ({})", newState);
+//                     // clusterApplierService.removeTimeoutListener(this);
+//                     lastObservedState.set(new StoredState(newState));
+//                     context.listener.onNewClusterState(newState);
+//                 } else {
+//                     logger.trace(
+//                         "observer: postAdded - predicate approved state but observing context has changed - ignoring ({})",
+//                         newState
+//                     );
+//                 }
+//             } else {
+//                 logger.trace("observer: postAdded - predicate rejected state ({})", newState);
+//             }
+//         }
+
+//         @Override
+//         public void onClose() {
+//             ObservingContext context = observingContext.getAndSet(null);
+
+//             if (context != null) {
+//                 logger.trace("observer: cluster service closed. notifying listener.");
+//                 // clusterApplierService.removeTimeoutListener(this);
+//                 context.listener.onClusterServiceClose();
+//             }
+//         }
+
+//         @Override
+//         public void onTimeout(TimeValue timeout) {
+//             ObservingContext context = observingContext.getAndSet(null);
+//             if (context != null) {
+//                 // clusterApplierService.removeTimeoutListener(this);
+//                 long timeSinceStartMS = threadPool.relativeTimeInMillis() - startTimeMS;
+//                 logger.trace(
+//                     "observer: timeout notification from cluster service. timeout setting [{}], time since start [{}]",
+//                     timeOutValue,
+//                     new TimeValue(timeSinceStartMS)
+//                 );
+//                 // update to latest, in case people want to retry
+//                 lastObservedState.set(new StoredState(clusterApplierService.protobufState()));
+//                 timedOut = true;
+//                 context.listener.onTimeout(timeOutValue);
+//             }
+//         }
+
+//         @Override
+//         public String toString() {
+//             return "ProtobufClusterStateObserver[" + observingContext.get() + "]";
+//         }
+//     }
+
+//     /**
+//      * The observer considers two cluster states to be the same if they have the same version and cluster-manager node id (i.e. null or set)
+//      *
+//      * @opensearch.internal
+//      */
+//     private static class StoredState {
+//         private final String clusterManagerNodeId;
+//         private final long version;
+
+//         StoredState(ProtobufClusterState clusterState) {
+//             this.clusterManagerNodeId = clusterState.nodes().getClusterManagerNodeId();
+//             this.version = clusterState.version();
+//         }
+
+//         /**
+//          * returns true if stored state is older then given state or they are from a different cluster-manager, meaning they can't be compared
+//          * */
+//         public boolean isOlderOrDifferentClusterManager(ProtobufClusterState clusterState) {
+//             return version < clusterState.version()
+//                 || Objects.equals(clusterManagerNodeId, clusterState.nodes().getClusterManagerNodeId()) == false;
+//         }
+//     }
+
+//     /**
+//      * Listener for the observer.
+//      *
+//      * @opensearch.internal
+//      */
+//     public interface Listener {
+
+//         /** called when a new state is observed */
+//         void onNewClusterState(ProtobufClusterState state);
+
+//         /** called when the cluster service is closed */
+//         void onClusterServiceClose();
+
+//         void onTimeout(TimeValue timeout);
+//     }
+
+//     /**
+//      * Context for the observer.
+//      *
+//      * @opensearch.internal
+//      */
+//     static class ObservingContext {
+//         public final Listener listener;
+//         public final Predicate<ProtobufClusterState> statePredicate;
+
+//         ObservingContext(Listener listener, Predicate<ProtobufClusterState> statePredicate) {
+//             this.listener = listener;
+//             this.statePredicate = statePredicate;
+//         }
+
+//         @Override
+//         public String toString() {
+//             return "ObservingContext[" + listener + "]";
+//         }
+//     }
+
+//     /**
+//      * A context preserving listener.
+//      *
+//      * @opensearch.internal
+//      */
+//     private static final class ContextPreservingListener implements Listener {
+//         private final Listener delegate;
+//         private final Supplier<ThreadContext.StoredContext> contextSupplier;
+
+//         private ContextPreservingListener(Listener delegate, Supplier<ThreadContext.StoredContext> contextSupplier) {
+//             this.contextSupplier = contextSupplier;
+//             this.delegate = delegate;
+//         }
+
+//         @Override
+//         public void onNewClusterState(ProtobufClusterState state) {
+//             try (ThreadContext.StoredContext context = contextSupplier.get()) {
+//                 delegate.onNewClusterState(state);
+//             }
+//         }
+
+//         @Override
+//         public void onClusterServiceClose() {
+//             try (ThreadContext.StoredContext context = contextSupplier.get()) {
+//                 delegate.onClusterServiceClose();
+//             }
+//         }
+
+//         @Override
+//         public void onTimeout(TimeValue timeout) {
+//             try (ThreadContext.StoredContext context = contextSupplier.get()) {
+//                 delegate.onTimeout(timeout);
+//             }
+//         }
+
+//         @Override
+//         public String toString() {
+//             return "ContextPreservingListener[" + delegate + "]";
+//         }
+//     }
+// }
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufTimeoutClusterStateListener.java b/server/src/main/java/org/opensearch/cluster/ProtobufTimeoutClusterStateListener.java
index 99ce33a6a71e6..278d11f6ea8e7 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufTimeoutClusterStateListener.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufTimeoutClusterStateListener.java
@@ -1,49 +1,49 @@
-/*
- * 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.cluster;
-
-import org.opensearch.common.unit.TimeValue;
-
-/**
- * An exception to cluster state listener that allows for timeouts and for post added notifications.
- *
- * @opensearch.internal
- */
-public interface ProtobufTimeoutClusterStateListener extends ProtobufClusterStateListener {
-
-    void postAdded();
-
-    void onClose();
-
-    void onTimeout(TimeValue timeout);
-}
+// /*
+//  * 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.cluster;
+
+// import org.opensearch.common.unit.TimeValue;
+
+// /**
+//  * An exception to cluster state listener that allows for timeouts and for post added notifications.
+//  *
+//  * @opensearch.internal
+//  */
+// public interface ProtobufTimeoutClusterStateListener extends ProtobufClusterStateListener {
+
+//     void postAdded();
+
+//     void onClose();
+
+//     void onTimeout(TimeValue timeout);
+// }
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
index 3df16442b9fa7..f6cd024359e4e 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
@@ -613,6 +613,8 @@ private void handleJoinRequest(JoinRequest joinRequest, JoinHelper.JoinCallback
                 processJoinRequest(joinRequest, joinCallback);
             }
         }, joinCallback::onFailure));
+
+        
     }
 
     // package private for tests
@@ -853,19 +855,19 @@ protected void doStart() {
                 )
                 .nodes(DiscoveryNodes.builder().add(getLocalNode()).localNodeId(getLocalNode().getId()))
                 .build();
-            ProtobufClusterState protobufInitialState = ProtobufClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.get(settings))
-                .blocks(
-                    ClusterBlocks.builder()
-                        .addGlobalBlock(STATE_NOT_RECOVERED_BLOCK)
-                        .addGlobalBlock(noClusterManagerBlockService.getNoClusterManagerBlock())
-                )
-                .nodes(DiscoveryNodes.builder().add(getLocalNode()).localNodeId(getLocalNode().getId()))
-                .build();
+            // ProtobufClusterState protobufInitialState = ProtobufClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.get(settings))
+            //     .blocks(
+            //         ClusterBlocks.builder()
+            //             .addGlobalBlock(STATE_NOT_RECOVERED_BLOCK)
+            //             .addGlobalBlock(noClusterManagerBlockService.getNoClusterManagerBlock())
+            //     )
+            //     .nodes(DiscoveryNodes.builder().add(getLocalNode()).localNodeId(getLocalNode().getId()))
+            //     .build();
             System.out.println("cluster state initial: " + initialState);
-            System.out.println("protobuf cluster state initial: " + protobufInitialState);
+            // System.out.println("protobuf cluster state initial: " + protobufInitialState);
             applierState = initialState;
             clusterApplier.setInitialState(initialState);
-            clusterApplier.setInitialProtobufState(protobufInitialState);
+            // clusterApplier.setInitialProtobufState(protobufInitialState);
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterApplier.java b/server/src/main/java/org/opensearch/cluster/service/ClusterApplier.java
index bb03e04568116..539b84ae2e025 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterApplier.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterApplier.java
@@ -49,11 +49,11 @@ public interface ClusterApplier {
      */
     void setInitialState(ClusterState initialState);
 
-    /**
-     * Sets the initial state for this applier. Should only be called once.
-     * @param initialState the initial state to set
-     */
-    void setInitialProtobufState(ProtobufClusterState initialState);
+    // /**
+    //  * Sets the initial state for this applier. Should only be called once.
+    //  * @param initialState the initial state to set
+    //  */
+    // void setInitialProtobufState(ProtobufClusterState initialState);
 
     /**
      * Method to invoke when a new cluster state is available to be applied
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java b/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
index 2b3067b804820..75b809658f2ea 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
@@ -115,7 +115,7 @@ public class ClusterApplierService extends AbstractLifecycleComponent implements
     private final Map<TimeoutClusterStateListener, NotifyTimeout> timeoutClusterStateListeners = new ConcurrentHashMap<>();
 
     private final AtomicReference<ClusterState> state; // last applied state
-    private final AtomicReference<ProtobufClusterState> protobufState; // last applied state
+    // private final AtomicReference<ProtobufClusterState> protobufState; // last applied state
 
     private final String nodeName;
 
@@ -125,7 +125,7 @@ public ClusterApplierService(String nodeName, Settings settings, ClusterSettings
         this.clusterSettings = clusterSettings;
         this.threadPool = threadPool;
         this.state = new AtomicReference<>();
-        this.protobufState = new AtomicReference<>();
+        // this.protobufState = new AtomicReference<>();
         this.nodeName = nodeName;
 
         this.slowTaskLoggingThreshold = CLUSTER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING.get(settings);
@@ -153,14 +153,14 @@ public void setInitialState(ClusterState initialState) {
         state.set(initialState);
     }
 
-    @Override
-    public void setInitialProtobufState(ProtobufClusterState initialState) {
-        if (lifecycle.started()) {
-            throw new IllegalStateException("can't set initial state when started");
-        }
-        assert protobufState.get() == null : "state is already set";
-        protobufState.set(initialState);
-    }
+    // @Override
+    // public void setInitialProtobufState(ProtobufClusterState initialState) {
+    //     if (lifecycle.started()) {
+    //         throw new IllegalStateException("can't set initial state when started");
+    //     }
+    //     assert protobufState.get() == null : "state is already set";
+    //     protobufState.set(initialState);
+    // }
 
     @Override
     protected synchronized void doStart() {
@@ -226,16 +226,16 @@ public ClusterState state() {
         return clusterState;
     }
 
-    /**
-     * The current cluster state.
-     * Should be renamed to appliedClusterState
-     */
-    public ProtobufClusterState protobufState() {
-        assert assertNotCalledFromClusterStateApplier("the applied cluster state is not yet available");
-        ProtobufClusterState clusterState = this.protobufState.get();
-        assert clusterState != null : "initial cluster state not set yet";
-        return clusterState;
-    }
+    // /**
+    //  * The current cluster state.
+    //  * Should be renamed to appliedClusterState
+    //  */
+    // public ProtobufClusterState protobufState() {
+    //     assert assertNotCalledFromClusterStateApplier("the applied cluster state is not yet available");
+    //     ProtobufClusterState clusterState = this.protobufState.get();
+    //     assert clusterState != null : "initial cluster state not set yet";
+    //     return clusterState;
+    // }
 
     /**
      * Returns true if the appliedClusterState is not null
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterService.java b/server/src/main/java/org/opensearch/cluster/service/ClusterService.java
index 385d62b1895cc..2c079048f3a4b 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterService.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterService.java
@@ -171,13 +171,13 @@ public ClusterState state() {
         return clusterApplierService.state();
     }
 
-    /**
-     * The currently applied cluster state.
-     * TODO: Should be renamed to appliedState / appliedClusterState
-     */
-    public ProtobufClusterState protobufState() {
-        return clusterApplierService.protobufState();
-    }
+    // /**
+    //  * The currently applied cluster state.
+    //  * TODO: Should be renamed to appliedState / appliedClusterState
+    //  */
+    // public ProtobufClusterState protobufState() {
+    //     return clusterApplierService.protobufState();
+    // }
 
     /**
      * Adds a high priority applier of updated cluster states.
diff --git a/server/src/main/java/org/opensearch/common/logging/ProtobufNodeAndClusterIdStateListener.java b/server/src/main/java/org/opensearch/common/logging/ProtobufNodeAndClusterIdStateListener.java
index a2d9aae67db6c..848623d13b248 100644
--- a/server/src/main/java/org/opensearch/common/logging/ProtobufNodeAndClusterIdStateListener.java
+++ b/server/src/main/java/org/opensearch/common/logging/ProtobufNodeAndClusterIdStateListener.java
@@ -1,71 +1,71 @@
-/*
- * 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.
- */
+// /*
+//  * 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.
+//  */
 
-package org.opensearch.common.logging;
+// package org.opensearch.common.logging;
 
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.opensearch.cluster.ProtobufClusterState;
-import org.opensearch.cluster.ProtobufClusterStateObserver;
-import org.opensearch.cluster.service.ClusterService;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.common.util.concurrent.ThreadContext;
+// import org.apache.logging.log4j.LogManager;
+// import org.apache.logging.log4j.Logger;
+// import org.opensearch.cluster.ProtobufClusterState;
+// import org.opensearch.cluster.ProtobufClusterStateObserver;
+// import org.opensearch.cluster.service.ClusterService;
+// import org.opensearch.common.unit.TimeValue;
+// import org.opensearch.common.util.concurrent.ThreadContext;
 
-/**
- * The {@link ProtobufNodeAndClusterIdStateListener} listens to cluster state changes and ONLY when receives the first update
- * it sets the clusterUUID and nodeID in log4j pattern converter {@link NodeAndClusterIdConverter}.
- * Once the first update is received, it will automatically be de-registered from subsequent updates.
- *
- * @opensearch.internal
- */
-public class ProtobufNodeAndClusterIdStateListener implements ProtobufClusterStateObserver.Listener {
-    private static final Logger logger = LogManager.getLogger(ProtobufNodeAndClusterIdStateListener.class);
+// /**
+//  * The {@link ProtobufNodeAndClusterIdStateListener} listens to cluster state changes and ONLY when receives the first update
+//  * it sets the clusterUUID and nodeID in log4j pattern converter {@link NodeAndClusterIdConverter}.
+//  * Once the first update is received, it will automatically be de-registered from subsequent updates.
+//  *
+//  * @opensearch.internal
+//  */
+// public class ProtobufNodeAndClusterIdStateListener implements ProtobufClusterStateObserver.Listener {
+//     private static final Logger logger = LogManager.getLogger(ProtobufNodeAndClusterIdStateListener.class);
 
-    private ProtobufNodeAndClusterIdStateListener() {}
+//     private ProtobufNodeAndClusterIdStateListener() {}
 
-    /**
-     * Subscribes for the first cluster state update where nodeId and clusterId is present
-     * and sets these values in {@link NodeAndClusterIdConverter}.
-     */
-    public static void getAndSetNodeIdAndClusterId(ClusterService clusterService, ThreadContext threadContext) {
-        ProtobufClusterState clusterState = clusterService.protobufState();
-        ProtobufClusterStateObserver observer = new ProtobufClusterStateObserver(clusterState, clusterService, null, logger, threadContext);
+//     /**
+//      * Subscribes for the first cluster state update where nodeId and clusterId is present
+//      * and sets these values in {@link NodeAndClusterIdConverter}.
+//      */
+//     public static void getAndSetNodeIdAndClusterId(ClusterService clusterService, ThreadContext threadContext) {
+//         ProtobufClusterState clusterState = clusterService.protobufState();
+//         ProtobufClusterStateObserver observer = new ProtobufClusterStateObserver(clusterState, clusterService, null, logger, threadContext);
 
-        observer.waitForNextChange(
-            new ProtobufNodeAndClusterIdStateListener(),
-            ProtobufNodeAndClusterIdStateListener::isNodeAndClusterIdPresent
-        );
-    }
+//         observer.waitForNextChange(
+//             new ProtobufNodeAndClusterIdStateListener(),
+//             ProtobufNodeAndClusterIdStateListener::isNodeAndClusterIdPresent
+//         );
+//     }
 
-    private static boolean isNodeAndClusterIdPresent(ProtobufClusterState clusterState) {
-        return getNodeId(clusterState) != null && getClusterUUID(clusterState) != null;
-    }
+//     private static boolean isNodeAndClusterIdPresent(ProtobufClusterState clusterState) {
+//         return getNodeId(clusterState) != null && getClusterUUID(clusterState) != null;
+//     }
 
-    private static String getClusterUUID(ProtobufClusterState state) {
-        return state.getMetadata().clusterUUID();
-    }
+//     private static String getClusterUUID(ProtobufClusterState state) {
+//         return state.getMetadata().clusterUUID();
+//     }
 
-    private static String getNodeId(ProtobufClusterState state) {
-        return state.getNodes().getLocalNodeId();
-    }
+//     private static String getNodeId(ProtobufClusterState state) {
+//         return state.getNodes().getLocalNodeId();
+//     }
 
-    @Override
-    public void onNewClusterState(ProtobufClusterState state) {
-        String nodeId = getNodeId(state);
-        String clusterUUID = getClusterUUID(state);
+//     @Override
+//     public void onNewClusterState(ProtobufClusterState state) {
+//         String nodeId = getNodeId(state);
+//         String clusterUUID = getClusterUUID(state);
 
-        logger.debug("Received cluster state update. Setting nodeId=[{}] and clusterUuid=[{}]", nodeId, clusterUUID);
-        NodeAndClusterIdConverter.setNodeIdAndClusterId(nodeId, clusterUUID);
-    }
+//         logger.debug("Received cluster state update. Setting nodeId=[{}] and clusterUuid=[{}]", nodeId, clusterUUID);
+//         NodeAndClusterIdConverter.setNodeIdAndClusterId(nodeId, clusterUUID);
+//     }
 
-    @Override
-    public void onClusterServiceClose() {}
+//     @Override
+//     public void onClusterServiceClose() {}
 
-    @Override
-    public void onTimeout(TimeValue timeout) {}
-}
+//     @Override
+//     public void onTimeout(TimeValue timeout) {}
+// }
diff --git a/server/src/main/java/org/opensearch/node/Node.java b/server/src/main/java/org/opensearch/node/Node.java
index d0c527a2914e8..e9f39215fbf98 100644
--- a/server/src/main/java/org/opensearch/node/Node.java
+++ b/server/src/main/java/org/opensearch/node/Node.java
@@ -102,7 +102,7 @@
 import org.opensearch.cluster.InternalClusterInfoService;
 import org.opensearch.cluster.NodeConnectionsService;
 import org.opensearch.cluster.ProtobufClusterState;
-import org.opensearch.cluster.ProtobufClusterStateObserver;
+// import org.opensearch.cluster.ProtobufClusterStateObserver;
 import org.opensearch.cluster.action.index.MappingUpdatedAction;
 import org.opensearch.cluster.metadata.AliasValidator;
 import org.opensearch.cluster.metadata.IndexTemplateMetadata;
@@ -131,7 +131,7 @@
 import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.logging.HeaderWarning;
 import org.opensearch.common.logging.NodeAndClusterIdStateListener;
-import org.opensearch.common.logging.ProtobufNodeAndClusterIdStateListener;
+// import org.opensearch.common.logging.ProtobufNodeAndClusterIdStateListener;
 import org.opensearch.common.network.NetworkAddress;
 import org.opensearch.common.network.NetworkModule;
 import org.opensearch.common.network.NetworkService;
@@ -1461,25 +1461,25 @@ public Node start() throws NodeValidationException {
         discovery.startInitialJoin();
         final TimeValue initialStateTimeout = DiscoverySettings.INITIAL_STATE_TIMEOUT_SETTING.get(settings());
         configureNodeAndClusterIdStateListener(clusterService);
-        configureProtobufNodeAndClusterIdStateListener(clusterService);
+        // configureProtobufNodeAndClusterIdStateListener(clusterService);
 
         ClusterState clusterState1 = clusterService.state();
         System.out.println("Cluster state: " + clusterState1);
-        ProtobufClusterState protobufClusterState1 = clusterService.protobufState();
-        System.out.println("Protobuf Cluster state: " + protobufClusterState1);
+        // ProtobufClusterState protobufClusterState1 = clusterService.protobufState();
+        // System.out.println("Protobuf Cluster state: " + protobufClusterState1);
 
         if (initialStateTimeout.millis() > 0) {
             final ThreadPool thread = injector.getInstance(ThreadPool.class);
             ClusterState clusterState = clusterService.state();
-            ProtobufClusterState protobufClusterState = clusterService.protobufState();
+            // ProtobufClusterState protobufClusterState = clusterService.protobufState();
             ClusterStateObserver observer = new ClusterStateObserver(clusterState, clusterService, null, logger, thread.getThreadContext());
-            ProtobufClusterStateObserver protobufObserver = new ProtobufClusterStateObserver(
-                protobufClusterState,
-                clusterService,
-                null,
-                logger,
-                thread.getThreadContext()
-            );
+            // ProtobufClusterStateObserver protobufObserver = new ProtobufClusterStateObserver(
+            //     protobufClusterState,
+            //     clusterService,
+            //     null,
+            //     logger,
+            //     thread.getThreadContext()
+            // );
 
             if (clusterState.nodes().getClusterManagerNodeId() == null) {
                 logger.debug("waiting to join the cluster. timeout [{}]", initialStateTimeout);
@@ -1508,33 +1508,33 @@ public void onTimeout(TimeValue timeout) {
                     throw new OpenSearchTimeoutException("Interrupted while waiting for initial discovery state");
                 }
             }
-            if (protobufClusterState.nodes().getClusterManagerNodeId() == null) {
-                logger.debug("waiting to join the cluster. timeout [{}]", initialStateTimeout);
-                final CountDownLatch latch = new CountDownLatch(1);
-                protobufObserver.waitForNextChange(new ProtobufClusterStateObserver.Listener() {
-                    @Override
-                    public void onNewClusterState(ProtobufClusterState state) {
-                        latch.countDown();
-                    }
-
-                    @Override
-                    public void onClusterServiceClose() {
-                        latch.countDown();
-                    }
-
-                    @Override
-                    public void onTimeout(TimeValue timeout) {
-                        logger.warn("timed out while waiting for initial discovery state - timeout: {}", initialStateTimeout);
-                        latch.countDown();
-                    }
-                }, state -> state.nodes().getClusterManagerNodeId() != null, initialStateTimeout);
-
-                try {
-                    latch.await();
-                } catch (InterruptedException e) {
-                    throw new OpenSearchTimeoutException("Interrupted while waiting for initial discovery state");
-                }
-            }
+            // if (protobufClusterState.nodes().getClusterManagerNodeId() == null) {
+            //     logger.debug("waiting to join the cluster. timeout [{}]", initialStateTimeout);
+            //     final CountDownLatch latch = new CountDownLatch(1);
+            //     protobufObserver.waitForNextChange(new ProtobufClusterStateObserver.Listener() {
+            //         @Override
+            //         public void onNewClusterState(ProtobufClusterState state) {
+            //             latch.countDown();
+            //         }
+
+            //         @Override
+            //         public void onClusterServiceClose() {
+            //             latch.countDown();
+            //         }
+
+            //         @Override
+            //         public void onTimeout(TimeValue timeout) {
+            //             logger.warn("timed out while waiting for initial discovery state - timeout: {}", initialStateTimeout);
+            //             latch.countDown();
+            //         }
+            //     }, state -> state.nodes().getClusterManagerNodeId() != null, initialStateTimeout);
+
+            //     try {
+            //         latch.await();
+            //     } catch (InterruptedException e) {
+            //         throw new OpenSearchTimeoutException("Interrupted while waiting for initial discovery state");
+            //     }
+            // }
         }
 
         injector.getInstance(HttpServerTransport.class).start();
@@ -1560,12 +1560,12 @@ protected void configureNodeAndClusterIdStateListener(ClusterService clusterServ
         );
     }
 
-    protected void configureProtobufNodeAndClusterIdStateListener(ClusterService clusterService) {
-        ProtobufNodeAndClusterIdStateListener.getAndSetNodeIdAndClusterId(
-            clusterService,
-            injector.getInstance(ThreadPool.class).getThreadContext()
-        );
-    }
+    // protected void configureProtobufNodeAndClusterIdStateListener(ClusterService clusterService) {
+    //     ProtobufNodeAndClusterIdStateListener.getAndSetNodeIdAndClusterId(
+    //         clusterService,
+    //         injector.getInstance(ThreadPool.class).getThreadContext()
+    //     );
+    // }
 
     private Node stop() {
         if (!lifecycle.moveToStopped()) {
diff --git a/server/src/main/java/org/opensearch/tasks/TaskManager.java b/server/src/main/java/org/opensearch/tasks/TaskManager.java
index 34d2247de4aef..ac34c338d0ab6 100644
--- a/server/src/main/java/org/opensearch/tasks/TaskManager.java
+++ b/server/src/main/java/org/opensearch/tasks/TaskManager.java
@@ -45,8 +45,7 @@
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.cluster.ClusterChangedEvent;
 import org.opensearch.cluster.ClusterStateApplier;
-import org.opensearch.cluster.ProtobufClusterChangedEvent;
-import org.opensearch.cluster.ProtobufClusterStateApplier;
+
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.common.SetOnce;
@@ -94,7 +93,7 @@
  *
  * @opensearch.internal
  */
-public class TaskManager implements ClusterStateApplier, ProtobufClusterStateApplier {
+public class TaskManager implements ClusterStateApplier {
 
     private static final Logger logger = LogManager.getLogger(TaskManager.class);
 
@@ -935,28 +934,28 @@ public void applyClusterState(ClusterChangedEvent event) {
         }
     }
 
-    @Override
-    public void applyProtobufClusterState(ProtobufClusterChangedEvent event) {
-        lastDiscoveryNodes = event.state().getNodes();
-        if (event.nodesRemoved()) {
-            synchronized (banedParentsProtobuf) {
-                lastDiscoveryNodes = event.state().getNodes();
-                // Remove all bans that were registered by nodes that are no longer in the cluster state
-                Iterator<ProtobufTaskId> banIterator = banedParentsProtobuf.keySet().iterator();
-                while (banIterator.hasNext()) {
-                    ProtobufTaskId taskId = banIterator.next();
-                    if (lastDiscoveryNodes.nodeExists(taskId.getNodeId()) == false) {
-                        logger.debug(
-                            "Removing ban for the parent [{}] on the node [{}], reason: the parent node is gone",
-                            taskId,
-                            event.state().getNodes().getLocalNode()
-                        );
-                        banIterator.remove();
-                    }
-                }
-            }
-        }
-    }
+    // @Override
+    // public void applyProtobufClusterState(ProtobufClusterChangedEvent event) {
+    //     lastDiscoveryNodes = event.state().getNodes();
+    //     if (event.nodesRemoved()) {
+    //         synchronized (banedParentsProtobuf) {
+    //             lastDiscoveryNodes = event.state().getNodes();
+    //             // Remove all bans that were registered by nodes that are no longer in the cluster state
+    //             Iterator<ProtobufTaskId> banIterator = banedParentsProtobuf.keySet().iterator();
+    //             while (banIterator.hasNext()) {
+    //                 ProtobufTaskId taskId = banIterator.next();
+    //                 if (lastDiscoveryNodes.nodeExists(taskId.getNodeId()) == false) {
+    //                     logger.debug(
+    //                         "Removing ban for the parent [{}] on the node [{}], reason: the parent node is gone",
+    //                         taskId,
+    //                         event.state().getNodes().getLocalNode()
+    //                     );
+    //                     banIterator.remove();
+    //                 }
+    //             }
+    //         }
+    //     }
+    // }
 
     /**
      * Blocks the calling thread, waiting for the task to vanish from the TaskManager.
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/NoOpClusterApplier.java b/server/src/test/java/org/opensearch/cluster/coordination/NoOpClusterApplier.java
index 420223fa35178..a8f3a5d7d4ec0 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/NoOpClusterApplier.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/NoOpClusterApplier.java
@@ -48,8 +48,8 @@ public void onNewClusterState(String source, Supplier<ClusterState> clusterState
         listener.onSuccess(source);
     }
 
-    @Override
-    public void setInitialProtobufState(ProtobufClusterState initialState) {
+    // @Override
+    // public void setInitialProtobufState(ProtobufClusterState initialState) {
 
-    }
+    // }
 }

From cb320c7bbcd3c31bd05a1e17bc8ad93836527279 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Tue, 11 Jul 2023 19:17:31 +0000
Subject: [PATCH 14/37] Eliminating a lot of protobuf classes to merge with
 original classes - mainly TransportService to try to fix multi node problem

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../action/ActionListenerResponseHandler.java |   16 +
 .../org/opensearch/action/ActionModule.java   |    5 -
 ...ProtobufActionListenerResponseHandler.java |   23 +-
 .../action/ProtobufActionRequest.java         |    4 +-
 .../action/ProtobufActionResponse.java        |    4 +-
 .../ProtobufTransportNodesInfoAction.java     |   14 +-
 .../node/info/TransportNodesInfoAction.java   |    6 +
 .../ProtobufTransportNodesStatsAction.java    |    8 +-
 .../ProtobufTransportClusterStateAction.java  |    4 +-
 ...TransportFieldCapabilitiesIndexAction.java |   15 +
 .../main/ProtobufTransportMainAction.java     |    4 +-
 .../TransportResyncReplicationAction.java     |   15 +
 .../opensearch/action/search/PitService.java  |   15 +
 .../ProtobufChannelActionListener.java        |   14 +-
 .../ProtobufHandledTransportAction.java       |   18 +-
 .../support/ProtobufTransportAction.java      |    4 +-
 .../broadcast/TransportBroadcastAction.java   |   15 +
 .../node/TransportBroadcastByNodeAction.java  |   17 +
 ...obufTransportClusterManagerNodeAction.java |   10 +-
 ...TransportClusterManagerNodeReadAction.java |    6 +-
 .../support/nodes/BaseNodeResponse.java       |   13 +
 .../nodes/ProtobufBaseNodeResponse.java       |    4 +-
 .../nodes/ProtobufTransportNodesAction.java   |   48 +-
 .../support/nodes/TransportNodesAction.java   |   17 +
 .../TransportReplicationAction.java           |   15 +
 ...ransportInstanceSingleOperationAction.java |   15 +
 .../shard/TransportSingleShardAction.java     |   29 +
 .../support/tasks/TransportTasksAction.java   |   16 +
 .../support/ProtobufAbstractClient.java       |    3 +
 .../org/opensearch/cluster/ClusterModule.java |   13 +-
 .../coordination/FollowersChecker.java        |   15 +
 .../cluster/coordination/JoinHelper.java      |   27 +
 .../cluster/coordination/LeaderChecker.java   |   15 +
 .../coordination/PreVoteCollector.java        |   15 +
 .../PublicationTransportHandler.java          |   28 +
 .../decommission/DecommissionController.java  |   15 +
 .../ProtobufIndexNameExpressionResolver.java  | 2702 +++++++-------
 .../cluster/node/DiscoveryNode.java           |   24 +-
 .../common/network/NetworkModule.java         |   64 +-
 .../transport/BoundTransportAddress.java      |   25 +-
 .../ProtobufBoundTransportAddress.java        |   22 +-
 .../transport/ProtobufTransportAddress.java   |    2 +-
 .../common/transport/TransportAddress.java    |   32 +-
 .../org/opensearch/discovery/PeerFinder.java  |   15 +
 .../extensions/ExtensionsManager.java         |   16 +
 .../UpdateSettingsResponseHandler.java        |   15 +
 .../ExtensionTransportActionsHandler.java     |   27 +
 .../rest/RestSendToExtensionAction.java       |   16 +
 .../http/AbstractHttpServerTransport.java     |   20 +-
 .../org/opensearch/http/ProtobufHttpInfo.java |   16 +-
 .../RetentionLeaseBackgroundSyncAction.java   |   15 +
 .../index/seqno/RetentionLeaseSyncAction.java |   15 +
 .../recovery/PeerRecoveryTargetService.java   |   15 +
 .../checkpoint/PublishCheckpointAction.java   |   15 +
 .../indices/store/IndicesStore.java           |   15 +
 .../main/java/org/opensearch/node/Node.java   |   76 +-
 .../opensearch/node/ProtobufNodeService.java  |    8 +-
 .../action/cat/ProtobufRestNodesAction.java   |   11 +-
 .../rest/action/cat/RestNodesAction.java      |    7 +-
 .../snapshots/SnapshotShardsService.java      |   15 +
 .../tasks/ProtobufTaskAwareRequest.java       |   14 +-
 .../ProtobufTaskCancellationService.java      |   28 +-
 .../org/opensearch/tasks/TaskManager.java     |    4 +-
 .../transport/ClusterConnectionManager.java   |    4 +
 .../EmptyTransportResponseHandler.java        |   17 +
 .../opensearch/transport/InboundHandler.java  |   18 +-
 .../opensearch/transport/OutboundHandler.java |   16 +-
 .../transport/PlainTransportFuture.java       |   14 +
 .../ProtobufActionTransportException.java     |   14 +-
 .../ProtobufBytesTransportRequest.java        |    2 +-
 .../ProtobufClusterConnectionManager.java     |  508 +--
 .../ProtobufConnectTransportException.java    |    2 +-
 .../transport/ProtobufConnectionManager.java  |   42 +-
 .../transport/ProtobufConnectionProfile.java  |    2 +-
 ...ProtobufEmptyTransportResponseHandler.java |   27 +-
 .../transport/ProtobufOutboundHandler.java    |  508 +--
 .../ProtobufPlainTransportFuture.java         |   27 +-
 .../ProtobufProxyConnectionStrategy.java      |   18 +-
 ...tobufReceiveTimeoutTransportException.java |    2 +-
 .../ProtobufRemoteClusterAwareClient.java     |   10 +-
 .../ProtobufRemoteClusterConnection.java      |   43 +-
 .../ProtobufRemoteClusterService.java         |    8 +-
 .../ProtobufRemoteConnectionManager.java      |  437 +--
 .../ProtobufRemoteConnectionStrategy.java     |   28 +-
 .../ProtobufRemoteTransportException.java     |    4 +-
 .../ProtobufRequestHandlerRegistry.java       |   12 +-
 ...ProtobufSendRequestTransportException.java |    2 +-
 .../ProtobufSniffConnectionStrategy.java      |   51 +-
 .../ProtobufTaskTransportChannel.java         |  110 +-
 .../ProtobufTcpTransportChannel.java          |  194 +-
 .../ProtobufTransportActionProxy.java         |   57 +-
 .../transport/ProtobufTransportChannel.java   |  112 +-
 .../ProtobufTransportConnectionListener.java  |   72 +-
 .../transport/ProtobufTransportInfo.java      |   35 +-
 .../ProtobufTransportInterceptor.java         |  108 +-
 .../transport/ProtobufTransportMessage.java   |   90 +-
 .../ProtobufTransportMessageListener.java     |  120 +-
 .../transport/ProtobufTransportRequest.java   |  120 +-
 .../ProtobufTransportRequestHandler.java      |    4 +-
 .../transport/ProtobufTransportResponse.java  |  118 +-
 .../ProtobufTransportResponseHandler.java     |  114 +-
 .../transport/ProtobufTransportService.java   | 3208 +++++++++--------
 .../transport/RemoteClusterConnection.java    |   14 +
 .../transport/RemoteClusterService.java       |   44 +-
 .../transport/RemoteConnectionManager.java    |    8 +
 .../transport/SniffConnectionStrategy.java    |   14 +
 .../opensearch/transport/TcpTransport.java    |  149 +-
 .../org/opensearch/transport/Transport.java   |  379 +-
 .../transport/TransportActionProxy.java       |   14 +
 .../transport/TransportHandshaker.java        |   14 +
 .../transport/TransportInterceptor.java       |   40 +
 .../transport/TransportMessage.java           |   11 +-
 .../transport/TransportRequest.java           |   41 +-
 .../transport/TransportResponse.java          |   21 +
 .../transport/TransportResponseHandler.java   |   59 +-
 .../transport/TransportService.java           |  452 ++-
 .../cluster/NodeConnectionsServiceTests.java  |   12 +-
 .../opensearch/test/MockHttpTransport.java    |   22 +-
 .../test/transport/FakeTransport.java         |   75 +-
 .../test/transport/StubbableTransport.java    |   82 +-
 .../AbstractSimpleTransportTestCase.java      |  340 ++
 121 files changed, 6797 insertions(+), 5011 deletions(-)

diff --git a/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java b/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java
index 7899324a3301e..79a9a198e1836 100644
--- a/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java
+++ b/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java
@@ -36,6 +36,10 @@
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportResponseHandler;
+
+import com.google.protobuf.CodedInputStream;
+
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponse;
 
@@ -88,4 +92,16 @@ public Response read(StreamInput in) throws IOException {
     public String toString() {
         return super.toString() + "/" + listener;
     }
+
+    @Override
+    public Response read(CodedInputStream in) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'read'");
+    }
+
+    @Override
+    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/ActionModule.java b/server/src/main/java/org/opensearch/action/ActionModule.java
index ecf5d1884cf65..94ee82cb92f7f 100644
--- a/server/src/main/java/org/opensearch/action/ActionModule.java
+++ b/server/src/main/java/org/opensearch/action/ActionModule.java
@@ -295,7 +295,6 @@
 import org.opensearch.client.node.NodeClient;
 import org.opensearch.client.node.ProtobufNodeClient;
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
-import org.opensearch.cluster.metadata.ProtobufIndexNameExpressionResolver;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.common.NamedRegistry;
 import org.opensearch.common.inject.AbstractModule;
@@ -506,7 +505,6 @@ public class ActionModule extends AbstractModule {
 
     private final Settings settings;
     private final IndexNameExpressionResolver indexNameExpressionResolver;
-    private final ProtobufIndexNameExpressionResolver protobufIndexNameExpressionResolver;
     private final IndexScopedSettings indexScopedSettings;
     private final ClusterSettings clusterSettings;
     private final SettingsFilter settingsFilter;
@@ -556,7 +554,6 @@ public ActionModule(
         this.clusterSettings = clusterSettings;
         this.settingsFilter = settingsFilter;
         this.actionPlugins = actionPlugins;
-        this.protobufIndexNameExpressionResolver = null;
         this.protobufActionPlugins = new ArrayList<>();
         ;
         this.protobufActions = new HashMap<String, ProtobufActionPlugin.ActionHandler<?, ?>>();
@@ -598,7 +595,6 @@ public ActionModule(
     public ActionModule(
         Settings settings,
         IndexNameExpressionResolver indexNameExpressionResolver,
-        ProtobufIndexNameExpressionResolver protobufIndexNameExpressionResolver,
         IndexScopedSettings indexScopedSettings,
         ClusterSettings clusterSettings,
         SettingsFilter settingsFilter,
@@ -613,7 +609,6 @@ public ActionModule(
     ) {
         this.settings = settings;
         this.indexNameExpressionResolver = indexNameExpressionResolver;
-        this.protobufIndexNameExpressionResolver = protobufIndexNameExpressionResolver;
         this.indexScopedSettings = indexScopedSettings;
         this.clusterSettings = clusterSettings;
         this.settingsFilter = settingsFilter;
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java b/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
index ffb013af87251..c7b1d2f97b490 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
@@ -10,10 +10,12 @@
 
 import com.google.protobuf.CodedInputStream;
 import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportResponseHandler;
+import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.ProtobufTransportException;
-import org.opensearch.transport.ProtobufTransportResponse;
+import org.opensearch.transport.TransportException;
+import org.opensearch.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.Objects;
@@ -24,9 +26,9 @@
 *
 * @opensearch.api
 */
-public class ProtobufActionListenerResponseHandler<Response extends ProtobufTransportResponse>
+public class ProtobufActionListenerResponseHandler<Response extends TransportResponse>
     implements
-        ProtobufTransportResponseHandler<Response> {
+        TransportResponseHandler<Response> {
 
     private final ActionListener<? super Response> listener;
     private final ProtobufWriteable.Reader<Response> reader;
@@ -52,7 +54,7 @@ public void handleResponse(Response response) {
     }
 
     @Override
-    public void handleException(ProtobufTransportException e) {
+    public void handleExceptionProtobuf(ProtobufTransportException e) {
         listener.onFailure(e);
     }
 
@@ -70,4 +72,15 @@ public Response read(CodedInputStream in) throws IOException {
     public String toString() {
         return super.toString() + "/" + listener;
     }
+
+    @Override
+    public Response read(StreamInput in) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'read'");
+    }
+
+    @Override
+    public void handleException(TransportException exp) {
+        listener.onFailure(exp);
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionRequest.java b/server/src/main/java/org/opensearch/action/ProtobufActionRequest.java
index 013ac5cacb776..eb81bf81f9049 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionRequest.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionRequest.java
@@ -15,7 +15,7 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
-import org.opensearch.transport.ProtobufTransportRequest;
+import org.opensearch.transport.TransportRequest;
 
 import java.io.IOException;
 
@@ -24,7 +24,7 @@
 *
 * @opensearch.api
 */
-public abstract class ProtobufActionRequest extends ProtobufTransportRequest {
+public abstract class ProtobufActionRequest extends TransportRequest {
 
     public ProtobufActionRequest() {
         super();
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java b/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java
index f6cf420cb86fd..8c070f849ee0e 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java
@@ -14,7 +14,7 @@
 package org.opensearch.action;
 
 import com.google.protobuf.CodedInputStream;
-import org.opensearch.transport.ProtobufTransportResponse;
+import org.opensearch.transport.TransportResponse;
 
 import java.io.IOException;
 
@@ -23,7 +23,7 @@
 *
 * @opensearch.api
 */
-public abstract class ProtobufActionResponse extends ProtobufTransportResponse {
+public abstract class ProtobufActionResponse extends TransportResponse {
 
     public ProtobufActionResponse() {}
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
index e00dd900ffc35..b82d913f1e821 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
@@ -18,8 +18,8 @@
 import org.opensearch.common.inject.Inject;
 import org.opensearch.node.ProtobufNodeService;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportRequest;
-import org.opensearch.transport.ProtobufTransportService;
+import org.opensearch.transport.TransportRequest;
+import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
 import java.util.List;
@@ -42,7 +42,7 @@ public class ProtobufTransportNodesInfoAction extends ProtobufTransportNodesActi
     public ProtobufTransportNodesInfoAction(
         ThreadPool threadPool,
         ClusterService clusterService,
-        ProtobufTransportService transportService,
+        TransportService transportService,
         ProtobufNodeService nodeService,
         ProtobufActionFilters actionFilters
     ) {
@@ -66,16 +66,22 @@ protected ProtobufNodesInfoResponse newResponse(
         List<ProtobufNodeInfo> responses,
         List<ProtobufFailedNodeException> failures
     ) {
+        System.out.println("Inside newResponse");
+        System.out.println("nodesInfoRequest: " + nodesInfoRequest);
+        System.out.println("responses: " + responses);
+        System.out.println("failures: " + failures);
         return new ProtobufNodesInfoResponse(new ClusterName(clusterService.getClusterName().value()), responses, failures);
     }
 
     @Override
     protected NodeInfoRequest newNodeRequest(ProtobufNodesInfoRequest request) {
+        System.out.println("Inside newNodeRequest");
         return new NodeInfoRequest(request);
     }
 
     @Override
     protected ProtobufNodeInfo newNodeResponse(CodedInputStream in) throws IOException {
+        System.out.println("Inside newNodeResponse with input stream");
         return new ProtobufNodeInfo(in);
     }
 
@@ -105,7 +111,7 @@ protected ProtobufNodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
     *
     * @opensearch.internal
     */
-    public static class NodeInfoRequest extends ProtobufTransportRequest {
+    public static class NodeInfoRequest extends TransportRequest {
 
         ProtobufNodesInfoRequest request;
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
index 64cd1a887ac12..b73c09b370aea 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
@@ -89,16 +89,22 @@ protected NodesInfoResponse newResponse(
         List<NodeInfo> responses,
         List<FailedNodeException> failures
     ) {
+        System.out.println("Inside newResponse");
+        System.out.println("nodesInfoRequest: " + nodesInfoRequest);
+        System.out.println("responses: " + responses);
+        System.out.println("failures: " + failures);
         return new NodesInfoResponse(clusterService.getClusterName(), responses, failures);
     }
 
     @Override
     protected NodeInfoRequest newNodeRequest(NodesInfoRequest request) {
+        System.out.println("Inside newNodeRequest");
         return new NodeInfoRequest(request);
     }
 
     @Override
     protected NodeInfo newNodeResponse(StreamInput in) throws IOException {
+        System.out.println("Inside newNodeResponse with input stream");
         return new NodeInfo(in);
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
index ed7f8e4002dc0..481c3b624e399 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
@@ -18,8 +18,8 @@
 import org.opensearch.common.inject.Inject;
 import org.opensearch.node.ProtobufNodeService;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportRequest;
-import org.opensearch.transport.ProtobufTransportService;
+import org.opensearch.transport.TransportRequest;
+import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
 import java.util.List;
@@ -42,7 +42,7 @@ public class ProtobufTransportNodesStatsAction extends ProtobufTransportNodesAct
     public ProtobufTransportNodesStatsAction(
         ThreadPool threadPool,
         ClusterService clusterService,
-        ProtobufTransportService transportService,
+        TransportService transportService,
         ProtobufNodeService nodeService,
         ProtobufActionFilters actionFilters
     ) {
@@ -112,7 +112,7 @@ protected ProtobufNodeStats nodeOperation(NodeStatsRequest nodeStatsRequest) {
     *
     * @opensearch.internal
     */
-    public static class NodeStatsRequest extends ProtobufTransportRequest {
+    public static class NodeStatsRequest extends TransportRequest {
 
         ProtobufNodesStatsRequest request;
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
index 6247d45fac534..4565a52282b35 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
@@ -29,7 +29,7 @@
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.node.NodeClosedException;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportService;
+import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
 import java.util.function.Predicate;
@@ -55,7 +55,7 @@ public class ProtobufTransportClusterStateAction extends ProtobufTransportCluste
 
     @Inject
     public ProtobufTransportClusterStateAction(
-        ProtobufTransportService transportService,
+        TransportService transportService,
         ClusterService clusterService,
         ThreadPool threadPool,
         ProtobufActionFilters actionFilters,
diff --git a/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java b/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java
index acabc12af0e56..08dd2acfec50c 100644
--- a/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java
+++ b/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java
@@ -69,12 +69,15 @@
 import org.opensearch.search.internal.ShardSearchRequest;
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequestHandler;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.Collections;
 import java.util.HashMap;
@@ -339,6 +342,18 @@ public void handleResponse(final FieldCapabilitiesIndexResponse response) {
                         public void handleException(TransportException exp) {
                             onFailure(shardRouting, exp);
                         }
+
+                        @Override
+                        public FieldCapabilitiesIndexResponse read(CodedInputStream in) throws IOException {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'read'");
+                        }
+
+                        @Override
+                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                        }
                     }
                 );
             }
diff --git a/server/src/main/java/org/opensearch/action/main/ProtobufTransportMainAction.java b/server/src/main/java/org/opensearch/action/main/ProtobufTransportMainAction.java
index 0385dedaaeab3..a9340c10f541d 100644
--- a/server/src/main/java/org/opensearch/action/main/ProtobufTransportMainAction.java
+++ b/server/src/main/java/org/opensearch/action/main/ProtobufTransportMainAction.java
@@ -20,7 +20,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.node.Node;
 import org.opensearch.tasks.ProtobufTask;
-import org.opensearch.transport.ProtobufTransportService;
+import org.opensearch.transport.TransportService;
 
 /**
  * Performs the main action
@@ -35,7 +35,7 @@ public class ProtobufTransportMainAction extends ProtobufHandledTransportAction<
     @Inject
     public ProtobufTransportMainAction(
         Settings settings,
-        ProtobufTransportService transportService,
+        TransportService transportService,
         ProtobufActionFilters actionFilters,
         ClusterService clusterService
     ) {
diff --git a/server/src/main/java/org/opensearch/action/resync/TransportResyncReplicationAction.java b/server/src/main/java/org/opensearch/action/resync/TransportResyncReplicationAction.java
index 879250218405c..f574ae6bd6df2 100644
--- a/server/src/main/java/org/opensearch/action/resync/TransportResyncReplicationAction.java
+++ b/server/src/main/java/org/opensearch/action/resync/TransportResyncReplicationAction.java
@@ -56,10 +56,13 @@
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.threadpool.ThreadPool.Names;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.function.Function;
 import java.util.stream.Stream;
@@ -250,6 +253,18 @@ public void handleResponse(ResyncReplicationResponse response) {
                 public void handleException(TransportException exp) {
                     listener.onFailure(exp);
                 }
+
+                @Override
+                public ResyncReplicationResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
     }
diff --git a/server/src/main/java/org/opensearch/action/search/PitService.java b/server/src/main/java/org/opensearch/action/search/PitService.java
index 336c0f2c49793..61496264be5a6 100644
--- a/server/src/main/java/org/opensearch/action/search/PitService.java
+++ b/server/src/main/java/org/opensearch/action/search/PitService.java
@@ -8,6 +8,8 @@
 
 package org.opensearch.action.search;
 
+import com.google.protobuf.CodedInputStream;
+
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
@@ -21,6 +23,7 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.Strings;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
@@ -201,6 +204,18 @@ public String executor() {
                 public GetAllPitNodesResponse read(StreamInput in) throws IOException {
                     return new GetAllPitNodesResponse(in);
                 }
+
+                @Override
+                public GetAllPitNodesResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
     }
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufChannelActionListener.java b/server/src/main/java/org/opensearch/action/support/ProtobufChannelActionListener.java
index 217ce15684361..27fd929919318 100644
--- a/server/src/main/java/org/opensearch/action/support/ProtobufChannelActionListener.java
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufChannelActionListener.java
@@ -9,24 +9,24 @@
 package org.opensearch.action.support;
 
 import org.opensearch.action.ActionListener;
-import org.opensearch.transport.ProtobufTransportChannel;
-import org.opensearch.transport.ProtobufTransportRequest;
-import org.opensearch.transport.ProtobufTransportResponse;
+import org.opensearch.transport.TransportChannel;
+import org.opensearch.transport.TransportRequest;
+import org.opensearch.transport.TransportResponse;
 
 /**
  * Listener for transport channel actions
 *
 * @opensearch.internal
 */
-public final class ProtobufChannelActionListener<Response extends ProtobufTransportResponse, Request extends ProtobufTransportRequest>
+public final class ProtobufChannelActionListener<Response extends TransportResponse, Request extends TransportRequest>
     implements
         ActionListener<Response> {
 
-    private final ProtobufTransportChannel channel;
+    private final TransportChannel channel;
     private final Request request;
     private final String actionName;
 
-    public ProtobufChannelActionListener(ProtobufTransportChannel channel, String actionName, Request request) {
+    public ProtobufChannelActionListener(TransportChannel channel, String actionName, Request request) {
         this.channel = channel;
         this.request = request;
         this.actionName = actionName;
@@ -43,6 +43,6 @@ public void onResponse(Response response) {
 
     @Override
     public void onFailure(Exception e) {
-        ProtobufTransportChannel.sendErrorResponse(channel, actionName, request, e);
+        TransportChannel.sendErrorResponse(channel, actionName, request, e);
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java b/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
index cf054e8e9ece9..0078815cdaf62 100644
--- a/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
@@ -12,10 +12,12 @@
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.tasks.ProtobufTask;
+import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportChannel;
 import org.opensearch.transport.ProtobufTransportRequestHandler;
-import org.opensearch.transport.ProtobufTransportService;
+import org.opensearch.transport.TransportChannel;
+import org.opensearch.transport.TransportRequestHandler;
+import org.opensearch.transport.TransportService;
 
 /**
  * A ProtobufTransportAction that self registers a handler into the transport service
@@ -27,7 +29,7 @@ public abstract class ProtobufHandledTransportAction<Request extends ProtobufAct
 
     protected ProtobufHandledTransportAction(
         String actionName,
-        ProtobufTransportService transportService,
+        TransportService transportService,
         ProtobufActionFilters actionFilters,
         ProtobufWriteable.Reader<Request> requestReader
     ) {
@@ -36,7 +38,7 @@ protected ProtobufHandledTransportAction(
 
     protected ProtobufHandledTransportAction(
         String actionName,
-        ProtobufTransportService transportService,
+        TransportService transportService,
         ProtobufActionFilters actionFilters,
         ProtobufWriteable.Reader<Request> requestReader,
         String executor
@@ -47,7 +49,7 @@ protected ProtobufHandledTransportAction(
     protected ProtobufHandledTransportAction(
         String actionName,
         boolean canTripCircuitBreaker,
-        ProtobufTransportService transportService,
+        TransportService transportService,
         ProtobufActionFilters actionFilters,
         ProtobufWriteable.Reader<Request> requestReader
     ) {
@@ -57,13 +59,13 @@ protected ProtobufHandledTransportAction(
     protected ProtobufHandledTransportAction(
         String actionName,
         boolean canTripCircuitBreaker,
-        ProtobufTransportService transportService,
+        TransportService transportService,
         ProtobufActionFilters actionFilters,
         ProtobufWriteable.Reader<Request> requestReader,
         String executor
     ) {
         super(actionName, actionFilters, transportService.getTaskManager());
-        transportService.registerRequestHandler(actionName, executor, false, canTripCircuitBreaker, requestReader, new TransportHandler());
+        transportService.registerRequestHandlerProtobuf(actionName, executor, false, canTripCircuitBreaker, requestReader, new TransportHandler());
     }
 
     /**
@@ -73,7 +75,7 @@ protected ProtobufHandledTransportAction(
     */
     class TransportHandler implements ProtobufTransportRequestHandler<Request> {
         @Override
-        public final void messageReceived(final Request request, final ProtobufTransportChannel channel, ProtobufTask task) {
+        public final void messageReceived(final Request request, final TransportChannel channel, ProtobufTask task) {
             // We already got the task created on the network layer - no need to create it again on the transport layer
             execute(task, request, new ProtobufChannelActionListener<>(channel, actionName, request));
         }
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java b/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
index b23b7c8e78106..d0156218dc381 100644
--- a/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
@@ -67,7 +67,7 @@ public final ProtobufTask execute(Request request, ActionListener<Response> list
         * task. That just seems like too many objects. Thus the two versions of
         * this method.
         */
-        final Releasable unregisterChildNode = registerChildNode(request.getParentTask());
+        final Releasable unregisterChildNode = registerChildNode(request.getProtobufParentTask());
         final ProtobufTask task;
 
         try {
@@ -110,7 +110,7 @@ public void onFailure(Exception e) {
     * {@link ProtobufTaskListener} which listens for the completion of the action.
     */
     public final ProtobufTask execute(Request request, ProtobufTaskListener<Response> listener) {
-        final Releasable unregisterChildNode = registerChildNode(request.getParentTask());
+        final Releasable unregisterChildNode = registerChildNode(request.getProtobufParentTask());
         final ProtobufTask task;
         try {
             task = taskManager.registerProtobuf("transport", actionName, request);
diff --git a/server/src/main/java/org/opensearch/action/support/broadcast/TransportBroadcastAction.java b/server/src/main/java/org/opensearch/action/support/broadcast/TransportBroadcastAction.java
index cb77fa7c3ac57..109f73685901e 100644
--- a/server/src/main/java/org/opensearch/action/support/broadcast/TransportBroadcastAction.java
+++ b/server/src/main/java/org/opensearch/action/support/broadcast/TransportBroadcastAction.java
@@ -54,12 +54,15 @@
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequestHandler;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReferenceArray;
@@ -229,6 +232,18 @@ public void handleResponse(ShardResponse response) {
                                 public void handleException(TransportException e) {
                                     onOperation(shard, shardIt, shardIndex, e);
                                 }
+
+                                @Override
+                                public ShardResponse read(CodedInputStream in) throws IOException {
+                                    // TODO Auto-generated method stub
+                                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                                }
+
+                                @Override
+                                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                                    // TODO Auto-generated method stub
+                                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                                }
                             }
                         );
                     }
diff --git a/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java b/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
index bf71134ab7b88..597d45a35db3f 100644
--- a/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
@@ -59,6 +59,7 @@
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.NodeShouldNotConnectException;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
@@ -66,6 +67,9 @@
 import org.opensearch.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
+
+import com.google.protobuf.CodedInputStream;
+
 import org.opensearch.transport.TransportRequestOptions;
 
 import java.io.IOException;
@@ -392,6 +396,19 @@ public void handleException(TransportException exp) {
                         public String executor() {
                             return ThreadPool.Names.SAME;
                         }
+
+                        @Override
+                        public TransportBroadcastByNodeAction<Request, Response, ShardOperationResult>.NodeResponse read(
+                                CodedInputStream in) throws IOException {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'read'");
+                        }
+
+                        @Override
+                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                        }
                     }
                 );
             } catch (Exception e) {
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
index 119ab35688ddd..f9bf42f0c887e 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
@@ -44,7 +44,7 @@
 import org.opensearch.transport.ConnectTransportException;
 import org.opensearch.transport.ProtobufRemoteTransportException;
 import org.opensearch.transport.ProtobufTransportException;
-import org.opensearch.transport.ProtobufTransportService;
+import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
 import java.util.function.Predicate;
@@ -61,7 +61,7 @@ public abstract class ProtobufTransportClusterManagerNodeAction<
     private static final Logger logger = LogManager.getLogger(ProtobufTransportClusterManagerNodeAction.class);
 
     protected final ThreadPool threadPool;
-    protected final ProtobufTransportService transportService;
+    protected final TransportService transportService;
     protected final ClusterService clusterService;
     protected final IndexNameExpressionResolver indexNameExpressionResolver;
 
@@ -69,7 +69,7 @@ public abstract class ProtobufTransportClusterManagerNodeAction<
 
     protected ProtobufTransportClusterManagerNodeAction(
         String actionName,
-        ProtobufTransportService transportService,
+        TransportService transportService,
         ClusterService clusterService,
         ThreadPool threadPool,
         ProtobufActionFilters actionFilters,
@@ -82,7 +82,7 @@ protected ProtobufTransportClusterManagerNodeAction(
     protected ProtobufTransportClusterManagerNodeAction(
         String actionName,
         boolean canTripCircuitBreaker,
-        ProtobufTransportService transportService,
+        TransportService transportService,
         ClusterService clusterService,
         ThreadPool threadPool,
         ProtobufActionFilters actionFilters,
@@ -279,7 +279,7 @@ protected void doStart(ClusterState clusterState) {
                                 ProtobufTransportClusterManagerNodeAction.this::read
                             ) {
                                 @Override
-                                public void handleException(final ProtobufTransportException exp) {
+                                public void handleExceptionProtobuf(final ProtobufTransportException exp) {
                                     Throwable cause = exp.unwrapCause();
                                     if (cause instanceof ConnectTransportException
                                         || (exp instanceof ProtobufRemoteTransportException && cause instanceof NodeClosedException)) {
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeReadAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeReadAction.java
index f4fb0ed6fb03e..fe863eaa05c5d 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeReadAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeReadAction.java
@@ -14,7 +14,7 @@
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportService;
+import org.opensearch.transport.TransportService;
 
 /**
  * A base class for read operations that needs to be performed on the cluster-manager node.
@@ -28,7 +28,7 @@ public abstract class ProtobufTransportClusterManagerNodeReadAction<
 
     protected ProtobufTransportClusterManagerNodeReadAction(
         String actionName,
-        ProtobufTransportService transportService,
+        TransportService transportService,
         ClusterService clusterService,
         ThreadPool threadPool,
         ProtobufActionFilters actionFilters,
@@ -41,7 +41,7 @@ protected ProtobufTransportClusterManagerNodeReadAction(
     protected ProtobufTransportClusterManagerNodeReadAction(
         String actionName,
         boolean checkSizeLimit,
-        ProtobufTransportService transportService,
+        TransportService transportService,
         ClusterService clusterService,
         ThreadPool threadPool,
         ProtobufActionFilters actionFilters,
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/BaseNodeResponse.java b/server/src/main/java/org/opensearch/action/support/nodes/BaseNodeResponse.java
index 4a94f790c3443..60bbd7defaacf 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/BaseNodeResponse.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/BaseNodeResponse.java
@@ -37,6 +37,9 @@
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.transport.TransportResponse;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 
 /**
@@ -53,6 +56,11 @@ protected BaseNodeResponse(StreamInput in) throws IOException {
         node = new DiscoveryNode(in);
     }
 
+    protected BaseNodeResponse(CodedInputStream in) throws IOException {
+        super(in);
+        node = new DiscoveryNode(in);
+    }
+
     protected BaseNodeResponse(DiscoveryNode node) {
         assert node != null;
         this.node = node;
@@ -69,4 +77,9 @@ public DiscoveryNode getNode() {
     public void writeTo(StreamOutput out) throws IOException {
         node.writeTo(out);
     }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        node.writeTo(out);
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
index fb121e23a7953..1d9fdfd4b25d9 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
@@ -16,7 +16,7 @@
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.transport.ProtobufTransportResponse;
+import org.opensearch.transport.TransportResponse;
 
 import java.io.IOException;
 
@@ -25,7 +25,7 @@
 *
 * @opensearch.internal
 */
-public abstract class ProtobufBaseNodeResponse extends ProtobufTransportResponse {
+public abstract class ProtobufBaseNodeResponse extends TransportResponse {
 
     private DiscoveryNode node;
 
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
index 59e66c10473aa..45680d612f24f 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
@@ -19,16 +19,18 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.tasks.ProtobufTask;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.NodeShouldNotConnectException;
-import org.opensearch.transport.ProtobufTransportChannel;
+import org.opensearch.transport.TransportChannel;
+import org.opensearch.transport.TransportException;
 import org.opensearch.transport.ProtobufTransportException;
-import org.opensearch.transport.ProtobufTransportRequest;
+import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.ProtobufTransportRequestHandler;
 import org.opensearch.transport.TransportRequestOptions;
-import org.opensearch.transport.ProtobufTransportResponseHandler;
-import org.opensearch.transport.ProtobufTransportService;
+import org.opensearch.transport.TransportResponseHandler;
+import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -46,12 +48,12 @@
 public abstract class ProtobufTransportNodesAction<
     NodesRequest extends ProtobufBaseNodesRequest<NodesRequest>,
     NodesResponse extends ProtobufBaseNodesResponse,
-    NodeRequest extends ProtobufTransportRequest,
+    NodeRequest extends TransportRequest,
     NodeResponse extends ProtobufBaseNodeResponse> extends ProtobufHandledTransportAction<NodesRequest, NodesResponse> {
 
     protected final ThreadPool threadPool;
     protected final ClusterService clusterService;
-    protected final ProtobufTransportService transportService;
+    protected final TransportService transportService;
     protected final Class<NodeResponse> nodeResponseClass;
     protected final String transportNodeAction;
 
@@ -73,7 +75,7 @@ protected ProtobufTransportNodesAction(
         String actionName,
         ThreadPool threadPool,
         ClusterService clusterService,
-        ProtobufTransportService transportService,
+        TransportService transportService,
         ProtobufActionFilters actionFilters,
         ProtobufWriteable.Reader<NodesRequest> request,
         ProtobufWriteable.Reader<NodeRequest> nodeRequest,
@@ -89,11 +91,11 @@ protected ProtobufTransportNodesAction(
 
         this.transportNodeAction = actionName + "[n]";
         this.finalExecutor = finalExecutor;
-        transportService.registerRequestHandler(transportNodeAction, nodeExecutor, nodeRequest, new NodeTransportHandler());
+        transportService.registerRequestHandlerProtobuf(transportNodeAction, nodeExecutor, nodeRequest, new NodeTransportHandler());
     }
 
     /**
-     * Same as {@link #ProtobufTransportNodesAction(String, ThreadPool, ClusterService, ProtobufTransportService, ProtobufActionFilters, ProtobufWriteable.Reader,
+     * Same as {@link #ProtobufTransportNodesAction(String, ThreadPool, ClusterService, TransportService, ProtobufActionFilters, ProtobufWriteable.Reader,
     * ProtobufWriteable.Reader, String, String, Class)} but executes final response collection on the transport thread except for when the final
     * node response is received from the local node, in which case {@code nodeExecutor} is used.
     * This constructor should only be used for actions for which the creation of the final response is fast enough to be safely executed
@@ -103,7 +105,7 @@ protected ProtobufTransportNodesAction(
         String actionName,
         ThreadPool threadPool,
         ClusterService clusterService,
-        ProtobufTransportService transportService,
+        TransportService transportService,
         ProtobufActionFilters actionFilters,
         ProtobufWriteable.Reader<NodesRequest> request,
         ProtobufWriteable.Reader<NodeRequest> nodeRequest,
@@ -221,7 +223,9 @@ class AsyncAction {
         }
 
         void start() {
+            System.out.println("ProtoTransportNodesAction.AsyncAction.start");
             final DiscoveryNode[] nodes = request.concreteNodes();
+            System.out.println("Nodes: " + nodes[0]);
             if (nodes.length == 0) {
                 // nothing to notify
                 threadPool.generic().execute(() -> listener.onResponse(newResponse(request, responses)));
@@ -236,9 +240,9 @@ void start() {
                 final DiscoveryNode node = nodes[i];
                 final String nodeId = node.getId();
                 try {
-                    ProtobufTransportRequest nodeRequest = newNodeRequest(request);
+                    TransportRequest nodeRequest = newNodeRequest(request);
                     if (task != null) {
-                        nodeRequest.setParentTask(clusterService.localNode().getId(), task.getId());
+                        nodeRequest.setProtobufParentTask(clusterService.localNode().getId(), task.getId());
                     }
 
                     transportService.sendRequest(
@@ -246,7 +250,7 @@ void start() {
                         getTransportNodeAction(node),
                         nodeRequest,
                         builder.build(),
-                        new ProtobufTransportResponseHandler<NodeResponse>() {
+                        new TransportResponseHandler<NodeResponse>() {
                             @Override
                             public NodeResponse read(CodedInputStream in) throws IOException {
                                 return newNodeResponse(in);
@@ -254,11 +258,13 @@ public NodeResponse read(CodedInputStream in) throws IOException {
 
                             @Override
                             public void handleResponse(NodeResponse response) {
+                                System.out.println("ProtoTransportNodesAction.AsyncAction.start.handleResponse");
                                 onOperation(idx, response);
                             }
 
                             @Override
-                            public void handleException(ProtobufTransportException exp) {
+                            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                                System.out.println("ProtoTransportNodesAction.AsyncAction.start.handleExceptionProtobuf");
                                 onFailure(idx, node.getId(), exp);
                             }
 
@@ -266,6 +272,18 @@ public void handleException(ProtobufTransportException exp) {
                             public String executor() {
                                 return ThreadPool.Names.SAME;
                             }
+
+                            @Override
+                            public NodeResponse read(StreamInput in) throws IOException {
+                                // TODO Auto-generated method stub
+                                throw new UnsupportedOperationException("Unimplemented method 'read'");
+                            }
+
+                            @Override
+                            public void handleException(TransportException exp) {
+                                // TODO Auto-generated method stub
+                                throw new UnsupportedOperationException("Unimplemented method 'handleException'");
+                            }
                         }
                     );
                 } catch (Exception e) {
@@ -304,7 +322,7 @@ private void finishHim() {
     class NodeTransportHandler implements ProtobufTransportRequestHandler<NodeRequest> {
 
         @Override
-        public void messageReceived(NodeRequest request, ProtobufTransportChannel channel, ProtobufTask task) throws Exception {
+        public void messageReceived(NodeRequest request, TransportChannel channel, ProtobufTask task) throws Exception {
             channel.sendResponse(nodeOperation(request, task));
         }
     }
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java b/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
index 3f39d7b786ccb..002ac45007b4b 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
@@ -46,6 +46,7 @@
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.NodeShouldNotConnectException;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
@@ -54,6 +55,8 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -241,7 +244,9 @@ class AsyncAction {
         }
 
         void start() {
+            System.out.println("TransportNodesAction.AsyncAction.start");
             final DiscoveryNode[] nodes = request.concreteNodes();
+            System.out.println("Nodes: " + nodes[0]);
             if (nodes.length == 0) {
                 // nothing to notify
                 threadPool.generic().execute(() -> listener.onResponse(newResponse(request, responses)));
@@ -286,6 +291,18 @@ public void handleException(TransportException exp) {
                             public String executor() {
                                 return ThreadPool.Names.SAME;
                             }
+
+                            @Override
+                            public NodeResponse read(CodedInputStream in) throws IOException {
+                                // TODO Auto-generated method stub
+                                throw new UnsupportedOperationException("Unimplemented method 'read'");
+                            }
+
+                            @Override
+                            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                                // TODO Auto-generated method stub
+                                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                            }
                         }
                     );
                 } catch (Exception e) {
diff --git a/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java b/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java
index 5b3be4d077f3c..648321f2b060c 100644
--- a/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java
+++ b/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java
@@ -85,6 +85,7 @@
 import org.opensearch.tasks.TaskId;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ConnectTransportException;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
@@ -92,6 +93,8 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.Map;
 import java.util.Objects;
@@ -1102,6 +1105,18 @@ public void handleException(TransportException exp) {
                         finishWithUnexpectedFailure(e);
                     }
                 }
+
+                @Override
+                public Response read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             });
         }
 
diff --git a/server/src/main/java/org/opensearch/action/support/single/instance/TransportInstanceSingleOperationAction.java b/server/src/main/java/org/opensearch/action/support/single/instance/TransportInstanceSingleOperationAction.java
index 8014f1b280bf2..972f52d82b086 100644
--- a/server/src/main/java/org/opensearch/action/support/single/instance/TransportInstanceSingleOperationAction.java
+++ b/server/src/main/java/org/opensearch/action/support/single/instance/TransportInstanceSingleOperationAction.java
@@ -58,6 +58,7 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.threadpool.ThreadPool.Names;
 import org.opensearch.transport.ConnectTransportException;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequestHandler;
@@ -65,6 +66,8 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 
 import static org.opensearch.cluster.metadata.IndexNameExpressionResolver.EXCLUDED_DATA_STREAMS_KEY;
@@ -245,6 +248,18 @@ public void handleException(TransportException exp) {
                         listener.onFailure(exp);
                     }
                 }
+
+                @Override
+                public Response read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             });
         }
 
diff --git a/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java b/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java
index 9a5ce608da472..22eb74b03bf52 100644
--- a/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java
+++ b/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java
@@ -58,12 +58,15 @@
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequestHandler;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 
 import static org.opensearch.action.support.TransportActions.isShardNotAvailableException;
@@ -225,6 +228,20 @@ public void handleResponse(final Response response) {
                         public void handleException(TransportException exp) {
                             listener.onFailure(exp);
                         }
+
+                        @Override
+                        public Response read(CodedInputStream in) throws IOException {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'read'");
+                        }
+
+                        @Override
+                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                        }
+
+                        
                     }
                 );
             } else {
@@ -302,6 +319,18 @@ public void handleResponse(final Response response) {
                         public void handleException(TransportException exp) {
                             onFailure(finalShardRouting, exp);
                         }
+
+                        @Override
+                        public Response read(CodedInputStream in) throws IOException {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'read'");
+                        }
+
+                        @Override
+                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                        }
                     }
                 );
             }
diff --git a/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java b/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java
index bfd207e6f969f..b26e09b10e130 100644
--- a/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java
+++ b/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java
@@ -52,6 +52,7 @@
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.NodeShouldNotConnectException;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
@@ -61,6 +62,8 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
@@ -316,6 +319,19 @@ public void handleException(TransportException exp) {
                                     public String executor() {
                                         return ThreadPool.Names.SAME;
                                     }
+
+                                    @Override
+                                    public TransportTasksAction<OperationTask, TasksRequest, TasksResponse, TaskResponse>.NodeTasksResponse read(
+                                            CodedInputStream in) throws IOException {
+                                        // TODO Auto-generated method stub
+                                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                                    }
+
+                                    @Override
+                                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                                        // TODO Auto-generated method stub
+                                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                                    }
                                 }
                             );
                         }
diff --git a/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java b/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
index 0ed6bc96ef3d2..741c8392713c2 100644
--- a/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
+++ b/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
@@ -143,6 +143,9 @@ public <Request extends ProtobufActionRequest, Response extends ProtobufActionRe
             Request request,
             ActionListener<Response> listener
         ) {
+            System.out.println("Nodes info execute");
+            System.out.println("action: " + action);
+            System.out.println("request: " + request);
             client.execute(action, request, listener);
         }
 
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterModule.java b/server/src/main/java/org/opensearch/cluster/ClusterModule.java
index d6c84eab5213b..eede99d26cb5a 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterModule.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterModule.java
@@ -41,7 +41,6 @@
 import org.opensearch.cluster.metadata.DataStreamMetadata;
 import org.opensearch.cluster.metadata.IndexGraveyard;
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
-import org.opensearch.cluster.metadata.ProtobufIndexNameExpressionResolver;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.metadata.MetadataDeleteIndexService;
 import org.opensearch.cluster.metadata.MetadataIndexAliasesService;
@@ -130,7 +129,7 @@ public class ClusterModule extends AbstractModule {
 
     private final ClusterService clusterService;
     private final IndexNameExpressionResolver indexNameExpressionResolver;
-    private final ProtobufIndexNameExpressionResolver protobufIndexNameExpressionResolver;
+    // private final ProtobufIndexNameExpressionResolver protobufIndexNameExpressionResolver;
     private final AllocationDeciders allocationDeciders;
     private final AllocationService allocationService;
     private final List<ClusterPlugin> clusterPlugins;
@@ -152,7 +151,7 @@ public ClusterModule(
         this.shardsAllocator = createShardsAllocator(settings, clusterService.getClusterSettings(), clusterPlugins);
         this.clusterService = clusterService;
         this.indexNameExpressionResolver = new IndexNameExpressionResolver(threadContext);
-        this.protobufIndexNameExpressionResolver = new ProtobufIndexNameExpressionResolver(threadContext);
+        // this.protobufIndexNameExpressionResolver = new ProtobufIndexNameExpressionResolver(threadContext);
         this.allocationService = new AllocationService(allocationDeciders, shardsAllocator, clusterInfoService, snapshotsInfoService);
     }
 
@@ -345,9 +344,9 @@ public IndexNameExpressionResolver getIndexNameExpressionResolver() {
         return indexNameExpressionResolver;
     }
 
-    public ProtobufIndexNameExpressionResolver getProtobufIndexNameExpressionResolver() {
-        return protobufIndexNameExpressionResolver;
-    }
+    // public ProtobufIndexNameExpressionResolver getProtobufIndexNameExpressionResolver() {
+    //     return protobufIndexNameExpressionResolver;
+    // }
 
     // TODO: this is public so allocation benchmark can access the default deciders...can we do that in another way?
     /** Return a new {@link AllocationDecider} instance with builtin deciders as well as those from plugins. */
@@ -432,7 +431,7 @@ protected void configure() {
         bind(MetadataUpdateSettingsService.class).asEagerSingleton();
         bind(MetadataIndexTemplateService.class).asEagerSingleton();
         bind(IndexNameExpressionResolver.class).toInstance(indexNameExpressionResolver);
-        bind(ProtobufIndexNameExpressionResolver.class).toInstance(protobufIndexNameExpressionResolver);
+        // bind(ProtobufIndexNameExpressionResolver.class).toInstance(protobufIndexNameExpressionResolver);
         bind(DelayedAllocationService.class).asEagerSingleton();
         bind(ShardStateAction.class).asEagerSingleton();
         bind(NodeMappingRefreshAction.class).asEagerSingleton();
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java b/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java
index 08008152cfcd6..67396c892fd18 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java
@@ -48,6 +48,7 @@
 import org.opensearch.monitor.StatusInfo;
 import org.opensearch.threadpool.ThreadPool.Names;
 import org.opensearch.transport.ConnectTransportException;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportConnectionListener;
@@ -59,6 +60,8 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.HashSet;
 import java.util.Map;
@@ -400,6 +403,18 @@ public void handleException(TransportException exp) {
                     public String executor() {
                         return Names.SAME;
                     }
+
+                    @Override
+                    public Empty read(CodedInputStream in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
+
+                    @Override
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                    }
                 }
             );
         }
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java b/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java
index 42f09f95a7f56..afaa4d8e72933 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java
@@ -62,6 +62,7 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.threadpool.ThreadPool.Names;
 import org.opensearch.transport.BytesTransportRequest;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.RemoteTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
@@ -72,6 +73,8 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.Collection;
 import java.util.Collections;
@@ -413,6 +416,18 @@ public void handleException(TransportException exp) {
                     public String executor() {
                         return Names.SAME;
                     }
+
+                    @Override
+                    public Empty read(CodedInputStream in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
+
+                    @Override
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                    }
                 }
             );
         } else {
@@ -443,6 +458,18 @@ public void handleException(TransportException exp) {
             public String executor() {
                 return ThreadPool.Names.SAME;
             }
+
+            @Override
+            public Empty read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         });
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java b/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java
index f43abf0080575..18a0877e79639 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java
@@ -50,6 +50,7 @@
 import org.opensearch.threadpool.ThreadPool.Names;
 import org.opensearch.transport.ConnectTransportException;
 import org.opensearch.transport.NodeDisconnectedException;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportConnectionListener;
 import org.opensearch.transport.TransportException;
@@ -61,6 +62,8 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -340,6 +343,18 @@ public void handleException(TransportException exp) {
                     public String executor() {
                         return Names.SAME;
                     }
+
+                    @Override
+                    public Empty read(CodedInputStream in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
+
+                    @Override
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                    }
                 }
             );
         }
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/PreVoteCollector.java b/server/src/main/java/org/opensearch/cluster/coordination/PreVoteCollector.java
index f8e568d3f5a0a..d673fb4ac388a 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/PreVoteCollector.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/PreVoteCollector.java
@@ -45,10 +45,13 @@
 import org.opensearch.monitor.NodeHealthService;
 import org.opensearch.monitor.StatusInfo;
 import org.opensearch.threadpool.ThreadPool.Names;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -217,6 +220,18 @@ public String executor() {
                         public String toString() {
                             return "TransportResponseHandler{" + PreVoteCollector.this + ", node=" + n + '}';
                         }
+
+                        @Override
+                        public PreVoteResponse read(CodedInputStream in) throws IOException {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'read'");
+                        }
+
+                        @Override
+                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                        }
                     }
                 )
             );
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java b/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
index 3e426ce557ba9..adb80c7687514 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
@@ -48,13 +48,17 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.BytesTransportRequest;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequestOptions;
 import org.opensearch.transport.TransportResponse;
+import org.opensearch.transport.TransportResponse.Empty;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
@@ -388,6 +392,18 @@ public void handleException(TransportException exp) {
                     public String executor() {
                         return ThreadPool.Names.GENERIC;
                     }
+
+                    @Override
+                    public Empty read(CodedInputStream in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
+
+                    @Override
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                    }
                 }
             );
         }
@@ -459,6 +475,18 @@ public void handleException(TransportException exp) {
                     public String executor() {
                         return ThreadPool.Names.GENERIC;
                     }
+
+                    @Override
+                    public PublishWithJoinResponse read(CodedInputStream in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
+
+                    @Override
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                    }
                 };
                 transportService.sendRequest(destination, PUBLISH_STATE_ACTION_NAME, request, stateRequestOptions, responseHandler);
             } catch (Exception e) {
diff --git a/server/src/main/java/org/opensearch/cluster/decommission/DecommissionController.java b/server/src/main/java/org/opensearch/cluster/decommission/DecommissionController.java
index 7a21dae35af94..be9042e96c661 100644
--- a/server/src/main/java/org/opensearch/cluster/decommission/DecommissionController.java
+++ b/server/src/main/java/org/opensearch/cluster/decommission/DecommissionController.java
@@ -31,10 +31,13 @@
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.http.HttpStats;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -257,6 +260,18 @@ public String executor() {
                 public NodesStatsResponse read(StreamInput in) throws IOException {
                     return new NodesStatsResponse(in);
                 }
+
+                @Override
+                public NodesStatsResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
     }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/ProtobufIndexNameExpressionResolver.java b/server/src/main/java/org/opensearch/cluster/metadata/ProtobufIndexNameExpressionResolver.java
index 8a8e2b2545150..27b4d4446014a 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/ProtobufIndexNameExpressionResolver.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/ProtobufIndexNameExpressionResolver.java
@@ -1,1351 +1,1351 @@
-/*
- * 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.
- */
-
-package org.opensearch.cluster.metadata;
-
-import org.opensearch.OpenSearchParseException;
-import org.opensearch.action.IndicesRequest;
-import org.opensearch.action.support.IndicesOptions;
-import org.opensearch.cluster.ProtobufClusterState;
-import org.opensearch.common.Booleans;
-import org.opensearch.common.Nullable;
-import org.opensearch.common.Strings;
-import org.opensearch.common.collect.ImmutableOpenMap;
-import org.opensearch.common.collect.Tuple;
-import org.opensearch.common.logging.DeprecationLogger;
-import org.opensearch.common.regex.Regex;
-import org.opensearch.common.time.DateFormatter;
-import org.opensearch.common.time.DateMathParser;
-import org.opensearch.common.time.DateUtils;
-import org.opensearch.common.util.CollectionUtils;
-import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.common.util.set.Sets;
-import org.opensearch.index.Index;
-import org.opensearch.index.IndexNotFoundException;
-import org.opensearch.indices.IndexClosedException;
-import org.opensearch.indices.InvalidIndexNameException;
-
-import java.time.Instant;
-import java.time.ZoneId;
-import java.time.ZoneOffset;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.SortedMap;
-import java.util.Spliterators;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-import java.util.stream.StreamSupport;
-
-/**
- * Resolves index name from an expression
- *
- * @opensearch.internal
- */
-public class ProtobufIndexNameExpressionResolver {
-    private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(ProtobufIndexNameExpressionResolver.class);
-
-    public static final String EXCLUDED_DATA_STREAMS_KEY = "opensearch.excluded_ds";
-    public static final String SYSTEM_INDEX_ACCESS_CONTROL_HEADER_KEY = "_system_index_access_allowed";
-
-    private final DateMathExpressionResolver dateMathExpressionResolver = new DateMathExpressionResolver();
-    private final WildcardExpressionResolver wildcardExpressionResolver = new WildcardExpressionResolver();
-    private final List<ExpressionResolver> expressionResolvers = List.of(dateMathExpressionResolver, wildcardExpressionResolver);
-
-    private final ThreadContext threadContext;
-
-    public ProtobufIndexNameExpressionResolver(ThreadContext threadContext) {
-        this.threadContext = Objects.requireNonNull(threadContext, "Thread Context must not be null");
-    }
-
-    /**
-     * Same as {@link #concreteIndexNames(ProtobufClusterState, IndicesOptions, String...)}, but the index expressions and options
-     * are encapsulated in the specified request.
-     */
-    public String[] concreteIndexNames(ProtobufClusterState state, IndicesRequest request) {
-        Context context = new Context(
-            state,
-            request.indicesOptions(),
-            false,
-            false,
-            request.includeDataStreams(),
-            isSystemIndexAccessAllowed()
-        );
-        return concreteIndexNames(context, request.indices());
-    }
-
-    /**
-     * Same as {@link #concreteIndexNames(ProtobufClusterState, IndicesRequest)}, but access to system indices is always allowed.
-     */
-    public String[] concreteIndexNamesWithSystemIndexAccess(ProtobufClusterState state, IndicesRequest request) {
-        Context context = new Context(state, request.indicesOptions(), false, false, request.includeDataStreams(), true);
-        return concreteIndexNames(context, request.indices());
-    }
-
-    /**
-     * Same as {@link #concreteIndices(ProtobufClusterState, IndicesOptions, String...)}, but the index expressions and options
-     * are encapsulated in the specified request and resolves data streams.
-     */
-    public Index[] concreteIndices(ProtobufClusterState state, IndicesRequest request) {
-        Context context = new Context(
-            state,
-            request.indicesOptions(),
-            false,
-            false,
-            request.includeDataStreams(),
-            isSystemIndexAccessAllowed()
-        );
-        return concreteIndices(context, request.indices());
-    }
-
-    /**
-     * Translates the provided index expression into actual concrete indices, properly deduplicated.
-     *
-     * @param state             the cluster state containing all the data to resolve to expressions to concrete indices
-     * @param options           defines how the aliases or indices need to be resolved to concrete indices
-     * @param indexExpressions  expressions that can be resolved to alias or index names.
-     * @return the resolved concrete indices based on the cluster state, indices options and index expressions
-     * @throws IndexNotFoundException if one of the index expressions is pointing to a missing index or alias and the
-     * provided indices options in the context don't allow such a case, or if the final result of the indices resolution
-     * contains no indices and the indices options in the context don't allow such a case.
-     * @throws IllegalArgumentException if one of the aliases resolve to multiple indices and the provided
-     * indices options in the context don't allow such a case.
-     */
-    public String[] concreteIndexNames(ProtobufClusterState state, IndicesOptions options, String... indexExpressions) {
-        Context context = new Context(state, options, isSystemIndexAccessAllowed());
-        return concreteIndexNames(context, indexExpressions);
-    }
-
-    public String[] concreteIndexNames(
-        ProtobufClusterState state,
-        IndicesOptions options,
-        boolean includeDataStreams,
-        String... indexExpressions
-    ) {
-        Context context = new Context(state, options, false, false, includeDataStreams, isSystemIndexAccessAllowed());
-        return concreteIndexNames(context, indexExpressions);
-    }
-
-    public String[] concreteIndexNames(ProtobufClusterState state, IndicesOptions options, IndicesRequest request) {
-        Context context = new Context(state, options, false, false, request.includeDataStreams(), isSystemIndexAccessAllowed());
-        return concreteIndexNames(context, request.indices());
-    }
-
-    public List<String> dataStreamNames(ProtobufClusterState state, IndicesOptions options, String... indexExpressions) {
-        // Allow system index access - they'll be filtered out below as there's no such thing (yet) as system data streams
-        Context context = new Context(state, options, false, false, true, true, true);
-        if (indexExpressions == null || indexExpressions.length == 0) {
-            indexExpressions = new String[] { "*" };
-        }
-
-        List<String> dataStreams = wildcardExpressionResolver.resolve(context, Arrays.asList(indexExpressions));
-        return ((dataStreams == null) ? List.<String>of() : dataStreams).stream()
-            .map(x -> state.metadata().getIndicesLookup().get(x))
-            .filter(Objects::nonNull)
-            .filter(ia -> ia.getType() == IndexAbstraction.Type.DATA_STREAM)
-            .map(IndexAbstraction::getName)
-            .collect(Collectors.toList());
-    }
-
-    /**
-     * Translates the provided index expression into actual concrete indices, properly deduplicated.
-     *
-     * @param state             the cluster state containing all the data to resolve to expressions to concrete indices
-     * @param options           defines how the aliases or indices need to be resolved to concrete indices
-     * @param indexExpressions  expressions that can be resolved to alias or index names.
-     * @return the resolved concrete indices based on the cluster state, indices options and index expressions
-     * @throws IndexNotFoundException if one of the index expressions is pointing to a missing index or alias and the
-     * provided indices options in the context don't allow such a case, or if the final result of the indices resolution
-     * contains no indices and the indices options in the context don't allow such a case.
-     * @throws IllegalArgumentException if one of the aliases resolve to multiple indices and the provided
-     * indices options in the context don't allow such a case.
-     */
-    public Index[] concreteIndices(ProtobufClusterState state, IndicesOptions options, String... indexExpressions) {
-        return concreteIndices(state, options, false, indexExpressions);
-    }
-
-    public Index[] concreteIndices(
-        ProtobufClusterState state,
-        IndicesOptions options,
-        boolean includeDataStreams,
-        String... indexExpressions
-    ) {
-        Context context = new Context(state, options, false, false, includeDataStreams, isSystemIndexAccessAllowed());
-        return concreteIndices(context, indexExpressions);
-    }
-
-    /**
-     * Translates the provided index expression into actual concrete indices, properly deduplicated.
-     *
-     * @param state      the cluster state containing all the data to resolve to expressions to concrete indices
-     * @param startTime  The start of the request where concrete indices is being invoked for
-     * @param request    request containing expressions that can be resolved to alias, index, or data stream names.
-     * @return the resolved concrete indices based on the cluster state, indices options and index expressions
-     * provided indices options in the context don't allow such a case, or if the final result of the indices resolution
-     * contains no indices and the indices options in the context don't allow such a case.
-     * @throws IllegalArgumentException if one of the aliases resolve to multiple indices and the provided
-     * indices options in the context don't allow such a case.
-     */
-    public Index[] concreteIndices(ProtobufClusterState state, IndicesRequest request, long startTime) {
-        Context context = new Context(
-            state,
-            request.indicesOptions(),
-            startTime,
-            false,
-            false,
-            request.includeDataStreams(),
-            false,
-            isSystemIndexAccessAllowed()
-        );
-        return concreteIndices(context, request.indices());
-    }
-
-    String[] concreteIndexNames(Context context, String... indexExpressions) {
-        Index[] indexes = concreteIndices(context, indexExpressions);
-        String[] names = new String[indexes.length];
-        for (int i = 0; i < indexes.length; i++) {
-            names[i] = indexes[i].getName();
-        }
-        return names;
-    }
-
-    Index[] concreteIndices(Context context, String... indexExpressions) {
-        if (indexExpressions == null || indexExpressions.length == 0) {
-            indexExpressions = new String[] { Metadata.ALL };
-        }
-        Metadata metadata = context.getState().metadata();
-        IndicesOptions options = context.getOptions();
-        // If only one index is specified then whether we fail a request if an index is missing depends on the allow_no_indices
-        // option. At some point we should change this, because there shouldn't be a reason why whether a single index
-        // or multiple indices are specified yield different behaviour.
-        final boolean failNoIndices = indexExpressions.length == 1 ? !options.allowNoIndices() : !options.ignoreUnavailable();
-        List<String> expressions = Arrays.asList(indexExpressions);
-        for (ExpressionResolver expressionResolver : expressionResolvers) {
-            expressions = expressionResolver.resolve(context, expressions);
-        }
-
-        if (expressions.isEmpty()) {
-            if (!options.allowNoIndices()) {
-                IndexNotFoundException infe;
-                if (indexExpressions.length == 1) {
-                    if (indexExpressions[0].equals(Metadata.ALL)) {
-                        infe = new IndexNotFoundException("no indices exist", (String) null);
-                    } else {
-                        infe = new IndexNotFoundException((String) null);
-                    }
-                } else {
-                    infe = new IndexNotFoundException((String) null);
-                }
-                infe.setResources("index_expression", indexExpressions);
-                throw infe;
-            } else {
-                return Index.EMPTY_ARRAY;
-            }
-        }
-
-        boolean excludedDataStreams = false;
-        final Set<Index> concreteIndices = new HashSet<>(expressions.size());
-        for (String expression : expressions) {
-            IndexAbstraction indexAbstraction = metadata.getIndicesLookup().get(expression);
-            if (indexAbstraction == null) {
-                if (failNoIndices) {
-                    IndexNotFoundException infe;
-                    if (expression.equals(Metadata.ALL)) {
-                        infe = new IndexNotFoundException("no indices exist", expression);
-                    } else {
-                        infe = new IndexNotFoundException(expression);
-                    }
-                    infe.setResources("index_expression", expression);
-                    throw infe;
-                } else {
-                    continue;
-                }
-            } else if (indexAbstraction.getType() == IndexAbstraction.Type.ALIAS && context.getOptions().ignoreAliases()) {
-                if (failNoIndices) {
-                    throw aliasesNotSupportedException(expression);
-                } else {
-                    continue;
-                }
-            } else if (indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM && context.includeDataStreams() == false) {
-                excludedDataStreams = true;
-                continue;
-            }
-
-            if (indexAbstraction.getType() == IndexAbstraction.Type.ALIAS && context.isResolveToWriteIndex()) {
-                IndexMetadata writeIndex = indexAbstraction.getWriteIndex();
-                if (writeIndex == null) {
-                    throw new IllegalArgumentException(
-                        "no write index is defined for alias ["
-                            + indexAbstraction.getName()
-                            + "]."
-                            + " The write index may be explicitly disabled using is_write_index=false or the alias points to multiple"
-                            + " indices without one being designated as a write index"
-                    );
-                }
-                if (addIndex(writeIndex, context)) {
-                    concreteIndices.add(writeIndex.getIndex());
-                }
-            } else if (indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM && context.isResolveToWriteIndex()) {
-                IndexMetadata writeIndex = indexAbstraction.getWriteIndex();
-                if (addIndex(writeIndex, context)) {
-                    concreteIndices.add(writeIndex.getIndex());
-                }
-            } else {
-                if (indexAbstraction.getIndices().size() > 1 && !options.allowAliasesToMultipleIndices()) {
-                    String[] indexNames = new String[indexAbstraction.getIndices().size()];
-                    int i = 0;
-                    for (IndexMetadata indexMetadata : indexAbstraction.getIndices()) {
-                        indexNames[i++] = indexMetadata.getIndex().getName();
-                    }
-                    throw new IllegalArgumentException(
-                        indexAbstraction.getType().getDisplayName()
-                            + " ["
-                            + expression
-                            + "] has more than one index associated with it "
-                            + Arrays.toString(indexNames)
-                            + ", can't execute a single index op"
-                    );
-                }
-
-                for (IndexMetadata index : indexAbstraction.getIndices()) {
-                    if (shouldTrackConcreteIndex(context, options, index)) {
-                        concreteIndices.add(index.getIndex());
-                    }
-                }
-            }
-        }
-
-        if (options.allowNoIndices() == false && concreteIndices.isEmpty()) {
-            IndexNotFoundException infe = new IndexNotFoundException((String) null);
-            infe.setResources("index_expression", indexExpressions);
-            if (excludedDataStreams) {
-                // Allows callers to handle IndexNotFoundException differently based on whether data streams were excluded.
-                infe.addMetadata(EXCLUDED_DATA_STREAMS_KEY, "true");
-            }
-            throw infe;
-        }
-        checkSystemIndexAccess(context, metadata, concreteIndices, indexExpressions);
-        return concreteIndices.toArray(new Index[0]);
-    }
-
-    private void checkSystemIndexAccess(Context context, Metadata metadata, Set<Index> concreteIndices, String[] originalPatterns) {
-        if (context.isSystemIndexAccessAllowed() == false) {
-            final List<String> resolvedSystemIndices = concreteIndices.stream()
-                .map(metadata::index)
-                .filter(IndexMetadata::isSystem)
-                .map(i -> i.getIndex().getName())
-                .sorted() // reliable order for testing
-                .collect(Collectors.toList());
-            if (resolvedSystemIndices.isEmpty() == false) {
-                resolvedSystemIndices.forEach(
-                    systemIndexName -> deprecationLogger.deprecate(
-                        "open_system_index_access_" + systemIndexName,
-                        "this request accesses system indices: [{}], but in a future major version, direct access to system "
-                            + "indices will be prevented by default",
-                        systemIndexName
-                    )
-                );
-            }
-        }
-    }
-
-    private static boolean shouldTrackConcreteIndex(Context context, IndicesOptions options, IndexMetadata index) {
-        if (index.getState() == IndexMetadata.State.CLOSE) {
-            if (options.forbidClosedIndices() && options.ignoreUnavailable() == false) {
-                throw new IndexClosedException(index.getIndex());
-            } else {
-                return options.forbidClosedIndices() == false && addIndex(index, context);
-            }
-        } else if (index.getState() == IndexMetadata.State.OPEN) {
-            return addIndex(index, context);
-        } else {
-            throw new IllegalStateException("index state [" + index.getState() + "] not supported");
-        }
-    }
-
-    private static boolean addIndex(IndexMetadata metadata, Context context) {
-        // This used to check the `index.search.throttled` setting, but we eventually decided that it was
-        // trappy to hide throttled indices by default. In order to avoid breaking backward compatibility,
-        // we changed it to look at the `index.frozen` setting instead, since frozen indices were the only
-        // type of index to use the `search_throttled` threadpool at that time.
-        // NOTE: The Setting object was defined in an external plugin prior to OpenSearch fork.
-        return (context.options.ignoreThrottled() && metadata.getSettings().getAsBoolean("index.frozen", false)) == false;
-    }
-
-    private static IllegalArgumentException aliasesNotSupportedException(String expression) {
-        return new IllegalArgumentException(
-            "The provided expression [" + expression + "] matches an " + "alias, specify the corresponding concrete indices instead."
-        );
-    }
-
-    /**
-     * Utility method that allows to resolve an index expression to its corresponding single concrete index.
-     * Callers should make sure they provide proper {@link org.opensearch.action.support.IndicesOptions}
-     * that require a single index as a result. The indices resolution must in fact return a single index when
-     * using this method, an {@link IllegalArgumentException} gets thrown otherwise.
-     *
-     * @param state             the cluster state containing all the data to resolve to expression to a concrete index
-     * @param request           The request that defines how the an alias or an index need to be resolved to a concrete index
-     *                          and the expression that can be resolved to an alias or an index name.
-     * @throws IllegalArgumentException if the index resolution lead to more than one index
-     * @return the concrete index obtained as a result of the index resolution
-     */
-    public Index concreteSingleIndex(ProtobufClusterState state, IndicesRequest request) {
-        String indexExpression = CollectionUtils.isEmpty(request.indices()) ? null : request.indices()[0];
-        Index[] indices = concreteIndices(state, request.indicesOptions(), indexExpression);
-        if (indices.length != 1) {
-            throw new IllegalArgumentException(
-                "unable to return a single index as the index and options" + " provided got resolved to multiple indices"
-            );
-        }
-        return indices[0];
-    }
-
-    /**
-     * Utility method that allows to resolve an index expression to its corresponding single write index.
-     *
-     * @param state             the cluster state containing all the data to resolve to expression to a concrete index
-     * @param request           The request that defines how the an alias or an index need to be resolved to a concrete index
-     *                          and the expression that can be resolved to an alias or an index name.
-     * @throws IllegalArgumentException if the index resolution does not lead to an index, or leads to more than one index
-     * @return the write index obtained as a result of the index resolution
-     */
-    public Index concreteWriteIndex(ProtobufClusterState state, IndicesRequest request) {
-        if (request.indices() == null || (request.indices() != null && request.indices().length != 1)) {
-            throw new IllegalArgumentException("indices request must specify a single index expression");
-        }
-        return concreteWriteIndex(state, request.indicesOptions(), request.indices()[0], false, request.includeDataStreams());
-    }
-
-    /**
-     * Utility method that allows to resolve an index expression to its corresponding single write index.
-     *
-     * @param state             the cluster state containing all the data to resolve to expression to a concrete index
-     * @param options           defines how the aliases or indices need to be resolved to concrete indices
-     * @param index             index that can be resolved to alias or index name.
-     * @param allowNoIndices    whether to allow resolve to no index
-     * @param includeDataStreams Whether data streams should be included in the evaluation.
-     * @throws IllegalArgumentException if the index resolution does not lead to an index, or leads to more than one index
-     * @return the write index obtained as a result of the index resolution or null if no index
-     */
-    public Index concreteWriteIndex(
-        ProtobufClusterState state,
-        IndicesOptions options,
-        String index,
-        boolean allowNoIndices,
-        boolean includeDataStreams
-    ) {
-        IndicesOptions combinedOptions = IndicesOptions.fromOptions(
-            options.ignoreUnavailable(),
-            allowNoIndices,
-            options.expandWildcardsOpen(),
-            options.expandWildcardsClosed(),
-            options.expandWildcardsHidden(),
-            options.allowAliasesToMultipleIndices(),
-            options.forbidClosedIndices(),
-            options.ignoreAliases(),
-            options.ignoreThrottled()
-        );
-
-        Context context = new Context(state, combinedOptions, false, true, includeDataStreams, isSystemIndexAccessAllowed());
-        Index[] indices = concreteIndices(context, index);
-        if (allowNoIndices && indices.length == 0) {
-            return null;
-        }
-        if (indices.length != 1) {
-            throw new IllegalArgumentException(
-                "The index expression [" + index + "] and options provided did not point to a single write-index"
-            );
-        }
-        return indices[0];
-    }
-
-    /**
-     * @return whether the specified index, data stream or alias exists.
-     *         If the data stream, index or alias contains date math then that is resolved too.
-     */
-    public boolean hasIndexAbstraction(String indexAbstraction, ProtobufClusterState state) {
-        Context context = new Context(state, IndicesOptions.lenientExpandOpen(), false, false, true, isSystemIndexAccessAllowed());
-        String resolvedAliasOrIndex = dateMathExpressionResolver.resolveExpression(indexAbstraction, context);
-        return state.metadata().getIndicesLookup().containsKey(resolvedAliasOrIndex);
-    }
-
-    /**
-     * @return If the specified string is data math expression then this method returns the resolved expression.
-     */
-    public String resolveDateMathExpression(String dateExpression) {
-        // The data math expression resolver doesn't rely on cluster state or indices options, because
-        // it just resolves the date math to an actual date.
-        return dateMathExpressionResolver.resolveExpression(dateExpression, new Context(null, null, isSystemIndexAccessAllowed()));
-    }
-
-    /**
-     * Resolve an array of expressions to the set of indices and aliases that these expressions match.
-     */
-    public Set<String> resolveExpressions(ProtobufClusterState state, String... expressions) {
-        Context context = new Context(state, IndicesOptions.lenientExpandOpen(), true, false, true, isSystemIndexAccessAllowed());
-        List<String> resolvedExpressions = Arrays.asList(expressions);
-        for (ExpressionResolver expressionResolver : expressionResolvers) {
-            resolvedExpressions = expressionResolver.resolve(context, resolvedExpressions);
-        }
-        return Collections.unmodifiableSet(new HashSet<>(resolvedExpressions));
-    }
-
-    /**
-     * Iterates through the list of indices and selects the effective list of filtering aliases for the
-     * given index.
-     * <p>Only aliases with filters are returned. If the indices list contains a non-filtering reference to
-     * the index itself - null is returned. Returns {@code null} if no filtering is required.
-     * <b>NOTE</b>: The provided expressions must have been resolved already via {@link #resolveExpressions}.
-     */
-    public String[] filteringAliases(ProtobufClusterState state, String index, Set<String> resolvedExpressions) {
-        return indexAliases(state, index, AliasMetadata::filteringRequired, false, resolvedExpressions);
-    }
-
-    /**
-     * Whether to generate the candidate set from index aliases, or from the set of resolved expressions.
-     * @param indexAliasesSize        the number of aliases of the index
-     * @param resolvedExpressionsSize the number of resolved expressions
-     */
-    // pkg-private for testing
-    boolean iterateIndexAliases(int indexAliasesSize, int resolvedExpressionsSize) {
-        return indexAliasesSize <= resolvedExpressionsSize;
-    }
-
-    /**
-     * Iterates through the list of indices and selects the effective list of required aliases for the given index.
-     * <p>Only aliases where the given predicate tests successfully are returned. If the indices list contains a non-required reference to
-     * the index itself - null is returned. Returns {@code null} if no filtering is required.
-     * <p><b>NOTE</b>: the provided expressions must have been resolved already via {@link #resolveExpressions}.
-     */
-    public String[] indexAliases(
-        ProtobufClusterState state,
-        String index,
-        Predicate<AliasMetadata> requiredAlias,
-        boolean skipIdentity,
-        Set<String> resolvedExpressions
-    ) {
-        if (isAllIndices(resolvedExpressions)) {
-            return null;
-        }
-
-        final IndexMetadata indexMetadata = state.metadata().getIndices().get(index);
-        if (indexMetadata == null) {
-            // Shouldn't happen
-            throw new IndexNotFoundException(index);
-        }
-
-        if (skipIdentity == false && resolvedExpressions.contains(index)) {
-            return null;
-        }
-
-        final ImmutableOpenMap<String, AliasMetadata> indexAliases = indexMetadata.getAliases();
-        final AliasMetadata[] aliasCandidates;
-        if (iterateIndexAliases(indexAliases.size(), resolvedExpressions.size())) {
-            // faster to iterate indexAliases
-            aliasCandidates = StreamSupport.stream(Spliterators.spliteratorUnknownSize(indexAliases.values().iterator(), 0), false)
-                .map(cursor -> cursor.value)
-                .filter(aliasMetadata -> resolvedExpressions.contains(aliasMetadata.alias()))
-                .toArray(AliasMetadata[]::new);
-        } else {
-            // faster to iterate resolvedExpressions
-            aliasCandidates = resolvedExpressions.stream().map(indexAliases::get).filter(Objects::nonNull).toArray(AliasMetadata[]::new);
-        }
-
-        List<String> aliases = null;
-        for (AliasMetadata aliasMetadata : aliasCandidates) {
-            if (requiredAlias.test(aliasMetadata)) {
-                // If required - add it to the list of aliases
-                if (aliases == null) {
-                    aliases = new ArrayList<>();
-                }
-                aliases.add(aliasMetadata.alias());
-            } else {
-                // If not, we have a non required alias for this index - no further checking needed
-                return null;
-            }
-        }
-        if (aliases == null) {
-            return null;
-        }
-        return aliases.toArray(new String[0]);
-    }
-
-    /**
-     * Resolves the search routing if in the expression aliases are used. If expressions point to concrete indices
-     * or aliases with no routing defined the specified routing is used.
-     *
-     * @return routing values grouped by concrete index
-     */
-    public Map<String, Set<String>> resolveSearchRouting(ProtobufClusterState state, @Nullable String routing, String... expressions) {
-        List<String> resolvedExpressions = expressions != null ? Arrays.asList(expressions) : Collections.emptyList();
-        Context context = new Context(state, IndicesOptions.lenientExpandOpen(), false, false, true, isSystemIndexAccessAllowed());
-        for (ExpressionResolver expressionResolver : expressionResolvers) {
-            resolvedExpressions = expressionResolver.resolve(context, resolvedExpressions);
-        }
-
-        // TODO: it appears that this can never be true?
-        if (isAllIndices(resolvedExpressions)) {
-            return resolveSearchRoutingAllIndices(state.metadata(), routing);
-        }
-
-        Map<String, Set<String>> routings = null;
-        Set<String> paramRouting = null;
-        // List of indices that don't require any routing
-        Set<String> norouting = new HashSet<>();
-        if (routing != null) {
-            paramRouting = Sets.newHashSet(Strings.splitStringByCommaToArray(routing));
-        }
-
-        for (String expression : resolvedExpressions) {
-            IndexAbstraction indexAbstraction = state.metadata().getIndicesLookup().get(expression);
-            if (indexAbstraction != null && indexAbstraction.getType() == IndexAbstraction.Type.ALIAS) {
-                IndexAbstraction.Alias alias = (IndexAbstraction.Alias) indexAbstraction;
-                for (Tuple<String, AliasMetadata> item : alias.getConcreteIndexAndAliasMetadatas()) {
-                    String concreteIndex = item.v1();
-                    AliasMetadata aliasMetadata = item.v2();
-                    if (!norouting.contains(concreteIndex)) {
-                        if (!aliasMetadata.searchRoutingValues().isEmpty()) {
-                            // Routing alias
-                            if (routings == null) {
-                                routings = new HashMap<>();
-                            }
-                            Set<String> r = routings.get(concreteIndex);
-                            if (r == null) {
-                                r = new HashSet<>();
-                                routings.put(concreteIndex, r);
-                            }
-                            r.addAll(aliasMetadata.searchRoutingValues());
-                            if (paramRouting != null) {
-                                r.retainAll(paramRouting);
-                            }
-                            if (r.isEmpty()) {
-                                routings.remove(concreteIndex);
-                            }
-                        } else {
-                            // Non-routing alias
-                            if (!norouting.contains(concreteIndex)) {
-                                norouting.add(concreteIndex);
-                                if (paramRouting != null) {
-                                    Set<String> r = new HashSet<>(paramRouting);
-                                    if (routings == null) {
-                                        routings = new HashMap<>();
-                                    }
-                                    routings.put(concreteIndex, r);
-                                } else {
-                                    if (routings != null) {
-                                        routings.remove(concreteIndex);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            } else {
-                // Index
-                if (!norouting.contains(expression)) {
-                    norouting.add(expression);
-                    if (paramRouting != null) {
-                        Set<String> r = new HashSet<>(paramRouting);
-                        if (routings == null) {
-                            routings = new HashMap<>();
-                        }
-                        routings.put(expression, r);
-                    } else {
-                        if (routings != null) {
-                            routings.remove(expression);
-                        }
-                    }
-                }
-            }
-
-        }
-        if (routings == null || routings.isEmpty()) {
-            return null;
-        }
-        return routings;
-    }
-
-    /**
-     * Sets the same routing for all indices
-     */
-    public Map<String, Set<String>> resolveSearchRoutingAllIndices(Metadata metadata, String routing) {
-        if (routing != null) {
-            Set<String> r = Sets.newHashSet(Strings.splitStringByCommaToArray(routing));
-            Map<String, Set<String>> routings = new HashMap<>();
-            String[] concreteIndices = metadata.getConcreteAllIndices();
-            for (String index : concreteIndices) {
-                routings.put(index, r);
-            }
-            return routings;
-        }
-        return null;
-    }
-
-    /**
-     * Identifies whether the array containing index names given as argument refers to all indices
-     * The empty or null array identifies all indices
-     *
-     * @param aliasesOrIndices the array containing index names
-     * @return true if the provided array maps to all indices, false otherwise
-     */
-    public static boolean isAllIndices(Collection<String> aliasesOrIndices) {
-        return aliasesOrIndices == null || aliasesOrIndices.isEmpty() || isExplicitAllPattern(aliasesOrIndices);
-    }
-
-    /**
-     * Identifies whether the array containing index names given as argument explicitly refers to all indices
-     * The empty or null array doesn't explicitly map to all indices
-     *
-     * @param aliasesOrIndices the array containing index names
-     * @return true if the provided array explicitly maps to all indices, false otherwise
-     */
-    static boolean isExplicitAllPattern(Collection<String> aliasesOrIndices) {
-        return aliasesOrIndices != null && aliasesOrIndices.size() == 1 && Metadata.ALL.equals(aliasesOrIndices.iterator().next());
-    }
-
-    /**
-     * Identifies whether the first argument (an array containing index names) is a pattern that matches all indices
-     *
-     * @param indicesOrAliases the array containing index names
-     * @param concreteIndices  array containing the concrete indices that the first argument refers to
-     * @return true if the first argument is a pattern that maps to all available indices, false otherwise
-     */
-    boolean isPatternMatchingAllIndices(Metadata metadata, String[] indicesOrAliases, String[] concreteIndices) {
-        // if we end up matching on all indices, check, if its a wildcard parameter, or a "-something" structure
-        if (concreteIndices.length == metadata.getConcreteAllIndices().length && indicesOrAliases.length > 0) {
-
-            // we might have something like /-test1,+test1 that would identify all indices
-            // or something like /-test1 with test1 index missing and IndicesOptions.lenient()
-            if (indicesOrAliases[0].charAt(0) == '-') {
-                return true;
-            }
-
-            // otherwise we check if there's any simple regex
-            for (String indexOrAlias : indicesOrAliases) {
-                if (Regex.isSimpleMatchPattern(indexOrAlias)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    /**
-     * Determines whether or not system index access should be allowed in the current context.
-     *
-     * @return True if system index access should be allowed, false otherwise.
-     */
-    public boolean isSystemIndexAccessAllowed() {
-        return Booleans.parseBoolean(threadContext.getHeader(SYSTEM_INDEX_ACCESS_CONTROL_HEADER_KEY), true);
-    }
-
-    /**
-     * Context for the resolver.
-     *
-     * @opensearch.internal
-     */
-    public static class Context {
-
-        private final ProtobufClusterState state;
-        private final IndicesOptions options;
-        private final long startTime;
-        private final boolean preserveAliases;
-        private final boolean resolveToWriteIndex;
-        private final boolean includeDataStreams;
-        private final boolean preserveDataStreams;
-        private final boolean isSystemIndexAccessAllowed;
-
-        Context(ProtobufClusterState state, IndicesOptions options, boolean isSystemIndexAccessAllowed) {
-            this(state, options, System.currentTimeMillis(), isSystemIndexAccessAllowed);
-        }
-
-        Context(
-            ProtobufClusterState state,
-            IndicesOptions options,
-            boolean preserveAliases,
-            boolean resolveToWriteIndex,
-            boolean includeDataStreams,
-            boolean isSystemIndexAccessAllowed
-        ) {
-            this(
-                state,
-                options,
-                System.currentTimeMillis(),
-                preserveAliases,
-                resolveToWriteIndex,
-                includeDataStreams,
-                false,
-                isSystemIndexAccessAllowed
-            );
-        }
-
-        Context(
-            ProtobufClusterState state,
-            IndicesOptions options,
-            boolean preserveAliases,
-            boolean resolveToWriteIndex,
-            boolean includeDataStreams,
-            boolean preserveDataStreams,
-            boolean isSystemIndexAccessAllowed
-        ) {
-            this(
-                state,
-                options,
-                System.currentTimeMillis(),
-                preserveAliases,
-                resolveToWriteIndex,
-                includeDataStreams,
-                preserveDataStreams,
-                isSystemIndexAccessAllowed
-            );
-        }
-
-        Context(ProtobufClusterState state, IndicesOptions options, long startTime, boolean isSystemIndexAccessAllowed) {
-            this(state, options, startTime, false, false, false, false, isSystemIndexAccessAllowed);
-        }
-
-        protected Context(
-            ProtobufClusterState state,
-            IndicesOptions options,
-            long startTime,
-            boolean preserveAliases,
-            boolean resolveToWriteIndex,
-            boolean includeDataStreams,
-            boolean preserveDataStreams,
-            boolean isSystemIndexAccessAllowed
-        ) {
-            this.state = state;
-            this.options = options;
-            this.startTime = startTime;
-            this.preserveAliases = preserveAliases;
-            this.resolveToWriteIndex = resolveToWriteIndex;
-            this.includeDataStreams = includeDataStreams;
-            this.preserveDataStreams = preserveDataStreams;
-            this.isSystemIndexAccessAllowed = isSystemIndexAccessAllowed;
-        }
-
-        public ProtobufClusterState getState() {
-            return state;
-        }
-
-        public IndicesOptions getOptions() {
-            return options;
-        }
-
-        public long getStartTime() {
-            return startTime;
-        }
-
-        /**
-         * This is used to prevent resolving aliases to concrete indices but this also means
-         * that we might return aliases that point to a closed index. This is currently only used
-         * by {@link #filteringAliases(ProtobufClusterState, String, Set)} since it's the only one that needs aliases
-         */
-        boolean isPreserveAliases() {
-            return preserveAliases;
-        }
-
-        /**
-         * This is used to require that aliases resolve to their write-index. It is currently not used in conjunction
-         * with <code>preserveAliases</code>.
-         */
-        boolean isResolveToWriteIndex() {
-            return resolveToWriteIndex;
-        }
-
-        public boolean includeDataStreams() {
-            return includeDataStreams;
-        }
-
-        public boolean isPreserveDataStreams() {
-            return preserveDataStreams;
-        }
-
-        /**
-         * Used to determine if it is allowed to access system indices in this context (e.g. for this request).
-         */
-        public boolean isSystemIndexAccessAllowed() {
-            return isSystemIndexAccessAllowed;
-        }
-    }
-
-    private interface ExpressionResolver {
-
-        /**
-         * Resolves the list of expressions into other expressions if possible (possible concrete indices and aliases, but
-         * that isn't required). The provided implementations can also be left untouched.
-         *
-         * @return a new list with expressions based on the provided expressions
-         */
-        List<String> resolve(Context context, List<String> expressions);
-
-    }
-
-    /**
-     * Resolves alias/index name expressions with wildcards into the corresponding concrete indices/aliases
-     *
-     * @opensearch.internal
-     */
-    static final class WildcardExpressionResolver implements ExpressionResolver {
-
-        @Override
-        public List<String> resolve(Context context, List<String> expressions) {
-            IndicesOptions options = context.getOptions();
-            Metadata metadata = context.getState().metadata();
-            // only check open/closed since if we do not expand to open or closed it doesn't make sense to
-            // expand to hidden
-            if (options.expandWildcardsClosed() == false && options.expandWildcardsOpen() == false) {
-                return expressions;
-            }
-
-            if (isEmptyOrTrivialWildcard(expressions)) {
-                List<String> resolvedExpressions = resolveEmptyOrTrivialWildcard(options, metadata);
-                if (context.includeDataStreams()) {
-                    final IndexMetadata.State excludeState = excludeState(options);
-                    final Map<String, IndexAbstraction> dataStreamsAbstractions = metadata.getIndicesLookup()
-                        .entrySet()
-                        .stream()
-                        .filter(entry -> entry.getValue().getType() == IndexAbstraction.Type.DATA_STREAM)
-                        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
-                    // dedup backing indices if expand hidden indices option is true
-                    Set<String> resolvedIncludingDataStreams = new HashSet<>(resolvedExpressions);
-                    resolvedIncludingDataStreams.addAll(
-                        expand(
-                            context,
-                            excludeState,
-                            dataStreamsAbstractions,
-                            expressions.isEmpty() ? "_all" : expressions.get(0),
-                            options.expandWildcardsHidden()
-                        )
-                    );
-                    return new ArrayList<>(resolvedIncludingDataStreams);
-                }
-                return resolvedExpressions;
-            }
-
-            Set<String> result = innerResolve(context, expressions, options, metadata);
-
-            if (result == null) {
-                return expressions;
-            }
-            if (result.isEmpty() && !options.allowNoIndices()) {
-                IndexNotFoundException infe = new IndexNotFoundException((String) null);
-                infe.setResources("index_or_alias", expressions.toArray(new String[0]));
-                throw infe;
-            }
-            return new ArrayList<>(result);
-        }
-
-        private Set<String> innerResolve(Context context, List<String> expressions, IndicesOptions options, Metadata metadata) {
-            Set<String> result = null;
-            boolean wildcardSeen = false;
-            for (int i = 0; i < expressions.size(); i++) {
-                String expression = expressions.get(i);
-                if (Strings.isEmpty(expression)) {
-                    throw indexNotFoundException(expression);
-                }
-                validateAliasOrIndex(expression);
-                if (aliasOrIndexExists(context, options, metadata, expression)) {
-                    if (result != null) {
-                        result.add(expression);
-                    }
-                    continue;
-                }
-                final boolean add;
-                if (expression.charAt(0) == '-' && wildcardSeen) {
-                    add = false;
-                    expression = expression.substring(1);
-                } else {
-                    add = true;
-                }
-                if (result == null) {
-                    // add all the previous ones...
-                    result = new HashSet<>(expressions.subList(0, i));
-                }
-                if (Regex.isSimpleMatchPattern(expression) == false) {
-                    // TODO why does wildcard resolver throw exceptions regarding non wildcarded expressions? This should not be done here.
-                    if (options.ignoreUnavailable() == false) {
-                        IndexAbstraction indexAbstraction = metadata.getIndicesLookup().get(expression);
-                        if (indexAbstraction == null) {
-                            throw indexNotFoundException(expression);
-                        } else if (indexAbstraction.getType() == IndexAbstraction.Type.ALIAS && options.ignoreAliases()) {
-                            throw aliasesNotSupportedException(expression);
-                        } else if (indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM
-                            && context.includeDataStreams() == false) {
-                                throw indexNotFoundException(expression);
-                            }
-                    }
-                    if (add) {
-                        result.add(expression);
-                    } else {
-                        result.remove(expression);
-                    }
-                    continue;
-                }
-
-                final IndexMetadata.State excludeState = excludeState(options);
-                final Map<String, IndexAbstraction> matches = matches(context, metadata, expression);
-                Set<String> expand = expand(context, excludeState, matches, expression, options.expandWildcardsHidden());
-                if (add) {
-                    result.addAll(expand);
-                } else {
-                    result.removeAll(expand);
-                }
-                if (options.allowNoIndices() == false && matches.isEmpty()) {
-                    throw indexNotFoundException(expression);
-                }
-                if (Regex.isSimpleMatchPattern(expression)) {
-                    wildcardSeen = true;
-                }
-            }
-            return result;
-        }
-
-        private static void validateAliasOrIndex(String expression) {
-            // Expressions can not start with an underscore. This is reserved for APIs. If the check gets here, the API
-            // does not exist and the path is interpreted as an expression. If the expression begins with an underscore,
-            // throw a specific error that is different from the [[IndexNotFoundException]], which is typically thrown
-            // if the expression can't be found.
-            if (expression.charAt(0) == '_') {
-                throw new InvalidIndexNameException(expression, "must not start with '_'.");
-            }
-        }
-
-        private static boolean aliasOrIndexExists(Context context, IndicesOptions options, Metadata metadata, String expression) {
-            IndexAbstraction indexAbstraction = metadata.getIndicesLookup().get(expression);
-            if (indexAbstraction == null) {
-                return false;
-            }
-
-            // treat aliases as unavailable indices when ignoreAliases is set to true (e.g. delete index and update aliases api)
-            if (indexAbstraction.getType() == IndexAbstraction.Type.ALIAS && options.ignoreAliases()) {
-                return false;
-            }
-
-            if (indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM && context.includeDataStreams() == false) {
-                return false;
-            }
-
-            return true;
-        }
-
-        private static IndexNotFoundException indexNotFoundException(String expression) {
-            IndexNotFoundException infe = new IndexNotFoundException(expression);
-            infe.setResources("index_or_alias", expression);
-            return infe;
-        }
-
-        private static IndexMetadata.State excludeState(IndicesOptions options) {
-            final IndexMetadata.State excludeState;
-            if (options.expandWildcardsOpen() && options.expandWildcardsClosed()) {
-                excludeState = null;
-            } else if (options.expandWildcardsOpen() && options.expandWildcardsClosed() == false) {
-                excludeState = IndexMetadata.State.CLOSE;
-            } else if (options.expandWildcardsClosed() && options.expandWildcardsOpen() == false) {
-                excludeState = IndexMetadata.State.OPEN;
-            } else {
-                assert false : "this shouldn't get called if wildcards expand to none";
-                excludeState = null;
-            }
-            return excludeState;
-        }
-
-        public static Map<String, IndexAbstraction> matches(Context context, Metadata metadata, String expression) {
-            if (Regex.isMatchAllPattern(expression)) {
-                return filterIndicesLookup(context, metadata.getIndicesLookup(), null, context.getOptions());
-            } else if (expression.indexOf("*") == expression.length() - 1) {
-                return suffixWildcard(context, metadata, expression);
-            } else {
-                return otherWildcard(context, metadata, expression);
-            }
-        }
-
-        private static Map<String, IndexAbstraction> suffixWildcard(Context context, Metadata metadata, String expression) {
-            assert expression.length() >= 2 : "expression [" + expression + "] should have at least a length of 2";
-            String fromPrefix = expression.substring(0, expression.length() - 1);
-            char[] toPrefixCharArr = fromPrefix.toCharArray();
-            toPrefixCharArr[toPrefixCharArr.length - 1]++;
-            String toPrefix = new String(toPrefixCharArr);
-            SortedMap<String, IndexAbstraction> subMap = metadata.getIndicesLookup().subMap(fromPrefix, toPrefix);
-            return filterIndicesLookup(context, subMap, null, context.getOptions());
-        }
-
-        private static Map<String, IndexAbstraction> otherWildcard(Context context, Metadata metadata, String expression) {
-            final String pattern = expression;
-            return filterIndicesLookup(
-                context,
-                metadata.getIndicesLookup(),
-                e -> Regex.simpleMatch(pattern, e.getKey()),
-                context.getOptions()
-            );
-        }
-
-        private static Map<String, IndexAbstraction> filterIndicesLookup(
-            Context context,
-            SortedMap<String, IndexAbstraction> indicesLookup,
-            Predicate<? super Map.Entry<String, IndexAbstraction>> filter,
-            IndicesOptions options
-        ) {
-            boolean shouldConsumeStream = false;
-            Stream<Map.Entry<String, IndexAbstraction>> stream = indicesLookup.entrySet().stream();
-            if (options.ignoreAliases()) {
-                shouldConsumeStream = true;
-                stream = stream.filter(e -> e.getValue().getType() != IndexAbstraction.Type.ALIAS);
-            }
-            if (filter != null) {
-                shouldConsumeStream = true;
-                stream = stream.filter(filter);
-            }
-            if (context.includeDataStreams() == false) {
-                shouldConsumeStream = true;
-                stream = stream.filter(e -> e.getValue().getType() != IndexAbstraction.Type.DATA_STREAM);
-            }
-            if (shouldConsumeStream) {
-                return stream.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
-            } else {
-                return indicesLookup;
-            }
-        }
-
-        private static Set<String> expand(
-            Context context,
-            IndexMetadata.State excludeState,
-            Map<String, IndexAbstraction> matches,
-            String expression,
-            boolean includeHidden
-        ) {
-            Set<String> expand = new HashSet<>();
-            for (Map.Entry<String, IndexAbstraction> entry : matches.entrySet()) {
-                String aliasOrIndexName = entry.getKey();
-                IndexAbstraction indexAbstraction = entry.getValue();
-
-                if (indexAbstraction.isHidden() == false || includeHidden || implicitHiddenMatch(aliasOrIndexName, expression)) {
-                    if (context.isPreserveAliases() && indexAbstraction.getType() == IndexAbstraction.Type.ALIAS) {
-                        expand.add(aliasOrIndexName);
-                    } else {
-                        for (IndexMetadata meta : indexAbstraction.getIndices()) {
-                            if (excludeState == null || meta.getState() != excludeState) {
-                                expand.add(meta.getIndex().getName());
-                            }
-                        }
-                        if (context.isPreserveDataStreams() && indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM) {
-                            expand.add(indexAbstraction.getName());
-                        }
-                    }
-                }
-            }
-            return expand;
-        }
-
-        private static boolean implicitHiddenMatch(String itemName, String expression) {
-            return itemName.startsWith(".") && expression.startsWith(".") && Regex.isSimpleMatchPattern(expression);
-        }
-
-        private boolean isEmptyOrTrivialWildcard(List<String> expressions) {
-            return expressions.isEmpty()
-                || (expressions.size() == 1 && (Metadata.ALL.equals(expressions.get(0)) || Regex.isMatchAllPattern(expressions.get(0))));
-        }
-
-        private static List<String> resolveEmptyOrTrivialWildcard(IndicesOptions options, Metadata metadata) {
-            if (options.expandWildcardsOpen() && options.expandWildcardsClosed() && options.expandWildcardsHidden()) {
-                return Arrays.asList(metadata.getConcreteAllIndices());
-            } else if (options.expandWildcardsOpen() && options.expandWildcardsClosed()) {
-                return Arrays.asList(metadata.getConcreteVisibleIndices());
-            } else if (options.expandWildcardsOpen() && options.expandWildcardsHidden()) {
-                return Arrays.asList(metadata.getConcreteAllOpenIndices());
-            } else if (options.expandWildcardsOpen()) {
-                return Arrays.asList(metadata.getConcreteVisibleOpenIndices());
-            } else if (options.expandWildcardsClosed() && options.expandWildcardsHidden()) {
-                return Arrays.asList(metadata.getConcreteAllClosedIndices());
-            } else if (options.expandWildcardsClosed()) {
-                return Arrays.asList(metadata.getConcreteVisibleClosedIndices());
-            } else {
-                return Collections.emptyList();
-            }
-        }
-    }
-
-    /**
-     * A date math expression resolver.
-     *
-     * @opensearch.internal
-     */
-    public static final class DateMathExpressionResolver implements ExpressionResolver {
-
-        private static final DateFormatter DEFAULT_DATE_FORMATTER = DateFormatter.forPattern("uuuu.MM.dd");
-        private static final String EXPRESSION_LEFT_BOUND = "<";
-        private static final String EXPRESSION_RIGHT_BOUND = ">";
-        private static final char LEFT_BOUND = '{';
-        private static final char RIGHT_BOUND = '}';
-        private static final char ESCAPE_CHAR = '\\';
-        private static final char TIME_ZONE_BOUND = '|';
-
-        @Override
-        public List<String> resolve(final Context context, List<String> expressions) {
-            List<String> result = new ArrayList<>(expressions.size());
-            for (String expression : expressions) {
-                result.add(resolveExpression(expression, context));
-            }
-            return result;
-        }
-
-        @SuppressWarnings("fallthrough")
-        String resolveExpression(String expression, final Context context) {
-            if (expression.startsWith(EXPRESSION_LEFT_BOUND) == false || expression.endsWith(EXPRESSION_RIGHT_BOUND) == false) {
-                return expression;
-            }
-
-            boolean escape = false;
-            boolean inDateFormat = false;
-            boolean inPlaceHolder = false;
-            final StringBuilder beforePlaceHolderSb = new StringBuilder();
-            StringBuilder inPlaceHolderSb = new StringBuilder();
-            final char[] text = expression.toCharArray();
-            final int from = 1;
-            final int length = text.length - 1;
-            for (int i = from; i < length; i++) {
-                boolean escapedChar = escape;
-                if (escape) {
-                    escape = false;
-                }
-
-                char c = text[i];
-                if (c == ESCAPE_CHAR) {
-                    if (escapedChar) {
-                        beforePlaceHolderSb.append(c);
-                        escape = false;
-                    } else {
-                        escape = true;
-                    }
-                    continue;
-                }
-                if (inPlaceHolder) {
-                    switch (c) {
-                        case LEFT_BOUND:
-                            if (inDateFormat && escapedChar) {
-                                inPlaceHolderSb.append(c);
-                            } else if (!inDateFormat) {
-                                inDateFormat = true;
-                                inPlaceHolderSb.append(c);
-                            } else {
-                                throw new OpenSearchParseException(
-                                    "invalid dynamic name expression [{}]." + " invalid character in placeholder at position [{}]",
-                                    new String(text, from, length),
-                                    i
-                                );
-                            }
-                            break;
-
-                        case RIGHT_BOUND:
-                            if (inDateFormat && escapedChar) {
-                                inPlaceHolderSb.append(c);
-                            } else if (inDateFormat) {
-                                inDateFormat = false;
-                                inPlaceHolderSb.append(c);
-                            } else {
-                                String inPlaceHolderString = inPlaceHolderSb.toString();
-                                int dateTimeFormatLeftBoundIndex = inPlaceHolderString.indexOf(LEFT_BOUND);
-                                String mathExpression;
-                                String dateFormatterPattern;
-                                DateFormatter dateFormatter;
-                                final ZoneId timeZone;
-                                if (dateTimeFormatLeftBoundIndex < 0) {
-                                    mathExpression = inPlaceHolderString;
-                                    dateFormatter = DEFAULT_DATE_FORMATTER;
-                                    timeZone = ZoneOffset.UTC;
-                                } else {
-                                    if (inPlaceHolderString.lastIndexOf(RIGHT_BOUND) != inPlaceHolderString.length() - 1) {
-                                        throw new OpenSearchParseException(
-                                            "invalid dynamic name expression [{}]. missing closing `}`" + " for date math format",
-                                            inPlaceHolderString
-                                        );
-                                    }
-                                    if (dateTimeFormatLeftBoundIndex == inPlaceHolderString.length() - 2) {
-                                        throw new OpenSearchParseException(
-                                            "invalid dynamic name expression [{}]. missing date format",
-                                            inPlaceHolderString
-                                        );
-                                    }
-                                    mathExpression = inPlaceHolderString.substring(0, dateTimeFormatLeftBoundIndex);
-                                    String patternAndTZid = inPlaceHolderString.substring(
-                                        dateTimeFormatLeftBoundIndex + 1,
-                                        inPlaceHolderString.length() - 1
-                                    );
-                                    int formatPatternTimeZoneSeparatorIndex = patternAndTZid.indexOf(TIME_ZONE_BOUND);
-                                    if (formatPatternTimeZoneSeparatorIndex != -1) {
-                                        dateFormatterPattern = patternAndTZid.substring(0, formatPatternTimeZoneSeparatorIndex);
-                                        timeZone = DateUtils.of(patternAndTZid.substring(formatPatternTimeZoneSeparatorIndex + 1));
-                                    } else {
-                                        dateFormatterPattern = patternAndTZid;
-                                        timeZone = ZoneOffset.UTC;
-                                    }
-                                    dateFormatter = DateFormatter.forPattern(dateFormatterPattern);
-                                }
-
-                                DateFormatter formatter = dateFormatter.withZone(timeZone);
-                                DateMathParser dateMathParser = formatter.toDateMathParser();
-                                Instant instant = dateMathParser.parse(mathExpression, context::getStartTime, false, timeZone);
-
-                                String time = formatter.format(instant);
-                                beforePlaceHolderSb.append(time);
-                                inPlaceHolderSb = new StringBuilder();
-                                inPlaceHolder = false;
-                            }
-                            break;
-
-                        default:
-                            inPlaceHolderSb.append(c);
-                    }
-                } else {
-                    switch (c) {
-                        case LEFT_BOUND:
-                            if (escapedChar) {
-                                beforePlaceHolderSb.append(c);
-                            } else {
-                                inPlaceHolder = true;
-                            }
-                            break;
-
-                        case RIGHT_BOUND:
-                            if (!escapedChar) {
-                                throw new OpenSearchParseException(
-                                    "invalid dynamic name expression [{}]."
-                                        + " invalid character at position [{}]. `{` and `}` are reserved characters and"
-                                        + " should be escaped when used as part of the index name using `\\` (e.g. `\\{text\\}`)",
-                                    new String(text, from, length),
-                                    i
-                                );
-                            }
-                        default:
-                            beforePlaceHolderSb.append(c);
-                    }
-                }
-            }
-
-            if (inPlaceHolder) {
-                throw new OpenSearchParseException(
-                    "invalid dynamic name expression [{}]. date math placeholder is open ended",
-                    new String(text, from, length)
-                );
-            }
-            if (beforePlaceHolderSb.length() == 0) {
-                throw new OpenSearchParseException("nothing captured");
-            }
-            return beforePlaceHolderSb.toString();
-        }
-    }
-}
+// /*
+//  * 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.
+//  */
+
+// package org.opensearch.cluster.metadata;
+
+// import org.opensearch.OpenSearchParseException;
+// import org.opensearch.action.IndicesRequest;
+// import org.opensearch.action.support.IndicesOptions;
+// import org.opensearch.cluster.ProtobufClusterState;
+// import org.opensearch.common.Booleans;
+// import org.opensearch.common.Nullable;
+// import org.opensearch.common.Strings;
+// import org.opensearch.common.collect.ImmutableOpenMap;
+// import org.opensearch.common.collect.Tuple;
+// import org.opensearch.common.logging.DeprecationLogger;
+// import org.opensearch.common.regex.Regex;
+// import org.opensearch.common.time.DateFormatter;
+// import org.opensearch.common.time.DateMathParser;
+// import org.opensearch.common.time.DateUtils;
+// import org.opensearch.common.util.CollectionUtils;
+// import org.opensearch.common.util.concurrent.ThreadContext;
+// import org.opensearch.common.util.set.Sets;
+// import org.opensearch.index.Index;
+// import org.opensearch.index.IndexNotFoundException;
+// import org.opensearch.indices.IndexClosedException;
+// import org.opensearch.indices.InvalidIndexNameException;
+
+// import java.time.Instant;
+// import java.time.ZoneId;
+// import java.time.ZoneOffset;
+// import java.util.ArrayList;
+// import java.util.Arrays;
+// import java.util.Collection;
+// import java.util.Collections;
+// import java.util.HashMap;
+// import java.util.HashSet;
+// import java.util.List;
+// import java.util.Map;
+// import java.util.Objects;
+// import java.util.Set;
+// import java.util.SortedMap;
+// import java.util.Spliterators;
+// import java.util.function.Predicate;
+// import java.util.stream.Collectors;
+// import java.util.stream.Stream;
+// import java.util.stream.StreamSupport;
+
+// /**
+//  * Resolves index name from an expression
+//  *
+//  * @opensearch.internal
+//  */
+// public class ProtobufIndexNameExpressionResolver {
+//     private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(ProtobufIndexNameExpressionResolver.class);
+
+//     public static final String EXCLUDED_DATA_STREAMS_KEY = "opensearch.excluded_ds";
+//     public static final String SYSTEM_INDEX_ACCESS_CONTROL_HEADER_KEY = "_system_index_access_allowed";
+
+//     private final DateMathExpressionResolver dateMathExpressionResolver = new DateMathExpressionResolver();
+//     private final WildcardExpressionResolver wildcardExpressionResolver = new WildcardExpressionResolver();
+//     private final List<ExpressionResolver> expressionResolvers = List.of(dateMathExpressionResolver, wildcardExpressionResolver);
+
+//     private final ThreadContext threadContext;
+
+//     public ProtobufIndexNameExpressionResolver(ThreadContext threadContext) {
+//         this.threadContext = Objects.requireNonNull(threadContext, "Thread Context must not be null");
+//     }
+
+//     /**
+//      * Same as {@link #concreteIndexNames(ProtobufClusterState, IndicesOptions, String...)}, but the index expressions and options
+//      * are encapsulated in the specified request.
+//      */
+//     public String[] concreteIndexNames(ProtobufClusterState state, IndicesRequest request) {
+//         Context context = new Context(
+//             state,
+//             request.indicesOptions(),
+//             false,
+//             false,
+//             request.includeDataStreams(),
+//             isSystemIndexAccessAllowed()
+//         );
+//         return concreteIndexNames(context, request.indices());
+//     }
+
+//     /**
+//      * Same as {@link #concreteIndexNames(ProtobufClusterState, IndicesRequest)}, but access to system indices is always allowed.
+//      */
+//     public String[] concreteIndexNamesWithSystemIndexAccess(ProtobufClusterState state, IndicesRequest request) {
+//         Context context = new Context(state, request.indicesOptions(), false, false, request.includeDataStreams(), true);
+//         return concreteIndexNames(context, request.indices());
+//     }
+
+//     /**
+//      * Same as {@link #concreteIndices(ProtobufClusterState, IndicesOptions, String...)}, but the index expressions and options
+//      * are encapsulated in the specified request and resolves data streams.
+//      */
+//     public Index[] concreteIndices(ProtobufClusterState state, IndicesRequest request) {
+//         Context context = new Context(
+//             state,
+//             request.indicesOptions(),
+//             false,
+//             false,
+//             request.includeDataStreams(),
+//             isSystemIndexAccessAllowed()
+//         );
+//         return concreteIndices(context, request.indices());
+//     }
+
+//     /**
+//      * Translates the provided index expression into actual concrete indices, properly deduplicated.
+//      *
+//      * @param state             the cluster state containing all the data to resolve to expressions to concrete indices
+//      * @param options           defines how the aliases or indices need to be resolved to concrete indices
+//      * @param indexExpressions  expressions that can be resolved to alias or index names.
+//      * @return the resolved concrete indices based on the cluster state, indices options and index expressions
+//      * @throws IndexNotFoundException if one of the index expressions is pointing to a missing index or alias and the
+//      * provided indices options in the context don't allow such a case, or if the final result of the indices resolution
+//      * contains no indices and the indices options in the context don't allow such a case.
+//      * @throws IllegalArgumentException if one of the aliases resolve to multiple indices and the provided
+//      * indices options in the context don't allow such a case.
+//      */
+//     public String[] concreteIndexNames(ProtobufClusterState state, IndicesOptions options, String... indexExpressions) {
+//         Context context = new Context(state, options, isSystemIndexAccessAllowed());
+//         return concreteIndexNames(context, indexExpressions);
+//     }
+
+//     public String[] concreteIndexNames(
+//         ProtobufClusterState state,
+//         IndicesOptions options,
+//         boolean includeDataStreams,
+//         String... indexExpressions
+//     ) {
+//         Context context = new Context(state, options, false, false, includeDataStreams, isSystemIndexAccessAllowed());
+//         return concreteIndexNames(context, indexExpressions);
+//     }
+
+//     public String[] concreteIndexNames(ProtobufClusterState state, IndicesOptions options, IndicesRequest request) {
+//         Context context = new Context(state, options, false, false, request.includeDataStreams(), isSystemIndexAccessAllowed());
+//         return concreteIndexNames(context, request.indices());
+//     }
+
+//     public List<String> dataStreamNames(ProtobufClusterState state, IndicesOptions options, String... indexExpressions) {
+//         // Allow system index access - they'll be filtered out below as there's no such thing (yet) as system data streams
+//         Context context = new Context(state, options, false, false, true, true, true);
+//         if (indexExpressions == null || indexExpressions.length == 0) {
+//             indexExpressions = new String[] { "*" };
+//         }
+
+//         List<String> dataStreams = wildcardExpressionResolver.resolve(context, Arrays.asList(indexExpressions));
+//         return ((dataStreams == null) ? List.<String>of() : dataStreams).stream()
+//             .map(x -> state.metadata().getIndicesLookup().get(x))
+//             .filter(Objects::nonNull)
+//             .filter(ia -> ia.getType() == IndexAbstraction.Type.DATA_STREAM)
+//             .map(IndexAbstraction::getName)
+//             .collect(Collectors.toList());
+//     }
+
+//     /**
+//      * Translates the provided index expression into actual concrete indices, properly deduplicated.
+//      *
+//      * @param state             the cluster state containing all the data to resolve to expressions to concrete indices
+//      * @param options           defines how the aliases or indices need to be resolved to concrete indices
+//      * @param indexExpressions  expressions that can be resolved to alias or index names.
+//      * @return the resolved concrete indices based on the cluster state, indices options and index expressions
+//      * @throws IndexNotFoundException if one of the index expressions is pointing to a missing index or alias and the
+//      * provided indices options in the context don't allow such a case, or if the final result of the indices resolution
+//      * contains no indices and the indices options in the context don't allow such a case.
+//      * @throws IllegalArgumentException if one of the aliases resolve to multiple indices and the provided
+//      * indices options in the context don't allow such a case.
+//      */
+//     public Index[] concreteIndices(ProtobufClusterState state, IndicesOptions options, String... indexExpressions) {
+//         return concreteIndices(state, options, false, indexExpressions);
+//     }
+
+//     public Index[] concreteIndices(
+//         ProtobufClusterState state,
+//         IndicesOptions options,
+//         boolean includeDataStreams,
+//         String... indexExpressions
+//     ) {
+//         Context context = new Context(state, options, false, false, includeDataStreams, isSystemIndexAccessAllowed());
+//         return concreteIndices(context, indexExpressions);
+//     }
+
+//     /**
+//      * Translates the provided index expression into actual concrete indices, properly deduplicated.
+//      *
+//      * @param state      the cluster state containing all the data to resolve to expressions to concrete indices
+//      * @param startTime  The start of the request where concrete indices is being invoked for
+//      * @param request    request containing expressions that can be resolved to alias, index, or data stream names.
+//      * @return the resolved concrete indices based on the cluster state, indices options and index expressions
+//      * provided indices options in the context don't allow such a case, or if the final result of the indices resolution
+//      * contains no indices and the indices options in the context don't allow such a case.
+//      * @throws IllegalArgumentException if one of the aliases resolve to multiple indices and the provided
+//      * indices options in the context don't allow such a case.
+//      */
+//     public Index[] concreteIndices(ProtobufClusterState state, IndicesRequest request, long startTime) {
+//         Context context = new Context(
+//             state,
+//             request.indicesOptions(),
+//             startTime,
+//             false,
+//             false,
+//             request.includeDataStreams(),
+//             false,
+//             isSystemIndexAccessAllowed()
+//         );
+//         return concreteIndices(context, request.indices());
+//     }
+
+//     String[] concreteIndexNames(Context context, String... indexExpressions) {
+//         Index[] indexes = concreteIndices(context, indexExpressions);
+//         String[] names = new String[indexes.length];
+//         for (int i = 0; i < indexes.length; i++) {
+//             names[i] = indexes[i].getName();
+//         }
+//         return names;
+//     }
+
+//     Index[] concreteIndices(Context context, String... indexExpressions) {
+//         if (indexExpressions == null || indexExpressions.length == 0) {
+//             indexExpressions = new String[] { Metadata.ALL };
+//         }
+//         Metadata metadata = context.getState().metadata();
+//         IndicesOptions options = context.getOptions();
+//         // If only one index is specified then whether we fail a request if an index is missing depends on the allow_no_indices
+//         // option. At some point we should change this, because there shouldn't be a reason why whether a single index
+//         // or multiple indices are specified yield different behaviour.
+//         final boolean failNoIndices = indexExpressions.length == 1 ? !options.allowNoIndices() : !options.ignoreUnavailable();
+//         List<String> expressions = Arrays.asList(indexExpressions);
+//         for (ExpressionResolver expressionResolver : expressionResolvers) {
+//             expressions = expressionResolver.resolve(context, expressions);
+//         }
+
+//         if (expressions.isEmpty()) {
+//             if (!options.allowNoIndices()) {
+//                 IndexNotFoundException infe;
+//                 if (indexExpressions.length == 1) {
+//                     if (indexExpressions[0].equals(Metadata.ALL)) {
+//                         infe = new IndexNotFoundException("no indices exist", (String) null);
+//                     } else {
+//                         infe = new IndexNotFoundException((String) null);
+//                     }
+//                 } else {
+//                     infe = new IndexNotFoundException((String) null);
+//                 }
+//                 infe.setResources("index_expression", indexExpressions);
+//                 throw infe;
+//             } else {
+//                 return Index.EMPTY_ARRAY;
+//             }
+//         }
+
+//         boolean excludedDataStreams = false;
+//         final Set<Index> concreteIndices = new HashSet<>(expressions.size());
+//         for (String expression : expressions) {
+//             IndexAbstraction indexAbstraction = metadata.getIndicesLookup().get(expression);
+//             if (indexAbstraction == null) {
+//                 if (failNoIndices) {
+//                     IndexNotFoundException infe;
+//                     if (expression.equals(Metadata.ALL)) {
+//                         infe = new IndexNotFoundException("no indices exist", expression);
+//                     } else {
+//                         infe = new IndexNotFoundException(expression);
+//                     }
+//                     infe.setResources("index_expression", expression);
+//                     throw infe;
+//                 } else {
+//                     continue;
+//                 }
+//             } else if (indexAbstraction.getType() == IndexAbstraction.Type.ALIAS && context.getOptions().ignoreAliases()) {
+//                 if (failNoIndices) {
+//                     throw aliasesNotSupportedException(expression);
+//                 } else {
+//                     continue;
+//                 }
+//             } else if (indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM && context.includeDataStreams() == false) {
+//                 excludedDataStreams = true;
+//                 continue;
+//             }
+
+//             if (indexAbstraction.getType() == IndexAbstraction.Type.ALIAS && context.isResolveToWriteIndex()) {
+//                 IndexMetadata writeIndex = indexAbstraction.getWriteIndex();
+//                 if (writeIndex == null) {
+//                     throw new IllegalArgumentException(
+//                         "no write index is defined for alias ["
+//                             + indexAbstraction.getName()
+//                             + "]."
+//                             + " The write index may be explicitly disabled using is_write_index=false or the alias points to multiple"
+//                             + " indices without one being designated as a write index"
+//                     );
+//                 }
+//                 if (addIndex(writeIndex, context)) {
+//                     concreteIndices.add(writeIndex.getIndex());
+//                 }
+//             } else if (indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM && context.isResolveToWriteIndex()) {
+//                 IndexMetadata writeIndex = indexAbstraction.getWriteIndex();
+//                 if (addIndex(writeIndex, context)) {
+//                     concreteIndices.add(writeIndex.getIndex());
+//                 }
+//             } else {
+//                 if (indexAbstraction.getIndices().size() > 1 && !options.allowAliasesToMultipleIndices()) {
+//                     String[] indexNames = new String[indexAbstraction.getIndices().size()];
+//                     int i = 0;
+//                     for (IndexMetadata indexMetadata : indexAbstraction.getIndices()) {
+//                         indexNames[i++] = indexMetadata.getIndex().getName();
+//                     }
+//                     throw new IllegalArgumentException(
+//                         indexAbstraction.getType().getDisplayName()
+//                             + " ["
+//                             + expression
+//                             + "] has more than one index associated with it "
+//                             + Arrays.toString(indexNames)
+//                             + ", can't execute a single index op"
+//                     );
+//                 }
+
+//                 for (IndexMetadata index : indexAbstraction.getIndices()) {
+//                     if (shouldTrackConcreteIndex(context, options, index)) {
+//                         concreteIndices.add(index.getIndex());
+//                     }
+//                 }
+//             }
+//         }
+
+//         if (options.allowNoIndices() == false && concreteIndices.isEmpty()) {
+//             IndexNotFoundException infe = new IndexNotFoundException((String) null);
+//             infe.setResources("index_expression", indexExpressions);
+//             if (excludedDataStreams) {
+//                 // Allows callers to handle IndexNotFoundException differently based on whether data streams were excluded.
+//                 infe.addMetadata(EXCLUDED_DATA_STREAMS_KEY, "true");
+//             }
+//             throw infe;
+//         }
+//         checkSystemIndexAccess(context, metadata, concreteIndices, indexExpressions);
+//         return concreteIndices.toArray(new Index[0]);
+//     }
+
+//     private void checkSystemIndexAccess(Context context, Metadata metadata, Set<Index> concreteIndices, String[] originalPatterns) {
+//         if (context.isSystemIndexAccessAllowed() == false) {
+//             final List<String> resolvedSystemIndices = concreteIndices.stream()
+//                 .map(metadata::index)
+//                 .filter(IndexMetadata::isSystem)
+//                 .map(i -> i.getIndex().getName())
+//                 .sorted() // reliable order for testing
+//                 .collect(Collectors.toList());
+//             if (resolvedSystemIndices.isEmpty() == false) {
+//                 resolvedSystemIndices.forEach(
+//                     systemIndexName -> deprecationLogger.deprecate(
+//                         "open_system_index_access_" + systemIndexName,
+//                         "this request accesses system indices: [{}], but in a future major version, direct access to system "
+//                             + "indices will be prevented by default",
+//                         systemIndexName
+//                     )
+//                 );
+//             }
+//         }
+//     }
+
+//     private static boolean shouldTrackConcreteIndex(Context context, IndicesOptions options, IndexMetadata index) {
+//         if (index.getState() == IndexMetadata.State.CLOSE) {
+//             if (options.forbidClosedIndices() && options.ignoreUnavailable() == false) {
+//                 throw new IndexClosedException(index.getIndex());
+//             } else {
+//                 return options.forbidClosedIndices() == false && addIndex(index, context);
+//             }
+//         } else if (index.getState() == IndexMetadata.State.OPEN) {
+//             return addIndex(index, context);
+//         } else {
+//             throw new IllegalStateException("index state [" + index.getState() + "] not supported");
+//         }
+//     }
+
+//     private static boolean addIndex(IndexMetadata metadata, Context context) {
+//         // This used to check the `index.search.throttled` setting, but we eventually decided that it was
+//         // trappy to hide throttled indices by default. In order to avoid breaking backward compatibility,
+//         // we changed it to look at the `index.frozen` setting instead, since frozen indices were the only
+//         // type of index to use the `search_throttled` threadpool at that time.
+//         // NOTE: The Setting object was defined in an external plugin prior to OpenSearch fork.
+//         return (context.options.ignoreThrottled() && metadata.getSettings().getAsBoolean("index.frozen", false)) == false;
+//     }
+
+//     private static IllegalArgumentException aliasesNotSupportedException(String expression) {
+//         return new IllegalArgumentException(
+//             "The provided expression [" + expression + "] matches an " + "alias, specify the corresponding concrete indices instead."
+//         );
+//     }
+
+//     /**
+//      * Utility method that allows to resolve an index expression to its corresponding single concrete index.
+//      * Callers should make sure they provide proper {@link org.opensearch.action.support.IndicesOptions}
+//      * that require a single index as a result. The indices resolution must in fact return a single index when
+//      * using this method, an {@link IllegalArgumentException} gets thrown otherwise.
+//      *
+//      * @param state             the cluster state containing all the data to resolve to expression to a concrete index
+//      * @param request           The request that defines how the an alias or an index need to be resolved to a concrete index
+//      *                          and the expression that can be resolved to an alias or an index name.
+//      * @throws IllegalArgumentException if the index resolution lead to more than one index
+//      * @return the concrete index obtained as a result of the index resolution
+//      */
+//     public Index concreteSingleIndex(ProtobufClusterState state, IndicesRequest request) {
+//         String indexExpression = CollectionUtils.isEmpty(request.indices()) ? null : request.indices()[0];
+//         Index[] indices = concreteIndices(state, request.indicesOptions(), indexExpression);
+//         if (indices.length != 1) {
+//             throw new IllegalArgumentException(
+//                 "unable to return a single index as the index and options" + " provided got resolved to multiple indices"
+//             );
+//         }
+//         return indices[0];
+//     }
+
+//     /**
+//      * Utility method that allows to resolve an index expression to its corresponding single write index.
+//      *
+//      * @param state             the cluster state containing all the data to resolve to expression to a concrete index
+//      * @param request           The request that defines how the an alias or an index need to be resolved to a concrete index
+//      *                          and the expression that can be resolved to an alias or an index name.
+//      * @throws IllegalArgumentException if the index resolution does not lead to an index, or leads to more than one index
+//      * @return the write index obtained as a result of the index resolution
+//      */
+//     public Index concreteWriteIndex(ProtobufClusterState state, IndicesRequest request) {
+//         if (request.indices() == null || (request.indices() != null && request.indices().length != 1)) {
+//             throw new IllegalArgumentException("indices request must specify a single index expression");
+//         }
+//         return concreteWriteIndex(state, request.indicesOptions(), request.indices()[0], false, request.includeDataStreams());
+//     }
+
+//     /**
+//      * Utility method that allows to resolve an index expression to its corresponding single write index.
+//      *
+//      * @param state             the cluster state containing all the data to resolve to expression to a concrete index
+//      * @param options           defines how the aliases or indices need to be resolved to concrete indices
+//      * @param index             index that can be resolved to alias or index name.
+//      * @param allowNoIndices    whether to allow resolve to no index
+//      * @param includeDataStreams Whether data streams should be included in the evaluation.
+//      * @throws IllegalArgumentException if the index resolution does not lead to an index, or leads to more than one index
+//      * @return the write index obtained as a result of the index resolution or null if no index
+//      */
+//     public Index concreteWriteIndex(
+//         ProtobufClusterState state,
+//         IndicesOptions options,
+//         String index,
+//         boolean allowNoIndices,
+//         boolean includeDataStreams
+//     ) {
+//         IndicesOptions combinedOptions = IndicesOptions.fromOptions(
+//             options.ignoreUnavailable(),
+//             allowNoIndices,
+//             options.expandWildcardsOpen(),
+//             options.expandWildcardsClosed(),
+//             options.expandWildcardsHidden(),
+//             options.allowAliasesToMultipleIndices(),
+//             options.forbidClosedIndices(),
+//             options.ignoreAliases(),
+//             options.ignoreThrottled()
+//         );
+
+//         Context context = new Context(state, combinedOptions, false, true, includeDataStreams, isSystemIndexAccessAllowed());
+//         Index[] indices = concreteIndices(context, index);
+//         if (allowNoIndices && indices.length == 0) {
+//             return null;
+//         }
+//         if (indices.length != 1) {
+//             throw new IllegalArgumentException(
+//                 "The index expression [" + index + "] and options provided did not point to a single write-index"
+//             );
+//         }
+//         return indices[0];
+//     }
+
+//     /**
+//      * @return whether the specified index, data stream or alias exists.
+//      *         If the data stream, index or alias contains date math then that is resolved too.
+//      */
+//     public boolean hasIndexAbstraction(String indexAbstraction, ProtobufClusterState state) {
+//         Context context = new Context(state, IndicesOptions.lenientExpandOpen(), false, false, true, isSystemIndexAccessAllowed());
+//         String resolvedAliasOrIndex = dateMathExpressionResolver.resolveExpression(indexAbstraction, context);
+//         return state.metadata().getIndicesLookup().containsKey(resolvedAliasOrIndex);
+//     }
+
+//     /**
+//      * @return If the specified string is data math expression then this method returns the resolved expression.
+//      */
+//     public String resolveDateMathExpression(String dateExpression) {
+//         // The data math expression resolver doesn't rely on cluster state or indices options, because
+//         // it just resolves the date math to an actual date.
+//         return dateMathExpressionResolver.resolveExpression(dateExpression, new Context(null, null, isSystemIndexAccessAllowed()));
+//     }
+
+//     /**
+//      * Resolve an array of expressions to the set of indices and aliases that these expressions match.
+//      */
+//     public Set<String> resolveExpressions(ProtobufClusterState state, String... expressions) {
+//         Context context = new Context(state, IndicesOptions.lenientExpandOpen(), true, false, true, isSystemIndexAccessAllowed());
+//         List<String> resolvedExpressions = Arrays.asList(expressions);
+//         for (ExpressionResolver expressionResolver : expressionResolvers) {
+//             resolvedExpressions = expressionResolver.resolve(context, resolvedExpressions);
+//         }
+//         return Collections.unmodifiableSet(new HashSet<>(resolvedExpressions));
+//     }
+
+//     /**
+//      * Iterates through the list of indices and selects the effective list of filtering aliases for the
+//      * given index.
+//      * <p>Only aliases with filters are returned. If the indices list contains a non-filtering reference to
+//      * the index itself - null is returned. Returns {@code null} if no filtering is required.
+//      * <b>NOTE</b>: The provided expressions must have been resolved already via {@link #resolveExpressions}.
+//      */
+//     public String[] filteringAliases(ProtobufClusterState state, String index, Set<String> resolvedExpressions) {
+//         return indexAliases(state, index, AliasMetadata::filteringRequired, false, resolvedExpressions);
+//     }
+
+//     /**
+//      * Whether to generate the candidate set from index aliases, or from the set of resolved expressions.
+//      * @param indexAliasesSize        the number of aliases of the index
+//      * @param resolvedExpressionsSize the number of resolved expressions
+//      */
+//     // pkg-private for testing
+//     boolean iterateIndexAliases(int indexAliasesSize, int resolvedExpressionsSize) {
+//         return indexAliasesSize <= resolvedExpressionsSize;
+//     }
+
+//     /**
+//      * Iterates through the list of indices and selects the effective list of required aliases for the given index.
+//      * <p>Only aliases where the given predicate tests successfully are returned. If the indices list contains a non-required reference to
+//      * the index itself - null is returned. Returns {@code null} if no filtering is required.
+//      * <p><b>NOTE</b>: the provided expressions must have been resolved already via {@link #resolveExpressions}.
+//      */
+//     public String[] indexAliases(
+//         ProtobufClusterState state,
+//         String index,
+//         Predicate<AliasMetadata> requiredAlias,
+//         boolean skipIdentity,
+//         Set<String> resolvedExpressions
+//     ) {
+//         if (isAllIndices(resolvedExpressions)) {
+//             return null;
+//         }
+
+//         final IndexMetadata indexMetadata = state.metadata().getIndices().get(index);
+//         if (indexMetadata == null) {
+//             // Shouldn't happen
+//             throw new IndexNotFoundException(index);
+//         }
+
+//         if (skipIdentity == false && resolvedExpressions.contains(index)) {
+//             return null;
+//         }
+
+//         final ImmutableOpenMap<String, AliasMetadata> indexAliases = indexMetadata.getAliases();
+//         final AliasMetadata[] aliasCandidates;
+//         if (iterateIndexAliases(indexAliases.size(), resolvedExpressions.size())) {
+//             // faster to iterate indexAliases
+//             aliasCandidates = StreamSupport.stream(Spliterators.spliteratorUnknownSize(indexAliases.values().iterator(), 0), false)
+//                 .map(cursor -> cursor.value)
+//                 .filter(aliasMetadata -> resolvedExpressions.contains(aliasMetadata.alias()))
+//                 .toArray(AliasMetadata[]::new);
+//         } else {
+//             // faster to iterate resolvedExpressions
+//             aliasCandidates = resolvedExpressions.stream().map(indexAliases::get).filter(Objects::nonNull).toArray(AliasMetadata[]::new);
+//         }
+
+//         List<String> aliases = null;
+//         for (AliasMetadata aliasMetadata : aliasCandidates) {
+//             if (requiredAlias.test(aliasMetadata)) {
+//                 // If required - add it to the list of aliases
+//                 if (aliases == null) {
+//                     aliases = new ArrayList<>();
+//                 }
+//                 aliases.add(aliasMetadata.alias());
+//             } else {
+//                 // If not, we have a non required alias for this index - no further checking needed
+//                 return null;
+//             }
+//         }
+//         if (aliases == null) {
+//             return null;
+//         }
+//         return aliases.toArray(new String[0]);
+//     }
+
+//     /**
+//      * Resolves the search routing if in the expression aliases are used. If expressions point to concrete indices
+//      * or aliases with no routing defined the specified routing is used.
+//      *
+//      * @return routing values grouped by concrete index
+//      */
+//     public Map<String, Set<String>> resolveSearchRouting(ProtobufClusterState state, @Nullable String routing, String... expressions) {
+//         List<String> resolvedExpressions = expressions != null ? Arrays.asList(expressions) : Collections.emptyList();
+//         Context context = new Context(state, IndicesOptions.lenientExpandOpen(), false, false, true, isSystemIndexAccessAllowed());
+//         for (ExpressionResolver expressionResolver : expressionResolvers) {
+//             resolvedExpressions = expressionResolver.resolve(context, resolvedExpressions);
+//         }
+
+//         // TODO: it appears that this can never be true?
+//         if (isAllIndices(resolvedExpressions)) {
+//             return resolveSearchRoutingAllIndices(state.metadata(), routing);
+//         }
+
+//         Map<String, Set<String>> routings = null;
+//         Set<String> paramRouting = null;
+//         // List of indices that don't require any routing
+//         Set<String> norouting = new HashSet<>();
+//         if (routing != null) {
+//             paramRouting = Sets.newHashSet(Strings.splitStringByCommaToArray(routing));
+//         }
+
+//         for (String expression : resolvedExpressions) {
+//             IndexAbstraction indexAbstraction = state.metadata().getIndicesLookup().get(expression);
+//             if (indexAbstraction != null && indexAbstraction.getType() == IndexAbstraction.Type.ALIAS) {
+//                 IndexAbstraction.Alias alias = (IndexAbstraction.Alias) indexAbstraction;
+//                 for (Tuple<String, AliasMetadata> item : alias.getConcreteIndexAndAliasMetadatas()) {
+//                     String concreteIndex = item.v1();
+//                     AliasMetadata aliasMetadata = item.v2();
+//                     if (!norouting.contains(concreteIndex)) {
+//                         if (!aliasMetadata.searchRoutingValues().isEmpty()) {
+//                             // Routing alias
+//                             if (routings == null) {
+//                                 routings = new HashMap<>();
+//                             }
+//                             Set<String> r = routings.get(concreteIndex);
+//                             if (r == null) {
+//                                 r = new HashSet<>();
+//                                 routings.put(concreteIndex, r);
+//                             }
+//                             r.addAll(aliasMetadata.searchRoutingValues());
+//                             if (paramRouting != null) {
+//                                 r.retainAll(paramRouting);
+//                             }
+//                             if (r.isEmpty()) {
+//                                 routings.remove(concreteIndex);
+//                             }
+//                         } else {
+//                             // Non-routing alias
+//                             if (!norouting.contains(concreteIndex)) {
+//                                 norouting.add(concreteIndex);
+//                                 if (paramRouting != null) {
+//                                     Set<String> r = new HashSet<>(paramRouting);
+//                                     if (routings == null) {
+//                                         routings = new HashMap<>();
+//                                     }
+//                                     routings.put(concreteIndex, r);
+//                                 } else {
+//                                     if (routings != null) {
+//                                         routings.remove(concreteIndex);
+//                                     }
+//                                 }
+//                             }
+//                         }
+//                     }
+//                 }
+//             } else {
+//                 // Index
+//                 if (!norouting.contains(expression)) {
+//                     norouting.add(expression);
+//                     if (paramRouting != null) {
+//                         Set<String> r = new HashSet<>(paramRouting);
+//                         if (routings == null) {
+//                             routings = new HashMap<>();
+//                         }
+//                         routings.put(expression, r);
+//                     } else {
+//                         if (routings != null) {
+//                             routings.remove(expression);
+//                         }
+//                     }
+//                 }
+//             }
+
+//         }
+//         if (routings == null || routings.isEmpty()) {
+//             return null;
+//         }
+//         return routings;
+//     }
+
+//     /**
+//      * Sets the same routing for all indices
+//      */
+//     public Map<String, Set<String>> resolveSearchRoutingAllIndices(Metadata metadata, String routing) {
+//         if (routing != null) {
+//             Set<String> r = Sets.newHashSet(Strings.splitStringByCommaToArray(routing));
+//             Map<String, Set<String>> routings = new HashMap<>();
+//             String[] concreteIndices = metadata.getConcreteAllIndices();
+//             for (String index : concreteIndices) {
+//                 routings.put(index, r);
+//             }
+//             return routings;
+//         }
+//         return null;
+//     }
+
+//     /**
+//      * Identifies whether the array containing index names given as argument refers to all indices
+//      * The empty or null array identifies all indices
+//      *
+//      * @param aliasesOrIndices the array containing index names
+//      * @return true if the provided array maps to all indices, false otherwise
+//      */
+//     public static boolean isAllIndices(Collection<String> aliasesOrIndices) {
+//         return aliasesOrIndices == null || aliasesOrIndices.isEmpty() || isExplicitAllPattern(aliasesOrIndices);
+//     }
+
+//     /**
+//      * Identifies whether the array containing index names given as argument explicitly refers to all indices
+//      * The empty or null array doesn't explicitly map to all indices
+//      *
+//      * @param aliasesOrIndices the array containing index names
+//      * @return true if the provided array explicitly maps to all indices, false otherwise
+//      */
+//     static boolean isExplicitAllPattern(Collection<String> aliasesOrIndices) {
+//         return aliasesOrIndices != null && aliasesOrIndices.size() == 1 && Metadata.ALL.equals(aliasesOrIndices.iterator().next());
+//     }
+
+//     /**
+//      * Identifies whether the first argument (an array containing index names) is a pattern that matches all indices
+//      *
+//      * @param indicesOrAliases the array containing index names
+//      * @param concreteIndices  array containing the concrete indices that the first argument refers to
+//      * @return true if the first argument is a pattern that maps to all available indices, false otherwise
+//      */
+//     boolean isPatternMatchingAllIndices(Metadata metadata, String[] indicesOrAliases, String[] concreteIndices) {
+//         // if we end up matching on all indices, check, if its a wildcard parameter, or a "-something" structure
+//         if (concreteIndices.length == metadata.getConcreteAllIndices().length && indicesOrAliases.length > 0) {
+
+//             // we might have something like /-test1,+test1 that would identify all indices
+//             // or something like /-test1 with test1 index missing and IndicesOptions.lenient()
+//             if (indicesOrAliases[0].charAt(0) == '-') {
+//                 return true;
+//             }
+
+//             // otherwise we check if there's any simple regex
+//             for (String indexOrAlias : indicesOrAliases) {
+//                 if (Regex.isSimpleMatchPattern(indexOrAlias)) {
+//                     return true;
+//                 }
+//             }
+//         }
+//         return false;
+//     }
+
+//     /**
+//      * Determines whether or not system index access should be allowed in the current context.
+//      *
+//      * @return True if system index access should be allowed, false otherwise.
+//      */
+//     public boolean isSystemIndexAccessAllowed() {
+//         return Booleans.parseBoolean(threadContext.getHeader(SYSTEM_INDEX_ACCESS_CONTROL_HEADER_KEY), true);
+//     }
+
+//     /**
+//      * Context for the resolver.
+//      *
+//      * @opensearch.internal
+//      */
+//     public static class Context {
+
+//         private final ProtobufClusterState state;
+//         private final IndicesOptions options;
+//         private final long startTime;
+//         private final boolean preserveAliases;
+//         private final boolean resolveToWriteIndex;
+//         private final boolean includeDataStreams;
+//         private final boolean preserveDataStreams;
+//         private final boolean isSystemIndexAccessAllowed;
+
+//         Context(ProtobufClusterState state, IndicesOptions options, boolean isSystemIndexAccessAllowed) {
+//             this(state, options, System.currentTimeMillis(), isSystemIndexAccessAllowed);
+//         }
+
+//         Context(
+//             ProtobufClusterState state,
+//             IndicesOptions options,
+//             boolean preserveAliases,
+//             boolean resolveToWriteIndex,
+//             boolean includeDataStreams,
+//             boolean isSystemIndexAccessAllowed
+//         ) {
+//             this(
+//                 state,
+//                 options,
+//                 System.currentTimeMillis(),
+//                 preserveAliases,
+//                 resolveToWriteIndex,
+//                 includeDataStreams,
+//                 false,
+//                 isSystemIndexAccessAllowed
+//             );
+//         }
+
+//         Context(
+//             ProtobufClusterState state,
+//             IndicesOptions options,
+//             boolean preserveAliases,
+//             boolean resolveToWriteIndex,
+//             boolean includeDataStreams,
+//             boolean preserveDataStreams,
+//             boolean isSystemIndexAccessAllowed
+//         ) {
+//             this(
+//                 state,
+//                 options,
+//                 System.currentTimeMillis(),
+//                 preserveAliases,
+//                 resolveToWriteIndex,
+//                 includeDataStreams,
+//                 preserveDataStreams,
+//                 isSystemIndexAccessAllowed
+//             );
+//         }
+
+//         Context(ProtobufClusterState state, IndicesOptions options, long startTime, boolean isSystemIndexAccessAllowed) {
+//             this(state, options, startTime, false, false, false, false, isSystemIndexAccessAllowed);
+//         }
+
+//         protected Context(
+//             ProtobufClusterState state,
+//             IndicesOptions options,
+//             long startTime,
+//             boolean preserveAliases,
+//             boolean resolveToWriteIndex,
+//             boolean includeDataStreams,
+//             boolean preserveDataStreams,
+//             boolean isSystemIndexAccessAllowed
+//         ) {
+//             this.state = state;
+//             this.options = options;
+//             this.startTime = startTime;
+//             this.preserveAliases = preserveAliases;
+//             this.resolveToWriteIndex = resolveToWriteIndex;
+//             this.includeDataStreams = includeDataStreams;
+//             this.preserveDataStreams = preserveDataStreams;
+//             this.isSystemIndexAccessAllowed = isSystemIndexAccessAllowed;
+//         }
+
+//         public ProtobufClusterState getState() {
+//             return state;
+//         }
+
+//         public IndicesOptions getOptions() {
+//             return options;
+//         }
+
+//         public long getStartTime() {
+//             return startTime;
+//         }
+
+//         /**
+//          * This is used to prevent resolving aliases to concrete indices but this also means
+//          * that we might return aliases that point to a closed index. This is currently only used
+//          * by {@link #filteringAliases(ProtobufClusterState, String, Set)} since it's the only one that needs aliases
+//          */
+//         boolean isPreserveAliases() {
+//             return preserveAliases;
+//         }
+
+//         /**
+//          * This is used to require that aliases resolve to their write-index. It is currently not used in conjunction
+//          * with <code>preserveAliases</code>.
+//          */
+//         boolean isResolveToWriteIndex() {
+//             return resolveToWriteIndex;
+//         }
+
+//         public boolean includeDataStreams() {
+//             return includeDataStreams;
+//         }
+
+//         public boolean isPreserveDataStreams() {
+//             return preserveDataStreams;
+//         }
+
+//         /**
+//          * Used to determine if it is allowed to access system indices in this context (e.g. for this request).
+//          */
+//         public boolean isSystemIndexAccessAllowed() {
+//             return isSystemIndexAccessAllowed;
+//         }
+//     }
+
+//     private interface ExpressionResolver {
+
+//         /**
+//          * Resolves the list of expressions into other expressions if possible (possible concrete indices and aliases, but
+//          * that isn't required). The provided implementations can also be left untouched.
+//          *
+//          * @return a new list with expressions based on the provided expressions
+//          */
+//         List<String> resolve(Context context, List<String> expressions);
+
+//     }
+
+//     /**
+//      * Resolves alias/index name expressions with wildcards into the corresponding concrete indices/aliases
+//      *
+//      * @opensearch.internal
+//      */
+//     static final class WildcardExpressionResolver implements ExpressionResolver {
+
+//         @Override
+//         public List<String> resolve(Context context, List<String> expressions) {
+//             IndicesOptions options = context.getOptions();
+//             Metadata metadata = context.getState().metadata();
+//             // only check open/closed since if we do not expand to open or closed it doesn't make sense to
+//             // expand to hidden
+//             if (options.expandWildcardsClosed() == false && options.expandWildcardsOpen() == false) {
+//                 return expressions;
+//             }
+
+//             if (isEmptyOrTrivialWildcard(expressions)) {
+//                 List<String> resolvedExpressions = resolveEmptyOrTrivialWildcard(options, metadata);
+//                 if (context.includeDataStreams()) {
+//                     final IndexMetadata.State excludeState = excludeState(options);
+//                     final Map<String, IndexAbstraction> dataStreamsAbstractions = metadata.getIndicesLookup()
+//                         .entrySet()
+//                         .stream()
+//                         .filter(entry -> entry.getValue().getType() == IndexAbstraction.Type.DATA_STREAM)
+//                         .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+//                     // dedup backing indices if expand hidden indices option is true
+//                     Set<String> resolvedIncludingDataStreams = new HashSet<>(resolvedExpressions);
+//                     resolvedIncludingDataStreams.addAll(
+//                         expand(
+//                             context,
+//                             excludeState,
+//                             dataStreamsAbstractions,
+//                             expressions.isEmpty() ? "_all" : expressions.get(0),
+//                             options.expandWildcardsHidden()
+//                         )
+//                     );
+//                     return new ArrayList<>(resolvedIncludingDataStreams);
+//                 }
+//                 return resolvedExpressions;
+//             }
+
+//             Set<String> result = innerResolve(context, expressions, options, metadata);
+
+//             if (result == null) {
+//                 return expressions;
+//             }
+//             if (result.isEmpty() && !options.allowNoIndices()) {
+//                 IndexNotFoundException infe = new IndexNotFoundException((String) null);
+//                 infe.setResources("index_or_alias", expressions.toArray(new String[0]));
+//                 throw infe;
+//             }
+//             return new ArrayList<>(result);
+//         }
+
+//         private Set<String> innerResolve(Context context, List<String> expressions, IndicesOptions options, Metadata metadata) {
+//             Set<String> result = null;
+//             boolean wildcardSeen = false;
+//             for (int i = 0; i < expressions.size(); i++) {
+//                 String expression = expressions.get(i);
+//                 if (Strings.isEmpty(expression)) {
+//                     throw indexNotFoundException(expression);
+//                 }
+//                 validateAliasOrIndex(expression);
+//                 if (aliasOrIndexExists(context, options, metadata, expression)) {
+//                     if (result != null) {
+//                         result.add(expression);
+//                     }
+//                     continue;
+//                 }
+//                 final boolean add;
+//                 if (expression.charAt(0) == '-' && wildcardSeen) {
+//                     add = false;
+//                     expression = expression.substring(1);
+//                 } else {
+//                     add = true;
+//                 }
+//                 if (result == null) {
+//                     // add all the previous ones...
+//                     result = new HashSet<>(expressions.subList(0, i));
+//                 }
+//                 if (Regex.isSimpleMatchPattern(expression) == false) {
+//                     // TODO why does wildcard resolver throw exceptions regarding non wildcarded expressions? This should not be done here.
+//                     if (options.ignoreUnavailable() == false) {
+//                         IndexAbstraction indexAbstraction = metadata.getIndicesLookup().get(expression);
+//                         if (indexAbstraction == null) {
+//                             throw indexNotFoundException(expression);
+//                         } else if (indexAbstraction.getType() == IndexAbstraction.Type.ALIAS && options.ignoreAliases()) {
+//                             throw aliasesNotSupportedException(expression);
+//                         } else if (indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM
+//                             && context.includeDataStreams() == false) {
+//                                 throw indexNotFoundException(expression);
+//                             }
+//                     }
+//                     if (add) {
+//                         result.add(expression);
+//                     } else {
+//                         result.remove(expression);
+//                     }
+//                     continue;
+//                 }
+
+//                 final IndexMetadata.State excludeState = excludeState(options);
+//                 final Map<String, IndexAbstraction> matches = matches(context, metadata, expression);
+//                 Set<String> expand = expand(context, excludeState, matches, expression, options.expandWildcardsHidden());
+//                 if (add) {
+//                     result.addAll(expand);
+//                 } else {
+//                     result.removeAll(expand);
+//                 }
+//                 if (options.allowNoIndices() == false && matches.isEmpty()) {
+//                     throw indexNotFoundException(expression);
+//                 }
+//                 if (Regex.isSimpleMatchPattern(expression)) {
+//                     wildcardSeen = true;
+//                 }
+//             }
+//             return result;
+//         }
+
+//         private static void validateAliasOrIndex(String expression) {
+//             // Expressions can not start with an underscore. This is reserved for APIs. If the check gets here, the API
+//             // does not exist and the path is interpreted as an expression. If the expression begins with an underscore,
+//             // throw a specific error that is different from the [[IndexNotFoundException]], which is typically thrown
+//             // if the expression can't be found.
+//             if (expression.charAt(0) == '_') {
+//                 throw new InvalidIndexNameException(expression, "must not start with '_'.");
+//             }
+//         }
+
+//         private static boolean aliasOrIndexExists(Context context, IndicesOptions options, Metadata metadata, String expression) {
+//             IndexAbstraction indexAbstraction = metadata.getIndicesLookup().get(expression);
+//             if (indexAbstraction == null) {
+//                 return false;
+//             }
+
+//             // treat aliases as unavailable indices when ignoreAliases is set to true (e.g. delete index and update aliases api)
+//             if (indexAbstraction.getType() == IndexAbstraction.Type.ALIAS && options.ignoreAliases()) {
+//                 return false;
+//             }
+
+//             if (indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM && context.includeDataStreams() == false) {
+//                 return false;
+//             }
+
+//             return true;
+//         }
+
+//         private static IndexNotFoundException indexNotFoundException(String expression) {
+//             IndexNotFoundException infe = new IndexNotFoundException(expression);
+//             infe.setResources("index_or_alias", expression);
+//             return infe;
+//         }
+
+//         private static IndexMetadata.State excludeState(IndicesOptions options) {
+//             final IndexMetadata.State excludeState;
+//             if (options.expandWildcardsOpen() && options.expandWildcardsClosed()) {
+//                 excludeState = null;
+//             } else if (options.expandWildcardsOpen() && options.expandWildcardsClosed() == false) {
+//                 excludeState = IndexMetadata.State.CLOSE;
+//             } else if (options.expandWildcardsClosed() && options.expandWildcardsOpen() == false) {
+//                 excludeState = IndexMetadata.State.OPEN;
+//             } else {
+//                 assert false : "this shouldn't get called if wildcards expand to none";
+//                 excludeState = null;
+//             }
+//             return excludeState;
+//         }
+
+//         public static Map<String, IndexAbstraction> matches(Context context, Metadata metadata, String expression) {
+//             if (Regex.isMatchAllPattern(expression)) {
+//                 return filterIndicesLookup(context, metadata.getIndicesLookup(), null, context.getOptions());
+//             } else if (expression.indexOf("*") == expression.length() - 1) {
+//                 return suffixWildcard(context, metadata, expression);
+//             } else {
+//                 return otherWildcard(context, metadata, expression);
+//             }
+//         }
+
+//         private static Map<String, IndexAbstraction> suffixWildcard(Context context, Metadata metadata, String expression) {
+//             assert expression.length() >= 2 : "expression [" + expression + "] should have at least a length of 2";
+//             String fromPrefix = expression.substring(0, expression.length() - 1);
+//             char[] toPrefixCharArr = fromPrefix.toCharArray();
+//             toPrefixCharArr[toPrefixCharArr.length - 1]++;
+//             String toPrefix = new String(toPrefixCharArr);
+//             SortedMap<String, IndexAbstraction> subMap = metadata.getIndicesLookup().subMap(fromPrefix, toPrefix);
+//             return filterIndicesLookup(context, subMap, null, context.getOptions());
+//         }
+
+//         private static Map<String, IndexAbstraction> otherWildcard(Context context, Metadata metadata, String expression) {
+//             final String pattern = expression;
+//             return filterIndicesLookup(
+//                 context,
+//                 metadata.getIndicesLookup(),
+//                 e -> Regex.simpleMatch(pattern, e.getKey()),
+//                 context.getOptions()
+//             );
+//         }
+
+//         private static Map<String, IndexAbstraction> filterIndicesLookup(
+//             Context context,
+//             SortedMap<String, IndexAbstraction> indicesLookup,
+//             Predicate<? super Map.Entry<String, IndexAbstraction>> filter,
+//             IndicesOptions options
+//         ) {
+//             boolean shouldConsumeStream = false;
+//             Stream<Map.Entry<String, IndexAbstraction>> stream = indicesLookup.entrySet().stream();
+//             if (options.ignoreAliases()) {
+//                 shouldConsumeStream = true;
+//                 stream = stream.filter(e -> e.getValue().getType() != IndexAbstraction.Type.ALIAS);
+//             }
+//             if (filter != null) {
+//                 shouldConsumeStream = true;
+//                 stream = stream.filter(filter);
+//             }
+//             if (context.includeDataStreams() == false) {
+//                 shouldConsumeStream = true;
+//                 stream = stream.filter(e -> e.getValue().getType() != IndexAbstraction.Type.DATA_STREAM);
+//             }
+//             if (shouldConsumeStream) {
+//                 return stream.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+//             } else {
+//                 return indicesLookup;
+//             }
+//         }
+
+//         private static Set<String> expand(
+//             Context context,
+//             IndexMetadata.State excludeState,
+//             Map<String, IndexAbstraction> matches,
+//             String expression,
+//             boolean includeHidden
+//         ) {
+//             Set<String> expand = new HashSet<>();
+//             for (Map.Entry<String, IndexAbstraction> entry : matches.entrySet()) {
+//                 String aliasOrIndexName = entry.getKey();
+//                 IndexAbstraction indexAbstraction = entry.getValue();
+
+//                 if (indexAbstraction.isHidden() == false || includeHidden || implicitHiddenMatch(aliasOrIndexName, expression)) {
+//                     if (context.isPreserveAliases() && indexAbstraction.getType() == IndexAbstraction.Type.ALIAS) {
+//                         expand.add(aliasOrIndexName);
+//                     } else {
+//                         for (IndexMetadata meta : indexAbstraction.getIndices()) {
+//                             if (excludeState == null || meta.getState() != excludeState) {
+//                                 expand.add(meta.getIndex().getName());
+//                             }
+//                         }
+//                         if (context.isPreserveDataStreams() && indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM) {
+//                             expand.add(indexAbstraction.getName());
+//                         }
+//                     }
+//                 }
+//             }
+//             return expand;
+//         }
+
+//         private static boolean implicitHiddenMatch(String itemName, String expression) {
+//             return itemName.startsWith(".") && expression.startsWith(".") && Regex.isSimpleMatchPattern(expression);
+//         }
+
+//         private boolean isEmptyOrTrivialWildcard(List<String> expressions) {
+//             return expressions.isEmpty()
+//                 || (expressions.size() == 1 && (Metadata.ALL.equals(expressions.get(0)) || Regex.isMatchAllPattern(expressions.get(0))));
+//         }
+
+//         private static List<String> resolveEmptyOrTrivialWildcard(IndicesOptions options, Metadata metadata) {
+//             if (options.expandWildcardsOpen() && options.expandWildcardsClosed() && options.expandWildcardsHidden()) {
+//                 return Arrays.asList(metadata.getConcreteAllIndices());
+//             } else if (options.expandWildcardsOpen() && options.expandWildcardsClosed()) {
+//                 return Arrays.asList(metadata.getConcreteVisibleIndices());
+//             } else if (options.expandWildcardsOpen() && options.expandWildcardsHidden()) {
+//                 return Arrays.asList(metadata.getConcreteAllOpenIndices());
+//             } else if (options.expandWildcardsOpen()) {
+//                 return Arrays.asList(metadata.getConcreteVisibleOpenIndices());
+//             } else if (options.expandWildcardsClosed() && options.expandWildcardsHidden()) {
+//                 return Arrays.asList(metadata.getConcreteAllClosedIndices());
+//             } else if (options.expandWildcardsClosed()) {
+//                 return Arrays.asList(metadata.getConcreteVisibleClosedIndices());
+//             } else {
+//                 return Collections.emptyList();
+//             }
+//         }
+//     }
+
+//     /**
+//      * A date math expression resolver.
+//      *
+//      * @opensearch.internal
+//      */
+//     public static final class DateMathExpressionResolver implements ExpressionResolver {
+
+//         private static final DateFormatter DEFAULT_DATE_FORMATTER = DateFormatter.forPattern("uuuu.MM.dd");
+//         private static final String EXPRESSION_LEFT_BOUND = "<";
+//         private static final String EXPRESSION_RIGHT_BOUND = ">";
+//         private static final char LEFT_BOUND = '{';
+//         private static final char RIGHT_BOUND = '}';
+//         private static final char ESCAPE_CHAR = '\\';
+//         private static final char TIME_ZONE_BOUND = '|';
+
+//         @Override
+//         public List<String> resolve(final Context context, List<String> expressions) {
+//             List<String> result = new ArrayList<>(expressions.size());
+//             for (String expression : expressions) {
+//                 result.add(resolveExpression(expression, context));
+//             }
+//             return result;
+//         }
+
+//         @SuppressWarnings("fallthrough")
+//         String resolveExpression(String expression, final Context context) {
+//             if (expression.startsWith(EXPRESSION_LEFT_BOUND) == false || expression.endsWith(EXPRESSION_RIGHT_BOUND) == false) {
+//                 return expression;
+//             }
+
+//             boolean escape = false;
+//             boolean inDateFormat = false;
+//             boolean inPlaceHolder = false;
+//             final StringBuilder beforePlaceHolderSb = new StringBuilder();
+//             StringBuilder inPlaceHolderSb = new StringBuilder();
+//             final char[] text = expression.toCharArray();
+//             final int from = 1;
+//             final int length = text.length - 1;
+//             for (int i = from; i < length; i++) {
+//                 boolean escapedChar = escape;
+//                 if (escape) {
+//                     escape = false;
+//                 }
+
+//                 char c = text[i];
+//                 if (c == ESCAPE_CHAR) {
+//                     if (escapedChar) {
+//                         beforePlaceHolderSb.append(c);
+//                         escape = false;
+//                     } else {
+//                         escape = true;
+//                     }
+//                     continue;
+//                 }
+//                 if (inPlaceHolder) {
+//                     switch (c) {
+//                         case LEFT_BOUND:
+//                             if (inDateFormat && escapedChar) {
+//                                 inPlaceHolderSb.append(c);
+//                             } else if (!inDateFormat) {
+//                                 inDateFormat = true;
+//                                 inPlaceHolderSb.append(c);
+//                             } else {
+//                                 throw new OpenSearchParseException(
+//                                     "invalid dynamic name expression [{}]." + " invalid character in placeholder at position [{}]",
+//                                     new String(text, from, length),
+//                                     i
+//                                 );
+//                             }
+//                             break;
+
+//                         case RIGHT_BOUND:
+//                             if (inDateFormat && escapedChar) {
+//                                 inPlaceHolderSb.append(c);
+//                             } else if (inDateFormat) {
+//                                 inDateFormat = false;
+//                                 inPlaceHolderSb.append(c);
+//                             } else {
+//                                 String inPlaceHolderString = inPlaceHolderSb.toString();
+//                                 int dateTimeFormatLeftBoundIndex = inPlaceHolderString.indexOf(LEFT_BOUND);
+//                                 String mathExpression;
+//                                 String dateFormatterPattern;
+//                                 DateFormatter dateFormatter;
+//                                 final ZoneId timeZone;
+//                                 if (dateTimeFormatLeftBoundIndex < 0) {
+//                                     mathExpression = inPlaceHolderString;
+//                                     dateFormatter = DEFAULT_DATE_FORMATTER;
+//                                     timeZone = ZoneOffset.UTC;
+//                                 } else {
+//                                     if (inPlaceHolderString.lastIndexOf(RIGHT_BOUND) != inPlaceHolderString.length() - 1) {
+//                                         throw new OpenSearchParseException(
+//                                             "invalid dynamic name expression [{}]. missing closing `}`" + " for date math format",
+//                                             inPlaceHolderString
+//                                         );
+//                                     }
+//                                     if (dateTimeFormatLeftBoundIndex == inPlaceHolderString.length() - 2) {
+//                                         throw new OpenSearchParseException(
+//                                             "invalid dynamic name expression [{}]. missing date format",
+//                                             inPlaceHolderString
+//                                         );
+//                                     }
+//                                     mathExpression = inPlaceHolderString.substring(0, dateTimeFormatLeftBoundIndex);
+//                                     String patternAndTZid = inPlaceHolderString.substring(
+//                                         dateTimeFormatLeftBoundIndex + 1,
+//                                         inPlaceHolderString.length() - 1
+//                                     );
+//                                     int formatPatternTimeZoneSeparatorIndex = patternAndTZid.indexOf(TIME_ZONE_BOUND);
+//                                     if (formatPatternTimeZoneSeparatorIndex != -1) {
+//                                         dateFormatterPattern = patternAndTZid.substring(0, formatPatternTimeZoneSeparatorIndex);
+//                                         timeZone = DateUtils.of(patternAndTZid.substring(formatPatternTimeZoneSeparatorIndex + 1));
+//                                     } else {
+//                                         dateFormatterPattern = patternAndTZid;
+//                                         timeZone = ZoneOffset.UTC;
+//                                     }
+//                                     dateFormatter = DateFormatter.forPattern(dateFormatterPattern);
+//                                 }
+
+//                                 DateFormatter formatter = dateFormatter.withZone(timeZone);
+//                                 DateMathParser dateMathParser = formatter.toDateMathParser();
+//                                 Instant instant = dateMathParser.parse(mathExpression, context::getStartTime, false, timeZone);
+
+//                                 String time = formatter.format(instant);
+//                                 beforePlaceHolderSb.append(time);
+//                                 inPlaceHolderSb = new StringBuilder();
+//                                 inPlaceHolder = false;
+//                             }
+//                             break;
+
+//                         default:
+//                             inPlaceHolderSb.append(c);
+//                     }
+//                 } else {
+//                     switch (c) {
+//                         case LEFT_BOUND:
+//                             if (escapedChar) {
+//                                 beforePlaceHolderSb.append(c);
+//                             } else {
+//                                 inPlaceHolder = true;
+//                             }
+//                             break;
+
+//                         case RIGHT_BOUND:
+//                             if (!escapedChar) {
+//                                 throw new OpenSearchParseException(
+//                                     "invalid dynamic name expression [{}]."
+//                                         + " invalid character at position [{}]. `{` and `}` are reserved characters and"
+//                                         + " should be escaped when used as part of the index name using `\\` (e.g. `\\{text\\}`)",
+//                                     new String(text, from, length),
+//                                     i
+//                                 );
+//                             }
+//                         default:
+//                             beforePlaceHolderSb.append(c);
+//                     }
+//                 }
+//             }
+
+//             if (inPlaceHolder) {
+//                 throw new OpenSearchParseException(
+//                     "invalid dynamic name expression [{}]. date math placeholder is open ended",
+//                     new String(text, from, length)
+//                 );
+//             }
+//             if (beforePlaceHolderSb.length() == 0) {
+//                 throw new OpenSearchParseException("nothing captured");
+//             }
+//             return beforePlaceHolderSb.toString();
+//         }
+//     }
+// }
diff --git a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
index 56cd468d3d3a4..471779a65587d 100644
--- a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
+++ b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
@@ -366,9 +366,9 @@ public DiscoveryNode(CodedInputStream in) throws IOException {
         this.ephemeralId = in.readString();
         this.hostName = in.readString();
         this.hostAddress = in.readString();
-        ProtobufTransportAddress protobufTransportAddress = new ProtobufTransportAddress(in);
-        this.address = new TransportAddress(protobufTransportAddress.address());
-        // this.address = new TransportAddress(in);
+        // ProtobufTransportAddress protobufTransportAddress = new ProtobufTransportAddress(in);
+        // this.address = new TransportAddress(protobufTransportAddress.address());
+        this.address = new TransportAddress(in);
         int size = in.readInt32();
         this.attributes = new HashMap<>(size);
         for (int i = 0; i < size; i++) {
@@ -432,9 +432,9 @@ public void writeTo(CodedOutputStream out) throws IOException {
         out.writeStringNoTag(ephemeralId);
         out.writeStringNoTag(hostName);
         out.writeStringNoTag(hostAddress);
-        ProtobufTransportAddress protobufTransportAddress = new ProtobufTransportAddress(address.address());
-        protobufTransportAddress.writeTo(out);
-        // address.writeTo(out);
+        // ProtobufTransportAddress protobufTransportAddress = new ProtobufTransportAddress(address.address());
+        // protobufTransportAddress.writeTo(out);
+        address.writeTo(out);
         out.writeInt32NoTag(attributes.size());
         for (Map.Entry<String, String> entry : attributes.entrySet()) {
             out.writeStringNoTag(entry.getKey());
@@ -457,12 +457,12 @@ public TransportAddress getAddress() {
         return address;
     }
 
-    /**
-     * The address that the node can be communicated with.
-     */
-    public ProtobufTransportAddress getProtobufAddress() {
-        return new ProtobufTransportAddress(address.address());
-    }
+    // /**
+    //  * The address that the node can be communicated with.
+    //  */
+    // public ProtobufTransportAddress getProtobufAddress() {
+    //     return new ProtobufTransportAddress(address.address());
+    // }
 
     /**
      * The unique id of the node.
diff --git a/server/src/main/java/org/opensearch/common/network/NetworkModule.java b/server/src/main/java/org/opensearch/common/network/NetworkModule.java
index ba348e89ed73b..c6445853de068 100644
--- a/server/src/main/java/org/opensearch/common/network/NetworkModule.java
+++ b/server/src/main/java/org/opensearch/common/network/NetworkModule.java
@@ -58,8 +58,9 @@
 import org.opensearch.tasks.RawTaskStatus;
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportInterceptor;
-import org.opensearch.transport.ProtobufTransportRequest;
+import org.opensearch.transport.TransportInterceptor;
+import org.opensearch.transport.TransportRequest;
+import org.opensearch.transport.TransportRequestHandler;
 import org.opensearch.transport.ProtobufTransportRequestHandler;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportInterceptor;
@@ -134,7 +135,7 @@ public final class NetworkModule {
     private final Map<String, Supplier<Transport>> transportFactories = new HashMap<>();
     private final Map<String, Supplier<HttpServerTransport>> transportHttpFactories = new HashMap<>();
     private final List<TransportInterceptor> transportIntercetors = new ArrayList<>();
-    private final List<ProtobufTransportInterceptor> protobufTransportInterceptors = new ArrayList<>();
+    private final List<TransportInterceptor> TransportInterceptors = new ArrayList<>();
 
     /**
      * Creates a network module that custom networking classes can be plugged into.
@@ -295,6 +296,19 @@ public <T extends TransportRequest> TransportRequestHandler<T> interceptHandler(
             return actualHandler;
         }
 
+        @Override
+        public <T extends TransportRequest> ProtobufTransportRequestHandler<T> interceptHandlerProtobuf(
+            String action,
+            String executor,
+            boolean forceExecution,
+            ProtobufTransportRequestHandler<T> actualHandler
+        ) {
+            for (TransportInterceptor interceptor : this.transportInterceptors) {
+                actualHandler = interceptor.interceptHandlerProtobuf(action, executor, forceExecution, actualHandler);
+            }
+            return actualHandler;
+        }
+
         @Override
         public AsyncSender interceptSender(AsyncSender sender) {
             for (TransportInterceptor interceptor : this.transportInterceptors) {
@@ -304,36 +318,36 @@ public AsyncSender interceptSender(AsyncSender sender) {
         }
     }
 
-    /**
-    * Registers a new {@link TransportInterceptor}
-    */
-    private void registerProtobufTransportInterceptor(ProtobufTransportInterceptor interceptor) {
-        this.protobufTransportInterceptors.add(Objects.requireNonNull(interceptor, "interceptor must not be null"));
-    }
-
-    /**
-     * Returns a composite {@link ProtobufTransportInterceptor} containing all registered interceptors
-     * @see #registerProtobufTransportInterceptor(ProtobufTransportInterceptor)
-     */
-    public ProtobufTransportInterceptor getProtobufTransportInterceptor() {
-        return new ProtobufCompositeTransportInterceptor(this.protobufTransportInterceptors);
-    }
-
-    static final class ProtobufCompositeTransportInterceptor implements ProtobufTransportInterceptor {
-        final List<ProtobufTransportInterceptor> transportInterceptors;
+    // /**
+    // * Registers a new {@link TransportInterceptor}
+    // */
+    // private void registerTransportInterceptor(TransportInterceptor interceptor) {
+    //     this.TransportInterceptors.add(Objects.requireNonNull(interceptor, "interceptor must not be null"));
+    // }
+
+    // /**
+    //  * Returns a composite {@link TransportInterceptor} containing all registered interceptors
+    //  * @see #registerTransportInterceptor(TransportInterceptor)
+    //  */
+    // public TransportInterceptor getTransportInterceptor() {
+    //     return new ProtobufCompositeTransportInterceptor(this.TransportInterceptors);
+    // }
+
+    static final class ProtobufCompositeTransportInterceptor implements TransportInterceptor {
+        final List<TransportInterceptor> transportInterceptors;
 
-        private ProtobufCompositeTransportInterceptor(List<ProtobufTransportInterceptor> transportInterceptors) {
+        private ProtobufCompositeTransportInterceptor(List<TransportInterceptor> transportInterceptors) {
             this.transportInterceptors = new ArrayList<>(transportInterceptors);
         }
 
         @Override
-        public <T extends ProtobufTransportRequest> ProtobufTransportRequestHandler<T> interceptHandler(
+        public <T extends TransportRequest> TransportRequestHandler<T> interceptHandler(
             String action,
             String executor,
             boolean forceExecution,
-            ProtobufTransportRequestHandler<T> actualHandler
+            TransportRequestHandler<T> actualHandler
         ) {
-            for (ProtobufTransportInterceptor interceptor : this.transportInterceptors) {
+            for (TransportInterceptor interceptor : this.transportInterceptors) {
                 actualHandler = interceptor.interceptHandler(action, executor, forceExecution, actualHandler);
             }
             return actualHandler;
@@ -341,7 +355,7 @@ public <T extends ProtobufTransportRequest> ProtobufTransportRequestHandler<T> i
 
         @Override
         public AsyncSender interceptSender(AsyncSender sender) {
-            for (ProtobufTransportInterceptor interceptor : this.transportInterceptors) {
+            for (TransportInterceptor interceptor : this.transportInterceptors) {
                 sender = interceptor.interceptSender(sender);
             }
             return sender;
diff --git a/server/src/main/java/org/opensearch/common/transport/BoundTransportAddress.java b/server/src/main/java/org/opensearch/common/transport/BoundTransportAddress.java
index 3a9c337f2d950..0a12589f58752 100644
--- a/server/src/main/java/org/opensearch/common/transport/BoundTransportAddress.java
+++ b/server/src/main/java/org/opensearch/common/transport/BoundTransportAddress.java
@@ -32,11 +32,15 @@
 
 package org.opensearch.common.transport;
 
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.common.network.InetAddresses;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 
 /**
@@ -46,7 +50,7 @@
  *
  * @opensearch.internal
  */
-public class BoundTransportAddress implements Writeable {
+public class BoundTransportAddress implements Writeable, ProtobufWriteable {
 
     private TransportAddress[] boundAddresses;
 
@@ -61,6 +65,16 @@ public BoundTransportAddress(StreamInput in) throws IOException {
         publishAddress = new TransportAddress(in);
     }
 
+    public BoundTransportAddress(CodedInputStream in) throws IOException {
+        int boundAddressLength = in.readInt32();
+        boundAddresses = new TransportAddress[boundAddressLength];
+        for (int i = 0; i < boundAddressLength; i++) {
+            boundAddresses[i] = new TransportAddress(in);
+        }
+        publishAddress = new TransportAddress(in);
+    }
+
+
     public BoundTransportAddress(TransportAddress[] boundAddresses, TransportAddress publishAddress) {
         if (boundAddresses == null || boundAddresses.length < 1) {
             throw new IllegalArgumentException("at least one bound address must be provided");
@@ -86,6 +100,15 @@ public void writeTo(StreamOutput out) throws IOException {
         publishAddress.writeTo(out);
     }
 
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        out.writeInt32NoTag(boundAddresses.length);
+        for (TransportAddress address : boundAddresses) {
+            address.writeTo(out);
+        }
+        publishAddress.writeTo(out);
+    }
+
     @Override
     public String toString() {
         StringBuilder builder = new StringBuilder("publish_address {");
diff --git a/server/src/main/java/org/opensearch/common/transport/ProtobufBoundTransportAddress.java b/server/src/main/java/org/opensearch/common/transport/ProtobufBoundTransportAddress.java
index 96ca6719491f7..3b3d27ec91de1 100644
--- a/server/src/main/java/org/opensearch/common/transport/ProtobufBoundTransportAddress.java
+++ b/server/src/main/java/org/opensearch/common/transport/ProtobufBoundTransportAddress.java
@@ -20,7 +20,7 @@
 
 import java.io.IOException;
 
-/**
+/** not used
  * A bounded transport address is a tuple of {@link TransportAddress}, one array that represents
 * the addresses the transport is bound to, and the other is the published one that represents the address clients
 * should communicate on.
@@ -29,20 +29,20 @@
 */
 public class ProtobufBoundTransportAddress implements ProtobufWriteable {
 
-    private ProtobufTransportAddress[] boundAddresses;
+    private TransportAddress[] boundAddresses;
 
-    private ProtobufTransportAddress publishAddress;
+    private TransportAddress publishAddress;
 
     public ProtobufBoundTransportAddress(CodedInputStream in) throws IOException {
         int boundAddressLength = in.readInt32();
-        boundAddresses = new ProtobufTransportAddress[boundAddressLength];
+        boundAddresses = new TransportAddress[boundAddressLength];
         for (int i = 0; i < boundAddressLength; i++) {
-            boundAddresses[i] = new ProtobufTransportAddress(in);
+            boundAddresses[i] = new TransportAddress(in);
         }
-        publishAddress = new ProtobufTransportAddress(in);
+        publishAddress = new TransportAddress(in);
     }
 
-    public ProtobufBoundTransportAddress(ProtobufTransportAddress[] boundAddresses, ProtobufTransportAddress publishAddress) {
+    public ProtobufBoundTransportAddress(TransportAddress[] boundAddresses, TransportAddress publishAddress) {
         if (boundAddresses == null || boundAddresses.length < 1) {
             throw new IllegalArgumentException("at least one bound address must be provided");
         }
@@ -50,18 +50,18 @@ public ProtobufBoundTransportAddress(ProtobufTransportAddress[] boundAddresses,
         this.publishAddress = publishAddress;
     }
 
-    public ProtobufTransportAddress[] boundAddresses() {
+    public TransportAddress[] boundAddresses() {
         return boundAddresses;
     }
 
-    public ProtobufTransportAddress publishAddress() {
+    public TransportAddress publishAddress() {
         return publishAddress;
     }
 
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
         out.writeInt32NoTag(boundAddresses.length);
-        for (ProtobufTransportAddress address : boundAddresses) {
+        for (TransportAddress address : boundAddresses) {
             address.writeTo(out);
         }
         publishAddress.writeTo(out);
@@ -78,7 +78,7 @@ public String toString() {
         builder.append(publishAddressString);
         builder.append("}, bound_addresses ");
         boolean firstAdded = false;
-        for (ProtobufTransportAddress address : boundAddresses) {
+        for (TransportAddress address : boundAddresses) {
             if (firstAdded) {
                 builder.append(", ");
             } else {
diff --git a/server/src/main/java/org/opensearch/common/transport/ProtobufTransportAddress.java b/server/src/main/java/org/opensearch/common/transport/ProtobufTransportAddress.java
index aa34a2f0ec99f..79ecce81bb97e 100644
--- a/server/src/main/java/org/opensearch/common/transport/ProtobufTransportAddress.java
+++ b/server/src/main/java/org/opensearch/common/transport/ProtobufTransportAddress.java
@@ -25,7 +25,7 @@
 import java.net.InetSocketAddress;
 import java.net.UnknownHostException;
 
-/**
+/** not used
  * A transport address used for IP socket address (wraps {@link java.net.InetSocketAddress}).
 *
 * @opensearch.internal
diff --git a/server/src/main/java/org/opensearch/common/transport/TransportAddress.java b/server/src/main/java/org/opensearch/common/transport/TransportAddress.java
index 737e8f3496143..f19d83e5b1f7b 100644
--- a/server/src/main/java/org/opensearch/common/transport/TransportAddress.java
+++ b/server/src/main/java/org/opensearch/common/transport/TransportAddress.java
@@ -32,13 +32,18 @@
 
 package org.opensearch.common.transport;
 
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.common.network.NetworkAddress;
+import org.opensearch.core.xcontent.ToXContent.Params;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
@@ -49,7 +54,7 @@
  *
  * @opensearch.internal
  */
-public final class TransportAddress implements Writeable, ToXContentFragment {
+public final class TransportAddress implements Writeable, ProtobufWriteable, ToXContentFragment {
 
     /**
      * A <a href="https://en.wikipedia.org/wiki/0.0.0.0">non-routeable v4 meta transport address</a> that can be used for
@@ -106,6 +111,31 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeInt(address.getPort());
     }
 
+    /**
+     * Read from a stream.
+     */
+    public TransportAddress(CodedInputStream in) throws IOException {
+        final int len = in.readRawByte();
+        final byte[] a = new byte[len]; // 4 bytes (IPv4) or 16 bytes (IPv6)
+        in.readRawBytes(len);
+        String host = in.readString(); // the host string was serialized so we can ignore the passed in version
+        final InetAddress inetAddress = InetAddress.getByAddress(host, a);
+        int port = in.readInt32();
+        this.address = new InetSocketAddress(inetAddress, port);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        byte[] bytes = address.getAddress().getAddress();  // 4 bytes (IPv4) or 16 bytes (IPv6)
+        out.write((byte) bytes.length); // 1 byte
+        out.write(bytes, 0, bytes.length);
+        out.writeStringNoTag(address.getHostString());
+        // don't serialize scope ids over the network!!!!
+        // these only make sense with respect to the local machine, and will only formulate
+        // the address incorrectly remotely.
+        out.writeInt32NoTag(address.getPort());
+    }
+
     /**
      * Returns a string representation of the enclosed {@link InetSocketAddress}
      * @see NetworkAddress#format(InetAddress)
diff --git a/server/src/main/java/org/opensearch/discovery/PeerFinder.java b/server/src/main/java/org/opensearch/discovery/PeerFinder.java
index 96556d1cd71ed..873abf690feb6 100644
--- a/server/src/main/java/org/opensearch/discovery/PeerFinder.java
+++ b/server/src/main/java/org/opensearch/discovery/PeerFinder.java
@@ -32,6 +32,8 @@
 
 package org.opensearch.discovery;
 
+import com.google.protobuf.CodedInputStream;
+
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
@@ -48,6 +50,7 @@
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
 import org.opensearch.threadpool.ThreadPool.Names;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequestOptions;
 import org.opensearch.transport.TransportResponseHandler;
@@ -504,6 +507,18 @@ public void handleException(TransportException exp) {
                 public String executor() {
                     return Names.GENERIC;
                 }
+
+                @Override
+                public PeersResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             };
             transportService.sendRequest(
                 discoveryNode,
diff --git a/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java b/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
index 468de4238f879..f0b082fb29b37 100644
--- a/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
+++ b/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
@@ -51,10 +51,14 @@
 import org.opensearch.extensions.settings.RegisterCustomSettingsRequest;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ConnectTransportException;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
+
+import com.google.protobuf.CodedInputStream;
+
 import org.opensearch.env.EnvironmentSettingsResponse;
 
 /**
@@ -369,6 +373,18 @@ public void handleException(TransportException exp) {
             public String executor() {
                 return ThreadPool.Names.GENERIC;
             }
+
+            @Override
+            public InitializeExtensionResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         };
 
         logger.info("Sending extension request type: " + REQUEST_EXTENSION_ACTION_NAME);
diff --git a/server/src/main/java/org/opensearch/extensions/UpdateSettingsResponseHandler.java b/server/src/main/java/org/opensearch/extensions/UpdateSettingsResponseHandler.java
index bc6f6f0d688f5..fdca909949c67 100644
--- a/server/src/main/java/org/opensearch/extensions/UpdateSettingsResponseHandler.java
+++ b/server/src/main/java/org/opensearch/extensions/UpdateSettingsResponseHandler.java
@@ -14,9 +14,12 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 
+import com.google.protobuf.CodedInputStream;
+
 /**
  * Response handler for {@link UpdateSettingsRequest}
  *
@@ -47,4 +50,16 @@ public void handleException(TransportException exp) {
     public String executor() {
         return ThreadPool.Names.GENERIC;
     }
+
+    @Override
+    public AcknowledgedResponse read(CodedInputStream in) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'read'");
+    }
+
+    @Override
+    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java b/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java
index 22502509634c6..ed912c069db76 100644
--- a/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java
+++ b/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java
@@ -21,11 +21,14 @@
 import org.opensearch.extensions.ExtensionsManager;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ActionNotFoundTransportException;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
@@ -219,6 +222,18 @@ public void handleException(TransportException exp) {
                 public String executor() {
                     return ThreadPool.Names.GENERIC;
                 }
+
+                @Override
+                public ExtensionActionResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             };
         try {
             transportService.sendRequest(
@@ -283,6 +298,18 @@ public void handleException(TransportException exp) {
                 public String executor() {
                     return ThreadPool.Names.GENERIC;
                 }
+
+                @Override
+                public RemoteExtensionActionResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             };
         try {
             transportService.sendRequest(
diff --git a/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java b/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java
index a96e87b0200cc..eb168c0736860 100644
--- a/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java
+++ b/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java
@@ -24,9 +24,13 @@
 import org.opensearch.rest.RestRequest.Method;
 import org.opensearch.core.rest.RestStatus;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
+
+import com.google.protobuf.CodedInputStream;
+
 import org.opensearch.http.HttpRequest;
 
 import java.io.IOException;
@@ -237,6 +241,18 @@ public void handleException(TransportException exp) {
             public String executor() {
                 return ThreadPool.Names.GENERIC;
             }
+
+            @Override
+            public RestExecuteOnExtensionResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         };
 
         try {
diff --git a/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java b/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java
index f82f380f5858b..90d4e7362d677 100644
--- a/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java
+++ b/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java
@@ -47,7 +47,7 @@
 import org.opensearch.common.transport.NetworkExceptionHelper;
 import org.opensearch.common.transport.PortsRange;
 import org.opensearch.common.transport.ProtobufBoundTransportAddress;
-import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.common.util.BigArrays;
@@ -165,15 +165,15 @@ public ProtobufHttpInfo protobufInfo() {
         }
         TransportAddress[] transportAddress = boundTransportAddress.boundAddresses();
         TransportAddress publishAddress = boundTransportAddress.publishAddress();
-        ProtobufTransportAddress[] protobufTransportAddresses = new ProtobufTransportAddress[transportAddress.length];
-        for (int i = 0; i < transportAddress.length; i++) {
-            protobufTransportAddresses[i] = new ProtobufTransportAddress(transportAddress[i].address());
-        }
-        ProtobufBoundTransportAddress protobufBoundTransportAddress = new ProtobufBoundTransportAddress(
-            protobufTransportAddresses,
-            new ProtobufTransportAddress(publishAddress.address())
-        );
-        return new ProtobufHttpInfo(protobufBoundTransportAddress, maxContentLength.getBytes());
+        // TransportAddress[] protobufTransportAddresses = new TransportAddress[transportAddress.length];
+        // for (int i = 0; i < transportAddress.length; i++) {
+        //     protobufTransportAddresses[i] = new TransportAddress(transportAddress[i].address());
+        // }
+        // ProtobufBoundTransportAddress protobufBoundTransportAddress = new ProtobufBoundTransportAddress(
+        //     protobufTransportAddresses,
+        //     new TransportAddress(publishAddress.address())
+        // );
+        return new ProtobufHttpInfo(boundTransportAddress, maxContentLength.getBytes());
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/http/ProtobufHttpInfo.java b/server/src/main/java/org/opensearch/http/ProtobufHttpInfo.java
index fb893000f68ff..1fe3472a28444 100644
--- a/server/src/main/java/org/opensearch/http/ProtobufHttpInfo.java
+++ b/server/src/main/java/org/opensearch/http/ProtobufHttpInfo.java
@@ -18,8 +18,8 @@
 
 import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.network.InetAddresses;
-import org.opensearch.common.transport.ProtobufBoundTransportAddress;
-import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.unit.ByteSizeValue;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.node.ProtobufReportingService;
@@ -38,14 +38,14 @@ public class ProtobufHttpInfo implements ProtobufReportingService.ProtobufInfo {
     /** Deprecated property, just here for deprecation logging in 7.x. */
     private static final boolean CNAME_IN_PUBLISH_HOST = System.getProperty("opensearch.http.cname_in_publish_address") != null;
 
-    private final ProtobufBoundTransportAddress address;
+    private final BoundTransportAddress address;
     private final long maxContentLength;
 
     public ProtobufHttpInfo(CodedInputStream in) throws IOException {
-        this(new ProtobufBoundTransportAddress(in), in.readInt64());
+        this(new BoundTransportAddress(in), in.readInt64());
     }
 
-    public ProtobufHttpInfo(ProtobufBoundTransportAddress address, long maxContentLength) {
+    public ProtobufHttpInfo(BoundTransportAddress address, long maxContentLength) {
         this.address = address;
         this.maxContentLength = maxContentLength;
     }
@@ -56,11 +56,11 @@ public void writeTo(CodedOutputStream out) throws IOException {
         out.writeInt64NoTag(maxContentLength);
     }
 
-    public ProtobufBoundTransportAddress address() {
+    public BoundTransportAddress address() {
         return address;
     }
 
-    public ProtobufBoundTransportAddress getAddress() {
+    public BoundTransportAddress getAddress() {
         return address();
     }
 
@@ -84,7 +84,7 @@ static final class Fields {
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
         builder.startObject(Fields.HTTP);
         builder.array(Fields.BOUND_ADDRESS, (Object[]) address.boundAddresses());
-        ProtobufTransportAddress publishAddress = address.publishAddress();
+        TransportAddress publishAddress = address.publishAddress();
         String publishAddressString = publishAddress.toString();
         String hostString = publishAddress.address().getHostString();
         if (CNAME_IN_PUBLISH_HOST) {
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java
index ec8d44846e30e..26d6b22524c8a 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java
@@ -60,10 +60,13 @@
 import org.opensearch.tasks.Task;
 import org.opensearch.tasks.TaskId;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.Map;
 import java.util.Objects;
@@ -167,6 +170,18 @@ public void handleException(TransportException e) {
                         }
                         getLogger().warn(new ParameterizedMessage("{} retention lease background sync failed", shardId), e);
                     }
+
+                    @Override
+                    public ReplicationResponse read(CodedInputStream in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
+
+                    @Override
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                    }
                 }
             );
         }
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java
index 0c50f9b06b2af..5e0d0801bb74b 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java
@@ -63,10 +63,13 @@
 import org.opensearch.tasks.Task;
 import org.opensearch.tasks.TaskId;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.Map;
 import java.util.Objects;
@@ -175,6 +178,18 @@ public void handleException(TransportException e) {
                         taskManager.unregister(task);
                         listener.onFailure(e);
                     }
+
+                    @Override
+                    public ReplicationResponse read(CodedInputStream in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
+
+                    @Override
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                    }
                 }
             );
         }
diff --git a/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java b/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
index 386b2e0e8192d..03659e98bb076 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
@@ -70,6 +70,7 @@
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ConnectTransportException;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
@@ -78,6 +79,8 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
@@ -748,5 +751,17 @@ public String executor() {
         public RecoveryResponse read(StreamInput in) throws IOException {
             return new RecoveryResponse(in);
         }
+
+        @Override
+        public RecoveryResponse read(CodedInputStream in) throws IOException {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'read'");
+        }
+
+        @Override
+        public void handleExceptionProtobuf(ProtobufTransportException exp) {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+        }
     }
 }
diff --git a/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java b/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
index e77f9e12212fc..6bf319b5246b8 100644
--- a/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
+++ b/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
@@ -34,10 +34,13 @@
 import org.opensearch.node.NodeClosedException;
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.Objects;
 
@@ -172,6 +175,18 @@ public void handleException(TransportException e) {
                             e
                         );
                     }
+
+                    @Override
+                    public ReplicationResponse read(CodedInputStream in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
+
+                    @Override
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                    }
                 }
             );
             logger.trace(
diff --git a/server/src/main/java/org/opensearch/indices/store/IndicesStore.java b/server/src/main/java/org/opensearch/indices/store/IndicesStore.java
index eaaf5198fba94..d4aca6a79b0f3 100644
--- a/server/src/main/java/org/opensearch/indices/store/IndicesStore.java
+++ b/server/src/main/java/org/opensearch/indices/store/IndicesStore.java
@@ -65,6 +65,7 @@
 import org.opensearch.indices.IndicesService;
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
@@ -73,6 +74,8 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.Closeable;
 import java.io.IOException;
 import java.util.ArrayList;
@@ -352,6 +355,18 @@ private void allNodesResponded() {
                 );
         }
 
+        @Override
+        public ShardActiveResponse read(CodedInputStream in) throws IOException {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'read'");
+        }
+
+        @Override
+        public void handleExceptionProtobuf(ProtobufTransportException exp) {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+        }
+
     }
 
     private class ShardActiveRequestHandler implements TransportRequestHandler<ShardActiveRequest> {
diff --git a/server/src/main/java/org/opensearch/node/Node.java b/server/src/main/java/org/opensearch/node/Node.java
index e9f39215fbf98..e6704f118ffff 100644
--- a/server/src/main/java/org/opensearch/node/Node.java
+++ b/server/src/main/java/org/opensearch/node/Node.java
@@ -143,7 +143,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.settings.SettingsModule;
 import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+import org.opensearch.common.transport.BoundTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.BigArrays;
@@ -235,8 +235,8 @@
 import org.opensearch.tasks.TaskResultsService;
 import org.opensearch.threadpool.ExecutorBuilder;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportInterceptor;
-import org.opensearch.transport.ProtobufTransportService;
+// import org.opensearch.transport.ProtobufTransportInterceptor;
+// import org.opensearch.transport.ProtobufTransportService;
 import org.opensearch.transport.RemoteClusterService;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportInterceptor;
@@ -856,7 +856,7 @@ protected Node(
             ActionModule protobufActionModule = new ActionModule(
                 settings,
                 clusterModule.getIndexNameExpressionResolver(),
-                clusterModule.getProtobufIndexNameExpressionResolver(),
+                // clusterModule.getProtobufIndexNameExpressionResolver(),
                 settingsModule.getIndexScopedSettings(),
                 settingsModule.getClusterSettings(),
                 settingsModule.getSettingsFilter(),
@@ -918,15 +918,15 @@ protected Node(
                 settingsModule.getClusterSettings(),
                 taskHeaders
             );
-            final ProtobufTransportService protobufTransportService = newProtobufTransportService(
-                settings,
-                transport,
-                threadPool,
-                networkModule.getProtobufTransportInterceptor(),
-                protobufLocalNodeFactory,
-                settingsModule.getClusterSettings(),
-                taskHeaders
-            );
+            // final ProtobufTransportService protobufTransportService = newProtobufTransportService(
+            //     settings,
+            //     transport,
+            //     threadPool,
+            //     networkModule.getProtobufTransportInterceptor(),
+            //     protobufLocalNodeFactory,
+            //     settingsModule.getClusterSettings(),
+            //     taskHeaders
+            // );
             TopNSearchTasksLogger taskConsumer = new TopNSearchTasksLogger(settings, settingsModule.getClusterSettings());
             transportService.getTaskManager().registerTaskResourceConsumer(taskConsumer);
             // if (FeatureFlags.isEnabled(FeatureFlags.EXTENSIONS)) {
@@ -1088,7 +1088,7 @@ protected Node(
                 threadPool,
                 protobufMonitorService,
                 discoveryModule.getDiscovery(),
-                protobufTransportService,
+                transportService,
                 indicesService,
                 pluginsService,
                 circuitBreakerService,
@@ -1197,7 +1197,7 @@ protected Node(
                     .toInstance(new SearchPhaseController(namedWriteableRegistry, searchService::aggReduceContextBuilder));
                 b.bind(Transport.class).toInstance(transport);
                 b.bind(TransportService.class).toInstance(transportService);
-                b.bind(ProtobufTransportService.class).toInstance(protobufTransportService);
+                // b.bind(ProtobufTransportService.class).toInstance(protobufTransportService);
                 b.bind(NetworkService.class).toInstance(networkService);
                 b.bind(UpdateHelper.class).toInstance(new UpdateHelper(scriptService));
                 b.bind(MetadataIndexUpgradeService.class).toInstance(metadataIndexUpgradeService);
@@ -1280,7 +1280,7 @@ protected Node(
             protobufClient.initialize(
                 protobufDynamicActionRegistry,
                 () -> clusterService.localNode().getId(),
-                protobufTransportService.getRemoteClusterService(),
+                transportService.getRemoteClusterService(),
                 namedWriteableRegistry
             );
 
@@ -1311,17 +1311,17 @@ protected TransportService newTransportService(
         return new TransportService(settings, transport, threadPool, interceptor, localNodeFactory, clusterSettings, taskHeaders);
     }
 
-    protected ProtobufTransportService newProtobufTransportService(
-        Settings settings,
-        Transport transport,
-        ThreadPool threadPool,
-        ProtobufTransportInterceptor interceptor,
-        Function<ProtobufBoundTransportAddress, DiscoveryNode> localNodeFactory,
-        ClusterSettings clusterSettings,
-        Set<String> taskHeaders
-    ) {
-        return new ProtobufTransportService(settings, transport, threadPool, interceptor, localNodeFactory, clusterSettings, taskHeaders);
-    }
+    // protected ProtobufTransportService newProtobufTransportService(
+    //     Settings settings,
+    //     Transport transport,
+    //     ThreadPool threadPool,
+    //     ProtobufTransportInterceptor interceptor,
+    //     Function<BoundTransportAddress, DiscoveryNode> localNodeFactory,
+    //     ClusterSettings clusterSettings,
+    //     Set<String> taskHeaders
+    // ) {
+    //     return new ProtobufTransportService(settings, transport, threadPool, interceptor, localNodeFactory, clusterSettings, taskHeaders);
+    // }
 
     protected void processRecoverySettings(ClusterSettings clusterSettings, RecoverySettings recoverySettings) {
         // Noop in production, overridden by tests
@@ -1393,24 +1393,24 @@ public Node start() throws NodeValidationException {
         transportService.getTaskManager().setTaskResultsService(injector.getInstance(TaskResultsService.class));
         transportService.getTaskManager().setTaskCancellationService(new TaskCancellationService(transportService));
 
-        ProtobufTransportService protobufTransportService = injector.getInstance(ProtobufTransportService.class);
-        protobufTransportService.getTaskManager().setTaskResultsService(injector.getInstance(TaskResultsService.class));
-        protobufTransportService.getTaskManager().setTaskCancellationService(new ProtobufTaskCancellationService(protobufTransportService));
+        // ProtobufTransportService protobufTransportService = injector.getInstance(ProtobufTransportService.class);
+        // protobufTransportService.getTaskManager().setTaskResultsService(injector.getInstance(TaskResultsService.class));
+        // protobufTransportService.getTaskManager().setTaskCancellationService(new ProtobufTaskCancellationService(protobufTransportService));
 
         TaskResourceTrackingService taskResourceTrackingService = injector.getInstance(TaskResourceTrackingService.class);
         transportService.getTaskManager().setTaskResourceTrackingService(taskResourceTrackingService);
-        protobufTransportService.getTaskManager().setTaskResourceTrackingService(taskResourceTrackingService);
+        // protobufTransportService.getTaskManager().setTaskResourceTrackingService(taskResourceTrackingService);
         runnableTaskListener.set(taskResourceTrackingService);
 
         transportService.start();
         assert localNodeFactory.getNode() != null;
         assert transportService.getLocalNode().equals(localNodeFactory.getNode())
             : "transportService has a different local node than the factory provided";
-        protobufTransportService.start();
-        protobufTransportService.setLocalNode(localNodeFactory.getNode());
+        // protobufTransportService.start();
+        // protobufTransportService.setLocalNode(localNodeFactory.getNode());
         assert localNodeFactory.getNode() != null;
-        assert protobufTransportService.getLocalNode().equals(localNodeFactory.getNode())
-            : "protobufTransportService has a different local node than the factory provided";
+        // assert protobufTransportService.getLocalNode().equals(localNodeFactory.getNode())
+        //     : "protobufTransportService has a different local node than the factory provided";
         injector.getInstance(PeerRecoverySourceService.class).start();
         injector.getInstance(SegmentReplicationSourceService.class).start();
 
@@ -1457,7 +1457,7 @@ public Node start() throws NodeValidationException {
         assert clusterService.localNode().equals(localNodeFactory.getNode())
             : "clusterService has a different local node than the factory provided";
         transportService.acceptIncomingRequests();
-        protobufTransportService.acceptIncomingRequests();
+        // protobufTransportService.acceptIncomingRequests();
         discovery.startInitialJoin();
         final TimeValue initialStateTimeout = DiscoverySettings.INITIAL_STATE_TIMEOUT_SETTING.get(settings());
         configureNodeAndClusterIdStateListener(clusterService);
@@ -1899,7 +1899,7 @@ DiscoveryNode getNode() {
         }
     }
 
-    private static class ProtobufLocalNodeFactory implements Function<ProtobufBoundTransportAddress, DiscoveryNode> {
+    private static class ProtobufLocalNodeFactory implements Function<BoundTransportAddress, DiscoveryNode> {
         private final SetOnce<DiscoveryNode> localNode = new SetOnce<>();
         private final String persistentNodeId;
         private final Settings settings;
@@ -1910,7 +1910,7 @@ private ProtobufLocalNodeFactory(Settings settings, String persistentNodeId) {
         }
 
         @Override
-        public DiscoveryNode apply(ProtobufBoundTransportAddress boundTransportAddress) {
+        public DiscoveryNode apply(BoundTransportAddress boundTransportAddress) {
             localNode.set(
                 DiscoveryNode.createLocal(
                     settings,
diff --git a/server/src/main/java/org/opensearch/node/ProtobufNodeService.java b/server/src/main/java/org/opensearch/node/ProtobufNodeService.java
index 0f0b600881d78..09b78169db755 100644
--- a/server/src/main/java/org/opensearch/node/ProtobufNodeService.java
+++ b/server/src/main/java/org/opensearch/node/ProtobufNodeService.java
@@ -33,7 +33,7 @@
 import org.opensearch.search.backpressure.SearchBackpressureService;
 import org.opensearch.search.pipeline.SearchPipelineService;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportService;
+import org.opensearch.transport.TransportService;
 
 import java.io.Closeable;
 import java.io.IOException;
@@ -48,7 +48,7 @@ public class ProtobufNodeService implements Closeable {
     private final Settings settings;
     private final ThreadPool threadPool;
     private final ProtobufMonitorService monitorService;
-    private final ProtobufTransportService transportService;
+    private final TransportService transportService;
     private final IndicesService indicesService;
     private final PluginsService pluginService;
     private final CircuitBreakerService circuitBreakerService;
@@ -71,7 +71,7 @@ public class ProtobufNodeService implements Closeable {
         ThreadPool threadPool,
         ProtobufMonitorService monitorService,
         Discovery discovery,
-        ProtobufTransportService transportService,
+        TransportService transportService,
         IndicesService indicesService,
         PluginsService pluginService,
         CircuitBreakerService circuitBreakerService,
@@ -199,7 +199,7 @@ public ProtobufNodeStats stats(
             jvm ? monitorService.jvmService().stats() : null,
             threadPool ? this.threadPool.protobufStats() : null,
             fs ? monitorService.fsService().stats() : null,
-            transport ? transportService.stats() : null,
+            transport ? transportService.protobufStats() : null,
             http ? (httpServerTransport == null ? null : httpServerTransport.protobufStats()) : null,
             circuitBreaker ? circuitBreakerService.protobufStats() : null,
             script ? scriptService.protobufStats() : null,
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
index d03185d66dfaa..200a419cac257 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
@@ -24,8 +24,8 @@
 import org.opensearch.common.Table;
 import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.network.NetworkAddress;
-import org.opensearch.common.transport.ProtobufTransportAddress;
-import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.unit.ByteSizeValue;
 import org.opensearch.http.ProtobufHttpInfo;
 import org.opensearch.index.cache.query.ProtobufQueryCacheStats;
@@ -338,6 +338,11 @@ Table buildTable(
         DiscoveryNodes nodes = state.getState().nodes();
         String clusterManagerId = nodes.getClusterManagerNodeId();
         Table table = getTableWithHeader(req);
+        System.out.println("Nodes: " + nodes);
+        System.out.println("clusterManagerId: " + clusterManagerId);
+        System.out.println("state: " + state);
+        System.out.println("nodesInfo: " + nodesInfo);
+        System.out.println("nodesStats: " + nodesStats);
 
         for (DiscoveryNode node : nodes) {
             ProtobufNodeInfo info = nodesInfo.getNodesMap().get(node.getId());
@@ -358,7 +363,7 @@ Table buildTable(
             table.addCell(node.getAddress().address().getPort());
             final ProtobufHttpInfo httpInfo = info == null ? null : info.getInfo(ProtobufHttpInfo.class);
             if (httpInfo != null) {
-                ProtobufTransportAddress transportAddress = httpInfo.getAddress().publishAddress();
+                TransportAddress transportAddress = httpInfo.getAddress().publishAddress();
                 table.addCell(NetworkAddress.format(transportAddress.address()));
             } else {
                 table.addCell("-");
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
index 88ae0dd74c087..2e2d5e8bb24e7 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
@@ -357,7 +357,12 @@ Table buildTable(
         DiscoveryNodes nodes = state.getState().nodes();
         String clusterManagerId = nodes.getClusterManagerNodeId();
         Table table = getTableWithHeader(req);
-
+        System.out.println("Nodes: " + nodes);
+        System.out.println("clusterManagerId: " + clusterManagerId);
+        System.out.println("state: " + state);
+        System.out.println("nodesInfo: " + nodesInfo);
+        System.out.println("nodesStats: " + nodesStats);
+        
         for (DiscoveryNode node : nodes) {
             NodeInfo info = nodesInfo.getNodesMap().get(node.getId());
             NodeStats stats = nodesStats.getNodesMap().get(node.getId());
diff --git a/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java b/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java
index d8f9b8e1b984f..a6aaef912043b 100644
--- a/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java
+++ b/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java
@@ -32,6 +32,8 @@
 
 package org.opensearch.snapshots;
 
+import com.google.protobuf.CodedInputStream;
+
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
@@ -67,6 +69,7 @@
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.Repository;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequestDeduplicator;
 import org.opensearch.transport.TransportResponseHandler;
@@ -601,6 +604,18 @@ public void handleException(TransportException exp) {
                     public String executor() {
                         return ThreadPool.Names.SAME;
                     }
+
+                    @Override
+                    public UpdateIndexShardSnapshotStatusResponse read(CodedInputStream in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
+
+                    @Override
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                    }
                 }
             )
         );
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskAwareRequest.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskAwareRequest.java
index 3ff06c87fb880..a569c1b848240 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskAwareRequest.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskAwareRequest.java
@@ -22,32 +22,32 @@ public interface ProtobufTaskAwareRequest {
     /**
      * Set a reference to task that caused this task to be run.
     */
-    default void setParentTask(String parentTaskNode, long parentTaskId) {
-        setParentTask(new ProtobufTaskId(parentTaskNode, parentTaskId));
+    default void setProtobufParentTask(String parentTaskNode, long parentTaskId) {
+        setProtobufParentTask(new ProtobufTaskId(parentTaskNode, parentTaskId));
     }
 
     /**
      * Set a reference to task that created this request.
     */
-    void setParentTask(ProtobufTaskId taskId);
+    void setProtobufParentTask(ProtobufTaskId taskId);
 
     /**
      * Get a reference to the task that created this request. Implementers should default to
     * {@link ProtobufTaskId#EMPTY_TASK_ID}, meaning "there is no parent".
     */
-    ProtobufTaskId getParentTask();
+    ProtobufTaskId getProtobufParentTask();
 
     /**
      * Returns the task object that should be used to keep track of the processing of the request.
     */
-    default ProtobufTask createTask(long id, String type, String action, ProtobufTaskId parentTaskId, Map<String, String> headers) {
-        return new ProtobufTask(id, type, action, getDescription(), parentTaskId, headers);
+    default ProtobufTask createProtobufTask(long id, String type, String action, ProtobufTaskId parentTaskId, Map<String, String> headers) {
+        return new ProtobufTask(id, type, action, getTaskDescription(), parentTaskId, headers);
     }
 
     /**
      * Returns optional description of the request to be displayed by the task manager
     */
-    default String getDescription() {
+    default String getTaskDescription() {
         return "";
     }
 }
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
index 388a5b3d497b0..9fb17ba385680 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
@@ -21,12 +21,12 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ProtobufEmptyTransportResponseHandler;
-import org.opensearch.transport.ProtobufTransportChannel;
+import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.ProtobufTransportException;
-import org.opensearch.transport.ProtobufTransportRequest;
+import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.ProtobufTransportRequestHandler;
-import org.opensearch.transport.ProtobufTransportResponse;
-import org.opensearch.transport.ProtobufTransportService;
+import org.opensearch.transport.TransportResponse;
+import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
 import java.util.Collection;
@@ -40,13 +40,13 @@
 public class ProtobufTaskCancellationService {
     public static final String BAN_PARENT_ACTION_NAME = "internal:admin/tasks/ban";
     private static final Logger logger = LogManager.getLogger(ProtobufTaskCancellationService.class);
-    private final ProtobufTransportService transportService;
+    private final TransportService transportService;
     private final TaskManager taskManager;
 
-    public ProtobufTaskCancellationService(ProtobufTransportService transportService) {
+    public ProtobufTaskCancellationService(TransportService transportService) {
         this.transportService = transportService;
         this.taskManager = transportService.getTaskManager();
-        transportService.registerRequestHandler(
+        transportService.registerRequestHandlerProtobuf(
             BAN_PARENT_ACTION_NAME,
             ThreadPool.Names.SAME,
             BanParentTaskRequest::new,
@@ -125,13 +125,13 @@ private void setBanOnNodes(
                 banRequest,
                 new ProtobufEmptyTransportResponseHandler(ThreadPool.Names.SAME) {
                     @Override
-                    public void handleResponse(ProtobufTransportResponse.Empty response) {
+                    public void handleResponse(TransportResponse.Empty response) {
                         logger.trace("sent ban for tasks with the parent [{}] to the node [{}]", taskId, node);
                         groupedListener.onResponse(null);
                     }
 
                     @Override
-                    public void handleException(ProtobufTransportException exp) {
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
                         assert ExceptionsHelper.unwrapCause(exp) instanceof OpenSearchSecurityException == false;
                         logger.warn("Cannot send ban for tasks with the parent [{}] to the node [{}]", taskId, node);
                         groupedListener.onFailure(exp);
@@ -153,7 +153,7 @@ private void removeBanOnNodes(ProtobufCancellableTask task, Collection<Discovery
                 request,
                 new ProtobufEmptyTransportResponseHandler(ThreadPool.Names.SAME) {
                     @Override
-                    public void handleException(ProtobufTransportException exp) {
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
                         assert ExceptionsHelper.unwrapCause(exp) instanceof OpenSearchSecurityException == false;
                         logger.info("failed to remove the parent ban for task {} on node {}", request.parentTaskId, node);
                     }
@@ -162,7 +162,7 @@ public void handleException(ProtobufTransportException exp) {
         }
     }
 
-    private static class BanParentTaskRequest extends ProtobufTransportRequest {
+    private static class BanParentTaskRequest extends TransportRequest {
 
         private final ProtobufTaskId parentTaskId;
         private final boolean ban;
@@ -213,7 +213,7 @@ public void writeTo(CodedOutputStream out) throws IOException {
 
     private class BanParentRequestHandler implements ProtobufTransportRequestHandler<BanParentTaskRequest> {
         @Override
-        public void messageReceived(final BanParentTaskRequest request, final ProtobufTransportChannel channel, ProtobufTask task)
+        public void messageReceived(final BanParentTaskRequest request, final TransportChannel channel, ProtobufTask task)
             throws Exception {
             if (request.ban) {
                 logger.debug(
@@ -226,7 +226,7 @@ public void messageReceived(final BanParentTaskRequest request, final ProtobufTr
                 final GroupedActionListener<Void> listener = new GroupedActionListener<>(
                     ActionListener.map(
                         new ProtobufChannelActionListener<>(channel, BAN_PARENT_ACTION_NAME, request),
-                        r -> ProtobufTransportResponse.Empty.INSTANCE
+                        r -> TransportResponse.Empty.INSTANCE
                     ),
                     childTasks.size() + 1
                 );
@@ -237,7 +237,7 @@ public void messageReceived(final BanParentTaskRequest request, final ProtobufTr
             } else {
                 logger.debug("Removing ban for the parent [{}] on the node [{}]", request.parentTaskId, localNodeId());
                 taskManager.removeBanProtobuf(request.parentTaskId);
-                channel.sendResponse(ProtobufTransportResponse.Empty.INSTANCE);
+                channel.sendResponse(TransportResponse.Empty.INSTANCE);
             }
         }
     }
diff --git a/server/src/main/java/org/opensearch/tasks/TaskManager.java b/server/src/main/java/org/opensearch/tasks/TaskManager.java
index ac34c338d0ab6..5f360f0cfe037 100644
--- a/server/src/main/java/org/opensearch/tasks/TaskManager.java
+++ b/server/src/main/java/org/opensearch/tasks/TaskManager.java
@@ -308,9 +308,9 @@ public ProtobufTask registerProtobuf(String type, String action, ProtobufTaskAwa
                 headers.put(key, httpHeader);
             }
         }
-        ProtobufTask task = request.createTask(taskIdGenerator.incrementAndGet(), type, action, request.getParentTask(), headers);
+        ProtobufTask task = request.createProtobufTask(taskIdGenerator.incrementAndGet(), type, action, request.getProtobufParentTask(), headers);
         Objects.requireNonNull(task);
-        assert task.getParentTaskId().equals(request.getParentTask()) : "Request [ " + request + "] didn't preserve it parentTaskId";
+        assert task.getParentTaskId().equals(request.getProtobufParentTask()) : "Request [ " + request + "] didn't preserve it parentTaskId";
         if (logger.isTraceEnabled()) {
             logger.trace("register {} [{}] [{}] [{}]", task.getId(), type, action, task.getDescription());
         }
diff --git a/server/src/main/java/org/opensearch/transport/ClusterConnectionManager.java b/server/src/main/java/org/opensearch/transport/ClusterConnectionManager.java
index 1a4854cfad8db..a392ea78f6c0b 100644
--- a/server/src/main/java/org/opensearch/transport/ClusterConnectionManager.java
+++ b/server/src/main/java/org/opensearch/transport/ClusterConnectionManager.java
@@ -122,6 +122,7 @@ public void connectToNode(
         ConnectionValidator connectionValidator,
         ActionListener<Void> listener
     ) throws ConnectTransportException {
+        System.out.println("Connecting to node");
         ConnectionProfile resolvedProfile = ConnectionProfile.resolveConnectionProfile(connectionProfile, defaultProfile);
         if (node == null) {
             listener.onFailure(new ConnectTransportException(null, "can't connect to a null node"));
@@ -201,6 +202,9 @@ public void connectToNode(
      */
     @Override
     public Transport.Connection getConnection(DiscoveryNode node) {
+        // System.out.println("ClusterConnectionManager.getConnection");
+        // System.out.println("node = " + node);
+        // System.out.println("connectedNodes = " + connectedNodes);
         Transport.Connection connection = connectedNodes.get(node);
         if (connection == null) {
             throw new NodeNotConnectedException(node, "Node not connected");
diff --git a/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java
index 3b97a81faf192..6cfc73d9eb0b5 100644
--- a/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java
+++ b/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java
@@ -32,8 +32,13 @@
 
 package org.opensearch.transport;
 
+import java.io.IOException;
+
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportResponse.Empty;
+
+import com.google.protobuf.CodedInputStream;
 
 /**
  * Handler for empty transport response
@@ -65,4 +70,16 @@ public void handleException(TransportException exp) {}
     public String executor() {
         return executor;
     }
+
+    @Override
+    public Empty read(CodedInputStream in) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'read'");
+    }
+
+    @Override
+    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/transport/InboundHandler.java b/server/src/main/java/org/opensearch/transport/InboundHandler.java
index 8632ad7102bd7..72fd20bf847a1 100644
--- a/server/src/main/java/org/opensearch/transport/InboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/InboundHandler.java
@@ -70,7 +70,7 @@ public class InboundHandler {
     private final Transport.RequestHandlers requestHandlers;
 
     private volatile TransportMessageListener messageListener = TransportMessageListener.NOOP_LISTENER;
-    private volatile ProtobufTransportMessageListener protobufMessageListener = ProtobufTransportMessageListener.NOOP_LISTENER;
+    // private volatile ProtobufTransportMessageListener protobufMessageListener = ProtobufTransportMessageListener.NOOP_LISTENER;
 
     private volatile long slowLogThresholdMs = Long.MAX_VALUE;
 
@@ -100,13 +100,13 @@ void setMessageListener(TransportMessageListener listener) {
         }
     }
 
-    void setProtobufMessageListener(ProtobufTransportMessageListener listener) {
-        if (protobufMessageListener == ProtobufTransportMessageListener.NOOP_LISTENER) {
-            protobufMessageListener = listener;
-        } else {
-            throw new IllegalStateException("Cannot set message listener twice");
-        }
-    }
+    // void setProtobufMessageListener(ProtobufTransportMessageListener listener) {
+    //     if (protobufMessageListener == ProtobufTransportMessageListener.NOOP_LISTENER) {
+    //         protobufMessageListener = listener;
+    //     } else {
+    //         throw new IllegalStateException("Cannot set message listener twice");
+    //     }
+    // }
 
     void setSlowLogThreshold(TimeValue slowLogThreshold) {
         this.slowLogThresholdMs = slowLogThreshold.getMillis();
@@ -138,6 +138,8 @@ private void messageReceived(TcpChannel channel, InboundMessage message, long st
             threadContext.setHeaders(header.getHeaders());
             threadContext.putTransient("_remote_address", remoteAddress);
             if (header.isRequest()) {
+                System.out.println("InboundHandler.messageReceived isRequest");
+                System.out.println("Header: " + header);
                 handleRequest(channel, header, message);
             } else {
                 // Responses do not support short circuiting currently
diff --git a/server/src/main/java/org/opensearch/transport/OutboundHandler.java b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
index a77dad228a626..2160f6546c511 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
@@ -71,7 +71,7 @@ final class OutboundHandler {
     private final ThreadPool threadPool;
     private final BigArrays bigArrays;
     private volatile TransportMessageListener messageListener = TransportMessageListener.NOOP_LISTENER;
-    private volatile ProtobufTransportMessageListener protobufMessageListener = ProtobufTransportMessageListener.NOOP_LISTENER;
+    // private volatile ProtobufTransportMessageListener protobufMessageListener = ProtobufTransportMessageListener.NOOP_LISTENER;
 
     OutboundHandler(
         String nodeName,
@@ -213,13 +213,13 @@ void setMessageListener(TransportMessageListener listener) {
         }
     }
 
-    void setProtobufMessageListener(ProtobufTransportMessageListener listener) {
-        if (protobufMessageListener == ProtobufTransportMessageListener.NOOP_LISTENER) {
-            protobufMessageListener = listener;
-        } else {
-            throw new IllegalStateException("Cannot set message listener twice");
-        }
-    }
+    // void setProtobufMessageListener(ProtobufTransportMessageListener listener) {
+    //     if (protobufMessageListener == ProtobufTransportMessageListener.NOOP_LISTENER) {
+    //         protobufMessageListener = listener;
+    //     } else {
+    //         throw new IllegalStateException("Cannot set message listener twice");
+    //     }
+    // }
 
     /**
      * Internal message serializer
diff --git a/server/src/main/java/org/opensearch/transport/PlainTransportFuture.java b/server/src/main/java/org/opensearch/transport/PlainTransportFuture.java
index 53d71c135a8dd..be9678a391f79 100644
--- a/server/src/main/java/org/opensearch/transport/PlainTransportFuture.java
+++ b/server/src/main/java/org/opensearch/transport/PlainTransportFuture.java
@@ -37,6 +37,8 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.util.concurrent.BaseFuture;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
@@ -124,4 +126,16 @@ public void handleException(TransportException exp) {
     public String toString() {
         return "future(" + handler.toString() + ")";
     }
+
+    @Override
+    public V read(CodedInputStream in) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'read'");
+    }
+
+    @Override
+    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufActionTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufActionTransportException.java
index 495bd02f4b070..a5dcffd4a6861 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufActionTransportException.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufActionTransportException.java
@@ -13,7 +13,7 @@
 
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.common.transport.TransportAddress;
 
 import java.io.IOException;
 
@@ -24,24 +24,24 @@
 */
 public class ProtobufActionTransportException extends ProtobufTransportException {
 
-    private final ProtobufTransportAddress address;
+    private final TransportAddress address;
 
     private final String action;
 
     public ProtobufActionTransportException(CodedInputStream in) throws IOException {
         super(in);
         ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        address = protobufStreamInput.readOptionalWriteable(ProtobufTransportAddress::new);
+        address = protobufStreamInput.readOptionalWriteable(TransportAddress::new);
         action = protobufStreamInput.readOptionalString();
     }
 
-    public ProtobufActionTransportException(String name, ProtobufTransportAddress address, String action, Throwable cause) {
+    public ProtobufActionTransportException(String name, TransportAddress address, String action, Throwable cause) {
         super(buildMessage(name, address, action, null), cause);
         this.address = address;
         this.action = action;
     }
 
-    public ProtobufActionTransportException(String name, ProtobufTransportAddress address, String action, String msg, Throwable cause) {
+    public ProtobufActionTransportException(String name, TransportAddress address, String action, String msg, Throwable cause) {
         super(buildMessage(name, address, action, msg), cause);
         this.address = address;
         this.action = action;
@@ -58,7 +58,7 @@ public void writeTo(CodedOutputStream out) throws IOException {
     /**
      * The target address to invoke the action on.
     */
-    public ProtobufTransportAddress address() {
+    public TransportAddress address() {
         return address;
     }
 
@@ -69,7 +69,7 @@ public String action() {
         return action;
     }
 
-    private static String buildMessage(String name, ProtobufTransportAddress address, String action, String msg) {
+    private static String buildMessage(String name, TransportAddress address, String action, String msg) {
         StringBuilder sb = new StringBuilder();
         if (name != null) {
             sb.append('[').append(name).append(']');
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufBytesTransportRequest.java b/server/src/main/java/org/opensearch/transport/ProtobufBytesTransportRequest.java
index ff684a7909915..7ad1a160e072a 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufBytesTransportRequest.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufBytesTransportRequest.java
@@ -23,7 +23,7 @@
 *
 * @opensearch.internal
 */
-public class ProtobufBytesTransportRequest extends ProtobufTransportRequest {
+public class ProtobufBytesTransportRequest extends TransportRequest {
 
     BytesReference bytes;
     Version version;
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java b/server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java
index 42d5046a9be4c..534d67f243a4f 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java
@@ -1,283 +1,283 @@
-/*
-* 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.
-*/
+// /*
+// * 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.
+// */
 
-package org.opensearch.transport;
+// package org.opensearch.transport;
 
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.opensearch.action.ActionListener;
-import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.util.concurrent.AbstractRefCounted;
-import org.opensearch.common.util.concurrent.ConcurrentCollections;
-import org.opensearch.common.util.concurrent.OpenSearchExecutors;
-import org.opensearch.common.util.concurrent.ListenableFuture;
-import org.opensearch.common.util.concurrent.RunOnce;
-import org.opensearch.common.util.io.IOUtils;
+// import org.apache.logging.log4j.LogManager;
+// import org.apache.logging.log4j.Logger;
+// import org.opensearch.action.ActionListener;
+// import org.opensearch.cluster.node.DiscoveryNode;
+// import org.opensearch.common.settings.Settings;
+// import org.opensearch.common.util.concurrent.AbstractRefCounted;
+// import org.opensearch.common.util.concurrent.ConcurrentCollections;
+// import org.opensearch.common.util.concurrent.OpenSearchExecutors;
+// import org.opensearch.common.util.concurrent.ListenableFuture;
+// import org.opensearch.common.util.concurrent.RunOnce;
+// import org.opensearch.common.util.io.IOUtils;
 
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.atomic.AtomicBoolean;
+// import java.util.Collections;
+// import java.util.Iterator;
+// import java.util.Map;
+// import java.util.Set;
+// import java.util.concurrent.ConcurrentMap;
+// import java.util.concurrent.CountDownLatch;
+// import java.util.concurrent.atomic.AtomicBoolean;
 
-/**
- * This class manages node connections within a cluster. The connection is opened by the underlying transport.
-* Once the connection is opened, this class manages the connection. This includes closing the connection when
-* the connection manager is closed.
-*
-* @opensearch.internal
-*/
-public class ProtobufClusterConnectionManager implements ProtobufConnectionManager {
+// /**
+//  * This class manages node connections within a cluster. The connection is opened by the underlying transport.
+// * Once the connection is opened, this class manages the connection. This includes closing the connection when
+// * the connection manager is closed.
+// *
+// * @opensearch.internal
+// */
+// public class ProtobufClusterConnectionManager implements ConnectionManager {
 
-    private static final Logger logger = LogManager.getLogger(ProtobufClusterConnectionManager.class);
+//     private static final Logger logger = LogManager.getLogger(ProtobufClusterConnectionManager.class);
 
-    private final ConcurrentMap<DiscoveryNode, Transport.ProtobufConnection> connectedNodes = ConcurrentCollections.newConcurrentMap();
-    private final ConcurrentMap<DiscoveryNode, ListenableFuture<Void>> pendingConnections = ConcurrentCollections.newConcurrentMap();
-    private final AbstractRefCounted connectingRefCounter = new AbstractRefCounted("connection manager") {
-        @Override
-        protected void closeInternal() {
-            Iterator<Map.Entry<DiscoveryNode, Transport.ProtobufConnection>> iterator = connectedNodes.entrySet().iterator();
-            while (iterator.hasNext()) {
-                Map.Entry<DiscoveryNode, Transport.ProtobufConnection> next = iterator.next();
-                try {
-                    IOUtils.closeWhileHandlingException(next.getValue());
-                } finally {
-                    iterator.remove();
-                }
-            }
-            closeLatch.countDown();
-        }
-    };
-    private final Transport transport;
-    private final ProtobufConnectionProfile defaultProfile;
-    private final AtomicBoolean closing = new AtomicBoolean(false);
-    private final CountDownLatch closeLatch = new CountDownLatch(1);
-    private final DelegatingNodeConnectionListener connectionListener = new DelegatingNodeConnectionListener();
+//     private final ConcurrentMap<DiscoveryNode, Transport.Connection> connectedNodes = ConcurrentCollections.newConcurrentMap();
+//     private final ConcurrentMap<DiscoveryNode, ListenableFuture<Void>> pendingConnections = ConcurrentCollections.newConcurrentMap();
+//     private final AbstractRefCounted connectingRefCounter = new AbstractRefCounted("connection manager") {
+//         @Override
+//         protected void closeInternal() {
+//             Iterator<Map.Entry<DiscoveryNode, Transport.Connection>> iterator = connectedNodes.entrySet().iterator();
+//             while (iterator.hasNext()) {
+//                 Map.Entry<DiscoveryNode, Transport.Connection> next = iterator.next();
+//                 try {
+//                     IOUtils.closeWhileHandlingException(next.getValue());
+//                 } finally {
+//                     iterator.remove();
+//                 }
+//             }
+//             closeLatch.countDown();
+//         }
+//     };
+//     private final Transport transport;
+//     private final ConnectionProfile defaultProfile;
+//     private final AtomicBoolean closing = new AtomicBoolean(false);
+//     private final CountDownLatch closeLatch = new CountDownLatch(1);
+//     private final DelegatingNodeConnectionListener connectionListener = new DelegatingNodeConnectionListener();
 
-    public ProtobufClusterConnectionManager(Settings settings, Transport transport) {
-        this(ProtobufConnectionProfile.buildDefaultConnectionProfile(settings), transport);
-    }
+//     public ProtobufClusterConnectionManager(Settings settings, Transport transport) {
+//         this(ConnectionProfile.buildDefaultConnectionProfile(settings), transport);
+//     }
 
-    public ProtobufClusterConnectionManager(ProtobufConnectionProfile connectionProfile, Transport transport) {
-        this.transport = transport;
-        this.defaultProfile = connectionProfile;
-    }
+//     public ProtobufClusterConnectionManager(ConnectionProfile connectionProfile, Transport transport) {
+//         this.transport = transport;
+//         this.defaultProfile = connectionProfile;
+//     }
 
-    @Override
-    public void addListener(ProtobufTransportConnectionListener listener) {
-        this.connectionListener.addListener(listener);
-    }
+//     @Override
+//     public void addListener(TransportConnectionListener listener) {
+//         this.connectionListener.addListener(listener);
+//     }
 
-    @Override
-    public void removeListener(ProtobufTransportConnectionListener listener) {
-        this.connectionListener.removeListener(listener);
-    }
+//     @Override
+//     public void removeListener(TransportConnectionListener listener) {
+//         this.connectionListener.removeListener(listener);
+//     }
 
-    @Override
-    public void openConnection(
-        DiscoveryNode node,
-        ProtobufConnectionProfile connectionProfile,
-        ActionListener<Transport.ProtobufConnection> listener
-    ) {
-        ProtobufConnectionProfile resolvedProfile = ProtobufConnectionProfile.resolveConnectionProfile(connectionProfile, defaultProfile);
-        internalOpenConnection(node, resolvedProfile, listener);
-    }
+//     @Override
+//     public void openConnection(
+//         DiscoveryNode node,
+//         ConnectionProfile connectionProfile,
+//         ActionListener<Transport.Connection> listener
+//     ) {
+//         ConnectionProfile resolvedProfile = ConnectionProfile.resolveConnectionProfile(connectionProfile, defaultProfile);
+//         internalOpenConnection(node, resolvedProfile, listener);
+//     }
 
-    /**
-     * Connects to a node with the given connection profile. If the node is already connected this method has no effect.
-    * Once a successful is established, it can be validated before being exposed.
-    * The ActionListener will be called on the calling thread or the generic thread pool.
-    */
-    @Override
-    public void connectToNode(
-        DiscoveryNode node,
-        ProtobufConnectionProfile connectionProfile,
-        ConnectionValidator connectionValidator,
-        ActionListener<Void> listener
-    ) throws ProtobufConnectTransportException {
-        ProtobufConnectionProfile resolvedProfile = ProtobufConnectionProfile.resolveConnectionProfile(connectionProfile, defaultProfile);
-        if (node == null) {
-            listener.onFailure(new ProtobufConnectTransportException(null, "can't connect to a null node"));
-            return;
-        }
+//     /**
+//      * Connects to a node with the given connection profile. If the node is already connected this method has no effect.
+//     * Once a successful is established, it can be validated before being exposed.
+//     * The ActionListener will be called on the calling thread or the generic thread pool.
+//     */
+//     @Override
+//     public void connectToNode(
+//         DiscoveryNode node,
+//         ConnectionProfile connectionProfile,
+//         ConnectionValidator connectionValidator,
+//         ActionListener<Void> listener
+//     ) throws ProtobufConnectTransportException {
+//         ConnectionProfile resolvedProfile = ConnectionProfile.resolveConnectionProfile(connectionProfile, defaultProfile);
+//         if (node == null) {
+//             listener.onFailure(new ProtobufConnectTransportException(null, "can't connect to a null node"));
+//             return;
+//         }
 
-        if (connectingRefCounter.tryIncRef() == false) {
-            listener.onFailure(new IllegalStateException("connection manager is closed"));
-            return;
-        }
+//         if (connectingRefCounter.tryIncRef() == false) {
+//             listener.onFailure(new IllegalStateException("connection manager is closed"));
+//             return;
+//         }
 
-        if (connectedNodes.containsKey(node)) {
-            connectingRefCounter.decRef();
-            listener.onResponse(null);
-            return;
-        }
+//         if (connectedNodes.containsKey(node)) {
+//             connectingRefCounter.decRef();
+//             listener.onResponse(null);
+//             return;
+//         }
 
-        final ListenableFuture<Void> currentListener = new ListenableFuture<>();
-        final ListenableFuture<Void> existingListener = pendingConnections.putIfAbsent(node, currentListener);
-        if (existingListener != null) {
-            try {
-                // wait on previous entry to complete connection attempt
-                existingListener.addListener(listener, OpenSearchExecutors.newDirectExecutorService());
-            } finally {
-                connectingRefCounter.decRef();
-            }
-            return;
-        }
+//         final ListenableFuture<Void> currentListener = new ListenableFuture<>();
+//         final ListenableFuture<Void> existingListener = pendingConnections.putIfAbsent(node, currentListener);
+//         if (existingListener != null) {
+//             try {
+//                 // wait on previous entry to complete connection attempt
+//                 existingListener.addListener(listener, OpenSearchExecutors.newDirectExecutorService());
+//             } finally {
+//                 connectingRefCounter.decRef();
+//             }
+//             return;
+//         }
 
-        currentListener.addListener(listener, OpenSearchExecutors.newDirectExecutorService());
+//         currentListener.addListener(listener, OpenSearchExecutors.newDirectExecutorService());
 
-        final RunOnce releaseOnce = new RunOnce(connectingRefCounter::decRef);
-        internalOpenConnection(node, resolvedProfile, ActionListener.wrap(conn -> {
-            connectionValidator.validate(conn, resolvedProfile, ActionListener.wrap(ignored -> {
-                assert Transports.assertNotTransportThread("connection validator success");
-                try {
-                    if (connectedNodes.putIfAbsent(node, conn) != null) {
-                        logger.debug("existing connection to node [{}], closing new redundant connection", node);
-                        IOUtils.closeWhileHandlingException(conn);
-                    } else {
-                        logger.debug("connected to node [{}]", node);
-                        try {
-                            connectionListener.onNodeConnected(node, conn);
-                        } finally {
-                            final Transport.ProtobufConnection finalConnection = conn;
-                            conn.addCloseListener(ActionListener.wrap(() -> {
-                                logger.trace("unregistering {} after connection close and marking as disconnected", node);
-                                connectedNodes.remove(node, finalConnection);
-                                connectionListener.onNodeDisconnected(node, conn);
-                            }));
-                        }
-                    }
-                } finally {
-                    ListenableFuture<Void> future = pendingConnections.remove(node);
-                    assert future == currentListener : "Listener in pending map is different than the expected listener";
-                    releaseOnce.run();
-                    future.onResponse(null);
-                }
-            }, e -> {
-                assert Transports.assertNotTransportThread("connection validator failure");
-                IOUtils.closeWhileHandlingException(conn);
-                failConnectionListeners(node, releaseOnce, e, currentListener);
-            }));
-        }, e -> {
-            assert Transports.assertNotTransportThread("internalOpenConnection failure");
-            failConnectionListeners(node, releaseOnce, e, currentListener);
-        }));
-    }
+//         final RunOnce releaseOnce = new RunOnce(connectingRefCounter::decRef);
+//         internalOpenConnection(node, resolvedProfile, ActionListener.wrap(conn -> {
+//             connectionValidator.validate(conn, resolvedProfile, ActionListener.wrap(ignored -> {
+//                 assert Transports.assertNotTransportThread("connection validator success");
+//                 try {
+//                     if (connectedNodes.putIfAbsent(node, conn) != null) {
+//                         logger.debug("existing connection to node [{}], closing new redundant connection", node);
+//                         IOUtils.closeWhileHandlingException(conn);
+//                     } else {
+//                         logger.debug("connected to node [{}]", node);
+//                         try {
+//                             connectionListener.onNodeConnected(node, conn);
+//                         } finally {
+//                             final Transport.Connection finalConnection = conn;
+//                             conn.addCloseListener(ActionListener.wrap(() -> {
+//                                 logger.trace("unregistering {} after connection close and marking as disconnected", node);
+//                                 connectedNodes.remove(node, finalConnection);
+//                                 connectionListener.onNodeDisconnected(node, conn);
+//                             }));
+//                         }
+//                     }
+//                 } finally {
+//                     ListenableFuture<Void> future = pendingConnections.remove(node);
+//                     assert future == currentListener : "Listener in pending map is different than the expected listener";
+//                     releaseOnce.run();
+//                     future.onResponse(null);
+//                 }
+//             }, e -> {
+//                 assert Transports.assertNotTransportThread("connection validator failure");
+//                 IOUtils.closeWhileHandlingException(conn);
+//                 failConnectionListeners(node, releaseOnce, e, currentListener);
+//             }));
+//         }, e -> {
+//             assert Transports.assertNotTransportThread("internalOpenConnection failure");
+//             failConnectionListeners(node, releaseOnce, e, currentListener);
+//         }));
+//     }
 
-    /**
-     * Returns a connection for the given node if the node is connected.
-    * Connections returned from this method must not be closed. The lifecycle of this connection is
-    * maintained by this connection manager
-    *
-    * @throws ProtobufNodeNotConnectedException if the node is not connected
-    * @see #connectToNode(DiscoveryNode, ProtobufConnectionProfile, ConnectionValidator, ActionListener)
-    */
-    @Override
-    public Transport.ProtobufConnection getConnection(DiscoveryNode node) {
-        Transport.ProtobufConnection connection = connectedNodes.get(node);
-        if (connection == null) {
-            throw new ProtobufNodeNotConnectedException(node, "Node not connected");
-        }
-        return connection;
-    }
+//     /**
+//      * Returns a connection for the given node if the node is connected.
+//     * Connections returned from this method must not be closed. The lifecycle of this connection is
+//     * maintained by this connection manager
+//     *
+//     * @throws ProtobufNodeNotConnectedException if the node is not connected
+//     * @see #connectToNode(DiscoveryNode, ConnectionProfile, ConnectionValidator, ActionListener)
+//     */
+//     @Override
+//     public Transport.Connection getConnection(DiscoveryNode node) {
+//         Transport.Connection connection = connectedNodes.get(node);
+//         if (connection == null) {
+//             throw new ProtobufNodeNotConnectedException(node, "Node not connected");
+//         }
+//         return connection;
+//     }
 
-    /**
-     * Returns {@code true} if the node is connected.
-    */
-    @Override
-    public boolean nodeConnected(DiscoveryNode node) {
-        return connectedNodes.containsKey(node);
-    }
+//     /**
+//      * Returns {@code true} if the node is connected.
+//     */
+//     @Override
+//     public boolean nodeConnected(DiscoveryNode node) {
+//         return connectedNodes.containsKey(node);
+//     }
 
-    /**
-     * Disconnected from the given node, if not connected, will do nothing.
-    */
-    @Override
-    public void disconnectFromNode(DiscoveryNode node) {
-        Transport.ProtobufConnection nodeChannels = connectedNodes.remove(node);
-        if (nodeChannels != null) {
-            // if we found it and removed it we close
-            nodeChannels.close();
-        }
-    }
+//     /**
+//      * Disconnected from the given node, if not connected, will do nothing.
+//     */
+//     @Override
+//     public void disconnectFromNode(DiscoveryNode node) {
+//         Transport.Connection nodeChannels = connectedNodes.remove(node);
+//         if (nodeChannels != null) {
+//             // if we found it and removed it we close
+//             nodeChannels.close();
+//         }
+//     }
 
-    /**
-     * Returns the number of nodes this manager is connected to.
-    */
-    @Override
-    public int size() {
-        return connectedNodes.size();
-    }
+//     /**
+//      * Returns the number of nodes this manager is connected to.
+//     */
+//     @Override
+//     public int size() {
+//         return connectedNodes.size();
+//     }
 
-    @Override
-    public Set<DiscoveryNode> getAllConnectedNodes() {
-        return Collections.unmodifiableSet(connectedNodes.keySet());
-    }
+//     @Override
+//     public Set<DiscoveryNode> getAllConnectedNodes() {
+//         return Collections.unmodifiableSet(connectedNodes.keySet());
+//     }
 
-    @Override
-    public void close() {
-        internalClose(true);
-    }
+//     @Override
+//     public void close() {
+//         internalClose(true);
+//     }
 
-    @Override
-    public void closeNoBlock() {
-        internalClose(false);
-    }
+//     @Override
+//     public void closeNoBlock() {
+//         internalClose(false);
+//     }
 
-    private void internalClose(boolean waitForPendingConnections) {
-        assert Transports.assertNotTransportThread("Closing ProtobufConnectionManager");
-        if (closing.compareAndSet(false, true)) {
-            connectingRefCounter.decRef();
-            if (waitForPendingConnections) {
-                try {
-                    closeLatch.await();
-                } catch (InterruptedException e) {
-                    Thread.currentThread().interrupt();
-                    throw new IllegalStateException(e);
-                }
-            }
-        }
-    }
+//     private void internalClose(boolean waitForPendingConnections) {
+//         assert Transports.assertNotTransportThread("Closing ConnectionManager");
+//         if (closing.compareAndSet(false, true)) {
+//             connectingRefCounter.decRef();
+//             if (waitForPendingConnections) {
+//                 try {
+//                     closeLatch.await();
+//                 } catch (InterruptedException e) {
+//                     Thread.currentThread().interrupt();
+//                     throw new IllegalStateException(e);
+//                 }
+//             }
+//         }
+//     }
 
-    private void internalOpenConnection(
-        DiscoveryNode node,
-        ProtobufConnectionProfile connectionProfile,
-        ActionListener<Transport.ProtobufConnection> listener
-    ) {
-        transport.openProtobufConnection(node, connectionProfile, ActionListener.map(listener, connection -> {
-            assert Transports.assertNotTransportThread("internalOpenConnection success");
-            try {
-                connectionListener.onConnectionOpened(connection);
-            } finally {
-                connection.addCloseListener(ActionListener.wrap(() -> connectionListener.onConnectionClosed(connection)));
-            }
-            if (connection.isClosed()) {
-                throw new ProtobufConnectTransportException(node, "a channel closed while connecting");
-            }
-            return connection;
-        }));
-    }
+//     private void internalOpenConnection(
+//         DiscoveryNode node,
+//         ConnectionProfile connectionProfile,
+//         ActionListener<Transport.Connection> listener
+//     ) {
+//         transport.openConnection(node, connectionProfile, ActionListener.map(listener, connection -> {
+//             assert Transports.assertNotTransportThread("internalOpenConnection success");
+//             try {
+//                 connectionListener.onConnectionOpened(connection);
+//             } finally {
+//                 connection.addCloseListener(ActionListener.wrap(() -> connectionListener.onConnectionClosed(connection)));
+//             }
+//             if (connection.isClosed()) {
+//                 throw new ProtobufConnectTransportException(node, "a channel closed while connecting");
+//             }
+//             return connection;
+//         }));
+//     }
 
-    private void failConnectionListeners(DiscoveryNode node, RunOnce releaseOnce, Exception e, ListenableFuture<Void> expectedListener) {
-        ListenableFuture<Void> future = pendingConnections.remove(node);
-        releaseOnce.run();
-        if (future != null) {
-            assert future == expectedListener : "Listener in pending map is different than the expected listener";
-            future.onFailure(e);
-        }
-    }
+//     private void failConnectionListeners(DiscoveryNode node, RunOnce releaseOnce, Exception e, ListenableFuture<Void> expectedListener) {
+//         ListenableFuture<Void> future = pendingConnections.remove(node);
+//         releaseOnce.run();
+//         if (future != null) {
+//             assert future == expectedListener : "Listener in pending map is different than the expected listener";
+//             future.onFailure(e);
+//         }
+//     }
 
-    @Override
-    public ProtobufConnectionProfile getConnectionProfile() {
-        return defaultProfile;
-    }
+//     @Override
+//     public ConnectionProfile getConnectionProfile() {
+//         return defaultProfile;
+//     }
 
-}
+// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufConnectTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufConnectTransportException.java
index 3a8108db629bf..e05ee7c83ca6d 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufConnectTransportException.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufConnectTransportException.java
@@ -38,7 +38,7 @@ public ProtobufConnectTransportException(DiscoveryNode node, String msg, Throwab
     }
 
     public ProtobufConnectTransportException(DiscoveryNode node, String msg, String action, Throwable cause) {
-        super(node == null ? null : node.getName(), node == null ? null : node.getProtobufAddress(), action, msg, cause);
+        super(node == null ? null : node.getName(), node == null ? null : node.getAddress(), action, msg, cause);
         this.node = node;
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java b/server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java
index d1ed3a6812bed..feea2de175cdb 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java
@@ -15,31 +15,31 @@
 import java.util.Set;
 import java.util.concurrent.CopyOnWriteArrayList;
 
-/**
+/** not used
  * ProtobufTransport connection manager.
 *
 * @opensearch.internal
 */
 public interface ProtobufConnectionManager extends Closeable {
 
-    void addListener(ProtobufTransportConnectionListener listener);
+    void addListener(TransportConnectionListener listener);
 
-    void removeListener(ProtobufTransportConnectionListener listener);
+    void removeListener(TransportConnectionListener listener);
 
     void openConnection(
         DiscoveryNode node,
-        ProtobufConnectionProfile connectionProfile,
-        ActionListener<Transport.ProtobufConnection> listener
+        ConnectionProfile connectionProfile,
+        ActionListener<Transport.Connection> listener
     );
 
     void connectToNode(
         DiscoveryNode node,
-        ProtobufConnectionProfile connectionProfile,
+        ConnectionProfile connectionProfile,
         ConnectionValidator connectionValidator,
         ActionListener<Void> listener
     ) throws ConnectTransportException;
 
-    Transport.ProtobufConnection getConnection(DiscoveryNode node);
+    Transport.Connection getConnection(DiscoveryNode node);
 
     boolean nodeConnected(DiscoveryNode node);
 
@@ -54,7 +54,7 @@ void connectToNode(
 
     void closeNoBlock();
 
-    ProtobufConnectionProfile getConnectionProfile();
+    ConnectionProfile getConnectionProfile();
 
     /**
      * Validates a connection
@@ -63,7 +63,7 @@ void connectToNode(
     */
     @FunctionalInterface
     interface ConnectionValidator {
-        void validate(Transport.ProtobufConnection connection, ProtobufConnectionProfile profile, ActionListener<Void> listener);
+        void validate(Transport.Connection connection, ConnectionProfile profile, ActionListener<Void> listener);
     }
 
     /**
@@ -71,43 +71,43 @@ interface ConnectionValidator {
     *
     * @opensearch.internal
     */
-    final class DelegatingNodeConnectionListener implements ProtobufTransportConnectionListener {
+    final class DelegatingNodeConnectionListener implements TransportConnectionListener {
 
-        private final CopyOnWriteArrayList<ProtobufTransportConnectionListener> listeners = new CopyOnWriteArrayList<>();
+        private final CopyOnWriteArrayList<TransportConnectionListener> listeners = new CopyOnWriteArrayList<>();
 
         @Override
-        public void onNodeDisconnected(DiscoveryNode key, Transport.ProtobufConnection connection) {
-            for (ProtobufTransportConnectionListener listener : listeners) {
+        public void onNodeDisconnected(DiscoveryNode key, Transport.Connection connection) {
+            for (TransportConnectionListener listener : listeners) {
                 listener.onNodeDisconnected(key, connection);
             }
         }
 
         @Override
-        public void onNodeConnected(DiscoveryNode node, Transport.ProtobufConnection connection) {
-            for (ProtobufTransportConnectionListener listener : listeners) {
+        public void onNodeConnected(DiscoveryNode node, Transport.Connection connection) {
+            for (TransportConnectionListener listener : listeners) {
                 listener.onNodeConnected(node, connection);
             }
         }
 
         @Override
-        public void onConnectionOpened(Transport.ProtobufConnection connection) {
-            for (ProtobufTransportConnectionListener listener : listeners) {
+        public void onConnectionOpened(Transport.Connection connection) {
+            for (TransportConnectionListener listener : listeners) {
                 listener.onConnectionOpened(connection);
             }
         }
 
         @Override
-        public void onConnectionClosed(Transport.ProtobufConnection connection) {
-            for (ProtobufTransportConnectionListener listener : listeners) {
+        public void onConnectionClosed(Transport.Connection connection) {
+            for (TransportConnectionListener listener : listeners) {
                 listener.onConnectionClosed(connection);
             }
         }
 
-        public void addListener(ProtobufTransportConnectionListener listener) {
+        public void addListener(TransportConnectionListener listener) {
             listeners.addIfAbsent(listener);
         }
 
-        public void removeListener(ProtobufTransportConnectionListener listener) {
+        public void removeListener(TransportConnectionListener listener) {
             listeners.remove(listener);
         }
     }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufConnectionProfile.java b/server/src/main/java/org/opensearch/transport/ProtobufConnectionProfile.java
index db39394a4e94c..20919b8cf5aca 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufConnectionProfile.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufConnectionProfile.java
@@ -22,7 +22,7 @@
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
 
-/**
+/** not used
  * A connection profile describes how many connection are established to specific node for each of the available request types.
 * ({@link org.opensearch.transport.TransportRequestOptions.Type}). This allows to tailor a connection towards a specific usage.
 *
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java
index 53286266bb015..71090200fb053 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java
@@ -9,14 +9,19 @@
 package org.opensearch.transport;
 
 import com.google.protobuf.CodedInputStream;
+
+import java.io.IOException;
+
+import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportResponse.Empty;
 
 /**
  * Handler for empty transport response
 *
 * @opensearch.internal
 */
-public class ProtobufEmptyTransportResponseHandler implements ProtobufTransportResponseHandler<ProtobufTransportResponse.Empty> {
+public class ProtobufEmptyTransportResponseHandler implements TransportResponseHandler<TransportResponse.Empty> {
 
     public static final ProtobufEmptyTransportResponseHandler INSTANCE_SAME = new ProtobufEmptyTransportResponseHandler(
         ThreadPool.Names.SAME
@@ -29,18 +34,30 @@ public ProtobufEmptyTransportResponseHandler(String executor) {
     }
 
     @Override
-    public ProtobufTransportResponse.Empty read(CodedInputStream in) {
-        return ProtobufTransportResponse.Empty.INSTANCE;
+    public TransportResponse.Empty read(CodedInputStream in) {
+        return TransportResponse.Empty.INSTANCE;
     }
 
     @Override
-    public void handleResponse(ProtobufTransportResponse.Empty response) {}
+    public void handleResponse(TransportResponse.Empty response) {}
 
     @Override
-    public void handleException(ProtobufTransportException exp) {}
+    public void handleExceptionProtobuf(ProtobufTransportException exp) {}
 
     @Override
     public String executor() {
         return executor;
     }
+
+    @Override
+    public Empty read(StreamInput in) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'read'");
+    }
+
+    @Override
+    public void handleException(TransportException exp) {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'handleException'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java b/server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java
index 63e108b044831..2106a46737923 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java
@@ -1,281 +1,281 @@
-/*
-* 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.
-*/
+// /*
+// * 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.
+// */
 
-package org.opensearch.transport;
+// package org.opensearch.transport;
 
-import com.google.protobuf.CodedOutputStream;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.message.ParameterizedMessage;
-import org.opensearch.Version;
-import org.opensearch.action.ActionListener;
-import org.opensearch.action.NotifyOnceListener;
-import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.common.CheckedSupplier;
-import org.opensearch.common.bytes.BytesReference;
-import org.opensearch.common.lease.Releasable;
-import org.opensearch.common.lease.Releasables;
-import org.opensearch.common.network.CloseableChannel;
-import org.opensearch.common.transport.NetworkExceptionHelper;
-import org.opensearch.common.transport.ProtobufTransportAddress;
-import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.threadpool.ThreadPool;
+// import com.google.protobuf.CodedOutputStream;
+// import org.apache.logging.log4j.LogManager;
+// import org.apache.logging.log4j.Logger;
+// import org.apache.logging.log4j.message.ParameterizedMessage;
+// import org.opensearch.Version;
+// import org.opensearch.action.ActionListener;
+// import org.opensearch.action.NotifyOnceListener;
+// import org.opensearch.cluster.node.DiscoveryNode;
+// import org.opensearch.common.CheckedSupplier;
+// import org.opensearch.common.bytes.BytesReference;
+// import org.opensearch.common.lease.Releasable;
+// import org.opensearch.common.lease.Releasables;
+// import org.opensearch.common.network.CloseableChannel;
+// import org.opensearch.common.transport.NetworkExceptionHelper;
+// import org.opensearch.common.transport.TransportAddress;
+// import org.opensearch.common.util.concurrent.ThreadContext;
+// import org.opensearch.threadpool.ThreadPool;
 
-import java.io.IOException;
-import java.util.Set;
+// import java.io.IOException;
+// import java.util.Set;
 
-/**
- * Outbound data handler
-*
-* @opensearch.internal
-*/
-final class ProtobufOutboundHandler {
+// /**
+//  * Outbound data handler
+// *
+// * @opensearch.internal
+// */
+// final class ProtobufOutboundHandler {
 
-    private static final Logger logger = LogManager.getLogger(ProtobufOutboundHandler.class);
+//     private static final Logger logger = LogManager.getLogger(ProtobufOutboundHandler.class);
 
-    private final String nodeName;
-    private final Version version;
-    private final String[] features;
-    private final StatsTracker statsTracker;
-    private final ThreadPool threadPool;
-    // private final BigArrays bigArrays;
-    private final byte[] bytes;
-    private volatile ProtobufTransportMessageListener messageListener = ProtobufTransportMessageListener.NOOP_LISTENER;
+//     private final String nodeName;
+//     private final Version version;
+//     private final String[] features;
+//     private final StatsTracker statsTracker;
+//     private final ThreadPool threadPool;
+//     // private final BigArrays bigArrays;
+//     private final byte[] bytes;
+//     private volatile ProtobufTransportMessageListener messageListener = ProtobufTransportMessageListener.NOOP_LISTENER;
 
-    ProtobufOutboundHandler(
-        String nodeName,
-        Version version,
-        String[] features,
-        StatsTracker statsTracker,
-        ThreadPool threadPool,
-        byte[] bytes
-    ) {
-        this.nodeName = nodeName;
-        this.version = version;
-        this.features = features;
-        this.statsTracker = statsTracker;
-        this.threadPool = threadPool;
-        this.bytes = bytes;
-    }
+//     ProtobufOutboundHandler(
+//         String nodeName,
+//         Version version,
+//         String[] features,
+//         StatsTracker statsTracker,
+//         ThreadPool threadPool,
+//         byte[] bytes
+//     ) {
+//         this.nodeName = nodeName;
+//         this.version = version;
+//         this.features = features;
+//         this.statsTracker = statsTracker;
+//         this.threadPool = threadPool;
+//         this.bytes = bytes;
+//     }
 
-    void sendBytes(TcpChannel channel, BytesReference bytes, ActionListener<Void> listener) {
-        SendContext sendContext = new SendContext(channel, () -> bytes, listener);
-        try {
-            internalSend(channel, sendContext);
-        } catch (IOException e) {
-            // This should not happen as the bytes are already serialized
-            throw new AssertionError(e);
-        }
-    }
+//     void sendBytes(TcpChannel channel, BytesReference bytes, ActionListener<Void> listener) {
+//         SendContext sendContext = new SendContext(channel, () -> bytes, listener);
+//         try {
+//             internalSend(channel, sendContext);
+//         } catch (IOException e) {
+//             // This should not happen as the bytes are already serialized
+//             throw new AssertionError(e);
+//         }
+//     }
 
-    /**
-     * Sends the request to the given channel. This method should be used to send {@link ProtobufTransportRequest}
-    * objects back to the caller.
-    */
-    void sendRequest(
-        final DiscoveryNode node,
-        final TcpChannel channel,
-        final long requestId,
-        final String action,
-        final ProtobufTransportRequest request,
-        final TransportRequestOptions options,
-        final Version channelVersion,
-        final boolean compressRequest,
-        final boolean isHandshake
-    ) throws IOException, TransportException {
-        Version version = Version.min(this.version, channelVersion);
-        ProtobufOutboundMessage.Request message = new ProtobufOutboundMessage.Request(
-            threadPool.getThreadContext(),
-            features,
-            request,
-            version,
-            action,
-            requestId,
-            isHandshake,
-            compressRequest
-        );
-        ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onRequestSent(node, requestId, action, request, options));
-        sendMessage(channel, message, listener);
-    }
+//     /**
+//      * Sends the request to the given channel. This method should be used to send {@link TransportRequest}
+//     * objects back to the caller.
+//     */
+//     void sendRequest(
+//         final DiscoveryNode node,
+//         final TcpChannel channel,
+//         final long requestId,
+//         final String action,
+//         final TransportRequest request,
+//         final TransportRequestOptions options,
+//         final Version channelVersion,
+//         final boolean compressRequest,
+//         final boolean isHandshake
+//     ) throws IOException, TransportException {
+//         Version version = Version.min(this.version, channelVersion);
+//         ProtobufOutboundMessage.Request message = new ProtobufOutboundMessage.Request(
+//             threadPool.getThreadContext(),
+//             features,
+//             request,
+//             version,
+//             action,
+//             requestId,
+//             isHandshake,
+//             compressRequest
+//         );
+//         ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onRequestSent(node, requestId, action, request, options));
+//         sendMessage(channel, message, listener);
+//     }
 
-    /**
-     * Sends the response to the given channel. This method should be used to send {@link ProtobufTransportResponse}
-    * objects back to the caller.
-    *
-    * @see #sendErrorResponse(Version, Set, TcpChannel, long, String, Exception) for sending error responses
-    */
-    void sendResponse(
-        final Version nodeVersion,
-        final Set<String> features,
-        final TcpChannel channel,
-        final long requestId,
-        final String action,
-        final ProtobufTransportResponse response,
-        final boolean compress,
-        final boolean isHandshake
-    ) throws IOException {
-        Version version = Version.min(this.version, nodeVersion);
-        ProtobufOutboundMessage.Response message = new ProtobufOutboundMessage.Response(
-            threadPool.getThreadContext(),
-            features,
-            response,
-            version,
-            requestId,
-            isHandshake,
-            compress
-        );
-        ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onResponseSent(requestId, action, response));
-        sendMessage(channel, message, listener);
-    }
+//     /**
+//      * Sends the response to the given channel. This method should be used to send {@link TransportResponse}
+//     * objects back to the caller.
+//     *
+//     * @see #sendErrorResponse(Version, Set, TcpChannel, long, String, Exception) for sending error responses
+//     */
+//     void sendResponse(
+//         final Version nodeVersion,
+//         final Set<String> features,
+//         final TcpChannel channel,
+//         final long requestId,
+//         final String action,
+//         final TransportResponse response,
+//         final boolean compress,
+//         final boolean isHandshake
+//     ) throws IOException {
+//         Version version = Version.min(this.version, nodeVersion);
+//         ProtobufOutboundMessage.Response message = new ProtobufOutboundMessage.Response(
+//             threadPool.getThreadContext(),
+//             features,
+//             response,
+//             version,
+//             requestId,
+//             isHandshake,
+//             compress
+//         );
+//         ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onResponseSent(requestId, action, response));
+//         sendMessage(channel, message, listener);
+//     }
 
-    /**
-     * Sends back an error response to the caller via the given channel
-    */
-    void sendErrorResponse(
-        final Version nodeVersion,
-        final Set<String> features,
-        final TcpChannel channel,
-        final long requestId,
-        final String action,
-        final Exception error
-    ) throws IOException {
-        Version version = Version.min(this.version, nodeVersion);
-        ProtobufTransportAddress address = new ProtobufTransportAddress(channel.getLocalAddress());
-        ProtobufRemoteTransportException tx = new ProtobufRemoteTransportException(nodeName, address, action, error);
-        ProtobufOutboundMessage.Response message = new ProtobufOutboundMessage.Response(
-            threadPool.getThreadContext(),
-            features,
-            tx,
-            version,
-            requestId,
-            false,
-            false
-        );
-        ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onResponseSent(requestId, action, error));
-        sendMessage(channel, message, listener);
-    }
+//     /**
+//      * Sends back an error response to the caller via the given channel
+//     */
+//     void sendErrorResponse(
+//         final Version nodeVersion,
+//         final Set<String> features,
+//         final TcpChannel channel,
+//         final long requestId,
+//         final String action,
+//         final Exception error
+//     ) throws IOException {
+//         Version version = Version.min(this.version, nodeVersion);
+//         TransportAddress address = new TransportAddress(channel.getLocalAddress());
+//         ProtobufRemoteTransportException tx = new ProtobufRemoteTransportException(nodeName, address, action, error);
+//         ProtobufOutboundMessage.Response message = new ProtobufOutboundMessage.Response(
+//             threadPool.getThreadContext(),
+//             features,
+//             tx,
+//             version,
+//             requestId,
+//             false,
+//             false
+//         );
+//         ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onResponseSent(requestId, action, error));
+//         sendMessage(channel, message, listener);
+//     }
 
-    private void sendMessage(TcpChannel channel, ProtobufOutboundMessage networkMessage, ActionListener<Void> listener) throws IOException {
-        MessageSerializer serializer = new MessageSerializer(networkMessage, bytes);
-        SendContext sendContext = new SendContext(channel, serializer, listener, serializer);
-        internalSend(channel, sendContext);
-    }
+//     private void sendMessage(TcpChannel channel, ProtobufOutboundMessage networkMessage, ActionListener<Void> listener) throws IOException {
+//         MessageSerializer serializer = new MessageSerializer(networkMessage, bytes);
+//         SendContext sendContext = new SendContext(channel, serializer, listener, serializer);
+//         internalSend(channel, sendContext);
+//     }
 
-    private void internalSend(TcpChannel channel, SendContext sendContext) throws IOException {
-        channel.getChannelStats().markAccessed(threadPool.relativeTimeInMillis());
-        BytesReference reference = sendContext.get();
-        // stash thread context so that channel event loop is not polluted by thread context
-        try (ThreadContext.StoredContext existing = threadPool.getThreadContext().stashContext()) {
-            channel.sendMessage(reference, sendContext);
-        } catch (RuntimeException ex) {
-            sendContext.onFailure(ex);
-            CloseableChannel.closeChannel(channel);
-            throw ex;
-        }
-    }
+//     private void internalSend(TcpChannel channel, SendContext sendContext) throws IOException {
+//         channel.getChannelStats().markAccessed(threadPool.relativeTimeInMillis());
+//         BytesReference reference = sendContext.get();
+//         // stash thread context so that channel event loop is not polluted by thread context
+//         try (ThreadContext.StoredContext existing = threadPool.getThreadContext().stashContext()) {
+//             channel.sendMessage(reference, sendContext);
+//         } catch (RuntimeException ex) {
+//             sendContext.onFailure(ex);
+//             CloseableChannel.closeChannel(channel);
+//             throw ex;
+//         }
+//     }
 
-    void setMessageListener(ProtobufTransportMessageListener listener) {
-        if (messageListener == ProtobufTransportMessageListener.NOOP_LISTENER) {
-            messageListener = listener;
-        } else {
-            throw new IllegalStateException("Cannot set message listener twice");
-        }
-    }
+//     void setMessageListener(ProtobufTransportMessageListener listener) {
+//         if (messageListener == ProtobufTransportMessageListener.NOOP_LISTENER) {
+//             messageListener = listener;
+//         } else {
+//             throw new IllegalStateException("Cannot set message listener twice");
+//         }
+//     }
 
-    /**
-     * Internal message serializer
-    *
-    * @opensearch.internal
-    */
-    private static class MessageSerializer implements CheckedSupplier<BytesReference, IOException>, Releasable {
+//     /**
+//      * Internal message serializer
+//     *
+//     * @opensearch.internal
+//     */
+//     private static class MessageSerializer implements CheckedSupplier<BytesReference, IOException>, Releasable {
 
-        private final ProtobufOutboundMessage message;
-        private byte[] bytes;
-        // private final BigArrays bigArrays;
-        // private volatile ReleasableBytesStreamOutput bytesStreamOutput;
+//         private final ProtobufOutboundMessage message;
+//         private byte[] bytes;
+//         // private final BigArrays bigArrays;
+//         // private volatile ReleasableBytesStreamOutput bytesStreamOutput;
 
-        private MessageSerializer(ProtobufOutboundMessage message, byte[] bytes) {
-            this.message = message;
-            this.bytes = bytes;
-        }
+//         private MessageSerializer(ProtobufOutboundMessage message, byte[] bytes) {
+//             this.message = message;
+//             this.bytes = bytes;
+//         }
 
-        @Override
-        public BytesReference get() throws IOException {
-            CodedOutputStream out = CodedOutputStream.newInstance(bytes);
-            return message.serialize(out, bytes);
-        }
+//         @Override
+//         public BytesReference get() throws IOException {
+//             CodedOutputStream out = CodedOutputStream.newInstance(bytes);
+//             return message.serialize(out, bytes);
+//         }
 
-        @Override
-        public void close() {
-            // IOUtils.closeWhileHandlingException(bytesStreamOutput);
-        }
-    }
+//         @Override
+//         public void close() {
+//             // IOUtils.closeWhileHandlingException(bytesStreamOutput);
+//         }
+//     }
 
-    private class SendContext extends NotifyOnceListener<Void> implements CheckedSupplier<BytesReference, IOException> {
+//     private class SendContext extends NotifyOnceListener<Void> implements CheckedSupplier<BytesReference, IOException> {
 
-        private final TcpChannel channel;
-        private final CheckedSupplier<BytesReference, IOException> messageSupplier;
-        private final ActionListener<Void> listener;
-        private final Releasable optionalReleasable;
-        private long messageSize = -1;
+//         private final TcpChannel channel;
+//         private final CheckedSupplier<BytesReference, IOException> messageSupplier;
+//         private final ActionListener<Void> listener;
+//         private final Releasable optionalReleasable;
+//         private long messageSize = -1;
 
-        private SendContext(
-            TcpChannel channel,
-            CheckedSupplier<BytesReference, IOException> messageSupplier,
-            ActionListener<Void> listener
-        ) {
-            this(channel, messageSupplier, listener, null);
-        }
+//         private SendContext(
+//             TcpChannel channel,
+//             CheckedSupplier<BytesReference, IOException> messageSupplier,
+//             ActionListener<Void> listener
+//         ) {
+//             this(channel, messageSupplier, listener, null);
+//         }
 
-        private SendContext(
-            TcpChannel channel,
-            CheckedSupplier<BytesReference, IOException> messageSupplier,
-            ActionListener<Void> listener,
-            Releasable optionalReleasable
-        ) {
-            this.channel = channel;
-            this.messageSupplier = messageSupplier;
-            this.listener = listener;
-            this.optionalReleasable = optionalReleasable;
-        }
+//         private SendContext(
+//             TcpChannel channel,
+//             CheckedSupplier<BytesReference, IOException> messageSupplier,
+//             ActionListener<Void> listener,
+//             Releasable optionalReleasable
+//         ) {
+//             this.channel = channel;
+//             this.messageSupplier = messageSupplier;
+//             this.listener = listener;
+//             this.optionalReleasable = optionalReleasable;
+//         }
 
-        public BytesReference get() throws IOException {
-            BytesReference message;
-            try {
-                message = messageSupplier.get();
-                messageSize = message.length();
-                TransportLogger.logOutboundMessage(channel, message);
-                return message;
-            } catch (Exception e) {
-                onFailure(e);
-                throw e;
-            }
-        }
+//         public BytesReference get() throws IOException {
+//             BytesReference message;
+//             try {
+//                 message = messageSupplier.get();
+//                 messageSize = message.length();
+//                 TransportLogger.logOutboundMessage(channel, message);
+//                 return message;
+//             } catch (Exception e) {
+//                 onFailure(e);
+//                 throw e;
+//             }
+//         }
 
-        @Override
-        protected void innerOnResponse(Void v) {
-            assert messageSize != -1 : "If onResponse is being called, the message should have been serialized";
-            statsTracker.markBytesWritten(messageSize);
-            closeAndCallback(() -> listener.onResponse(v));
-        }
+//         @Override
+//         protected void innerOnResponse(Void v) {
+//             assert messageSize != -1 : "If onResponse is being called, the message should have been serialized";
+//             statsTracker.markBytesWritten(messageSize);
+//             closeAndCallback(() -> listener.onResponse(v));
+//         }
 
-        @Override
-        protected void innerOnFailure(Exception e) {
-            if (NetworkExceptionHelper.isCloseConnectionException(e)) {
-                logger.debug(() -> new ParameterizedMessage("send message failed [channel: {}]", channel), e);
-            } else {
-                logger.warn(() -> new ParameterizedMessage("send message failed [channel: {}]", channel), e);
-            }
-            closeAndCallback(() -> listener.onFailure(e));
-        }
+//         @Override
+//         protected void innerOnFailure(Exception e) {
+//             if (NetworkExceptionHelper.isCloseConnectionException(e)) {
+//                 logger.debug(() -> new ParameterizedMessage("send message failed [channel: {}]", channel), e);
+//             } else {
+//                 logger.warn(() -> new ParameterizedMessage("send message failed [channel: {}]", channel), e);
+//             }
+//             closeAndCallback(() -> listener.onFailure(e));
+//         }
 
-        private void closeAndCallback(Runnable runnable) {
-            Releasables.close(optionalReleasable, runnable::run);
-        }
-    }
-}
+//         private void closeAndCallback(Runnable runnable) {
+//             Releasables.close(optionalReleasable, runnable::run);
+//         }
+//     }
+// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufPlainTransportFuture.java b/server/src/main/java/org/opensearch/transport/ProtobufPlainTransportFuture.java
index 259840e96126e..24ae8cc4c84ec 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufPlainTransportFuture.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufPlainTransportFuture.java
@@ -11,6 +11,7 @@
 import com.google.protobuf.CodedInputStream;
 import org.opensearch.OpenSearchException;
 import org.opensearch.OpenSearchTimeoutException;
+import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.common.util.concurrent.BaseFuture;
 
 import java.io.IOException;
@@ -23,14 +24,14 @@
 *
 * @opensearch.internal
 */
-public class ProtobufPlainTransportFuture<V extends ProtobufTransportResponse> extends BaseFuture<V>
+public class ProtobufPlainTransportFuture<V extends TransportResponse> extends BaseFuture<V>
     implements
         TransportFuture<V>,
-        ProtobufTransportResponseHandler<V> {
+        TransportResponseHandler<V> {
 
-    private final ProtobufTransportResponseHandler<V> handler;
+    private final TransportResponseHandler<V> handler;
 
-    public ProtobufPlainTransportFuture(ProtobufTransportResponseHandler<V> handler) {
+    public ProtobufPlainTransportFuture(TransportResponseHandler<V> handler) {
         this.handler = handler;
     }
 
@@ -83,14 +84,14 @@ public void handleResponse(V response) {
             handler.handleResponse(response);
             set(response);
         } catch (Exception e) {
-            handleException(new ProtobufTransportException(e));
+            handleExceptionProtobuf(new ProtobufTransportException(e));
         }
     }
 
     @Override
-    public void handleException(ProtobufTransportException exp) {
+    public void handleExceptionProtobuf(ProtobufTransportException exp) {
         try {
-            handler.handleException(exp);
+            handler.handleExceptionProtobuf(exp);
         } finally {
             setException(exp);
         }
@@ -100,4 +101,16 @@ public void handleException(ProtobufTransportException exp) {
     public String toString() {
         return "future(" + handler.toString() + ")";
     }
+
+    @Override
+    public V read(StreamInput in) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'read'");
+    }
+
+    @Override
+    public void handleException(TransportException exp) {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'handleException'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufProxyConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/ProtobufProxyConnectionStrategy.java
index 584967aa2b9bb..fa2f36f63208c 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufProxyConnectionStrategy.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufProxyConnectionStrategy.java
@@ -96,12 +96,12 @@ public class ProtobufProxyConnectionStrategy extends ProtobufRemoteConnectionStr
     private final String configuredServerName;
     private final Supplier<TransportAddress> address;
     private final AtomicReference<ClusterName> remoteClusterName = new AtomicReference<>();
-    private final ProtobufConnectionManager.ConnectionValidator clusterNameValidator;
+    private final ConnectionManager.ConnectionValidator clusterNameValidator;
 
     ProtobufProxyConnectionStrategy(
         String clusterAlias,
-        ProtobufTransportService transportService,
-        ProtobufRemoteConnectionManager connectionManager,
+        TransportService transportService,
+        RemoteConnectionManager connectionManager,
         Settings settings
     ) {
         this(
@@ -117,8 +117,8 @@ public class ProtobufProxyConnectionStrategy extends ProtobufRemoteConnectionStr
 
     ProtobufProxyConnectionStrategy(
         String clusterAlias,
-        ProtobufTransportService transportService,
-        ProtobufRemoteConnectionManager connectionManager,
+        TransportService transportService,
+        RemoteConnectionManager connectionManager,
         Settings settings,
         int maxNumConnections,
         String configuredAddress
@@ -137,8 +137,8 @@ public class ProtobufProxyConnectionStrategy extends ProtobufRemoteConnectionStr
 
     ProtobufProxyConnectionStrategy(
         String clusterAlias,
-        ProtobufTransportService transportService,
-        ProtobufRemoteConnectionManager connectionManager,
+        TransportService transportService,
+        RemoteConnectionManager connectionManager,
         Settings settings,
         int maxNumConnections,
         String configuredAddress,
@@ -158,8 +158,8 @@ public class ProtobufProxyConnectionStrategy extends ProtobufRemoteConnectionStr
 
     ProtobufProxyConnectionStrategy(
         String clusterAlias,
-        ProtobufTransportService transportService,
-        ProtobufRemoteConnectionManager connectionManager,
+        TransportService transportService,
+        RemoteConnectionManager connectionManager,
         Settings settings,
         int maxNumConnections,
         String configuredAddress,
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufReceiveTimeoutTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufReceiveTimeoutTransportException.java
index 704ab50753ee6..137c1763b0bb5 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufReceiveTimeoutTransportException.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufReceiveTimeoutTransportException.java
@@ -21,7 +21,7 @@
 public class ProtobufReceiveTimeoutTransportException extends ProtobufActionTransportException {
 
     public ProtobufReceiveTimeoutTransportException(DiscoveryNode node, String action, String msg) {
-        super(node.getName(), node.getProtobufAddress(), action, msg, null);
+        super(node.getName(), node.getAddress(), action, msg, null);
     }
 
     public ProtobufReceiveTimeoutTransportException(CodedInputStream in) throws IOException {
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java
index a5d6fec24c4d3..b1933e08fd610 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java
@@ -26,11 +26,11 @@
 */
 final class ProtobufRemoteClusterAwareClient extends ProtobufAbstractClient {
 
-    private final ProtobufTransportService service;
+    private final TransportService service;
     private final String clusterAlias;
     private final RemoteClusterService remoteClusterService;
 
-    ProtobufRemoteClusterAwareClient(Settings settings, ThreadPool threadPool, ProtobufTransportService service, String clusterAlias) {
+    ProtobufRemoteClusterAwareClient(Settings settings, ThreadPool threadPool, TransportService service, String clusterAlias) {
         super(settings, threadPool);
         this.service = service;
         this.clusterAlias = clusterAlias;
@@ -44,12 +44,12 @@ protected <Request extends ProtobufActionRequest, Response extends ProtobufActio
         ActionListener<Response> listener
     ) {
         remoteClusterService.ensureConnected(clusterAlias, ActionListener.wrap(v -> {
-            Transport.ProtobufConnection connection;
+            Transport.Connection connection;
             if (request instanceof RemoteClusterAwareRequest) {
                 DiscoveryNode preferredTargetNode = ((RemoteClusterAwareRequest) request).getPreferredTargetNode();
-                connection = remoteClusterService.getConnectionProtobuf(preferredTargetNode, clusterAlias);
+                connection = remoteClusterService.getConnection(preferredTargetNode, clusterAlias);
             } else {
-                connection = remoteClusterService.getConnectionProtobuf(clusterAlias);
+                connection = remoteClusterService.getConnection(clusterAlias);
             }
             service.sendRequest(
                 connection,
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
index 5cc607ee3bce8..66ece62dc5a67 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
@@ -16,6 +16,7 @@
 import org.opensearch.action.support.ContextPreservingActionListener;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.ThreadContext;
@@ -43,8 +44,8 @@
 */
 final class ProtobufRemoteClusterConnection implements Closeable {
 
-    private final ProtobufTransportService transportService;
-    private final ProtobufRemoteConnectionManager remoteConnectionManager;
+    private final TransportService transportService;
+    private final RemoteConnectionManager remoteConnectionManager;
     private final ProtobufRemoteConnectionStrategy connectionStrategy;
     private final String clusterAlias;
     private final ThreadPool threadPool;
@@ -57,11 +58,11 @@ final class ProtobufRemoteClusterConnection implements Closeable {
     * @param clusterAlias the configured alias of the cluster to connect to
     * @param transportService the local nodes transport service
     */
-    ProtobufRemoteClusterConnection(Settings settings, String clusterAlias, ProtobufTransportService transportService) {
+    ProtobufRemoteClusterConnection(Settings settings, String clusterAlias, TransportService transportService) {
         this.transportService = transportService;
         this.clusterAlias = clusterAlias;
-        ProtobufConnectionProfile profile = ProtobufRemoteConnectionStrategy.buildConnectionProfile(clusterAlias, settings);
-        this.remoteConnectionManager = new ProtobufRemoteConnectionManager(
+        ConnectionProfile profile = ProtobufRemoteConnectionStrategy.buildConnectionProfile(clusterAlias, settings);
+        this.remoteConnectionManager = new RemoteConnectionManager(
             clusterAlias,
             createConnectionManager(profile, transportService)
         );
@@ -127,13 +128,13 @@ void collectNodes(ActionListener<Function<String, DiscoveryNode>> listener) {
                 request.clear();
                 request.nodes(true);
                 request.local(true); // run this on the node that gets the request it's as good as any other
-                Transport.ProtobufConnection connection = remoteConnectionManager.getAnyRemoteConnection();
+                Transport.Connection connection = remoteConnectionManager.getAnyRemoteConnection();
                 transportService.sendRequest(
                     connection,
                     ClusterStateAction.NAME,
                     request,
                     TransportRequestOptions.EMPTY,
-                    new ProtobufTransportResponseHandler<ProtobufClusterStateResponse>() {
+                    new TransportResponseHandler<ProtobufClusterStateResponse>() {
 
                         @Override
                         public ProtobufClusterStateResponse read(CodedInputStream in) throws IOException {
@@ -147,7 +148,7 @@ public void handleResponse(ProtobufClusterStateResponse response) {
                         }
 
                         @Override
-                        public void handleException(ProtobufTransportException exp) {
+                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
                             contextPreservingActionListener.onFailure(exp);
                         }
 
@@ -155,6 +156,18 @@ public void handleException(ProtobufTransportException exp) {
                         public String executor() {
                             return ThreadPool.Names.SAME;
                         }
+
+                        @Override
+                        public ProtobufClusterStateResponse read(StreamInput in) throws IOException {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'read'");
+                        }
+
+                        @Override
+                        public void handleException(TransportException exp) {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'handleException'");
+                        }
                     }
                 );
             }
@@ -175,11 +188,11 @@ public String executor() {
      * Returns a connection to the remote cluster, preferably a direct connection to the provided {@link DiscoveryNode}.
     * If such node is not connected, the returned connection will be a proxy connection that redirects to it.
     */
-    Transport.ProtobufConnection getConnection(DiscoveryNode remoteClusterNode) {
+    Transport.Connection getConnection(DiscoveryNode remoteClusterNode) {
         return remoteConnectionManager.getConnection(remoteClusterNode);
     }
 
-    Transport.ProtobufConnection getConnection() {
+    Transport.Connection getConnection() {
         return remoteConnectionManager.getAnyRemoteConnection();
     }
 
@@ -212,14 +225,14 @@ int getNumNodesConnected() {
         return remoteConnectionManager.size();
     }
 
-    private static ProtobufConnectionManager createConnectionManager(
-        ProtobufConnectionProfile connectionProfile,
-        ProtobufTransportService transportService
+    private static ConnectionManager createConnectionManager(
+        ConnectionProfile connectionProfile,
+        TransportService transportService
     ) {
-        return new ProtobufClusterConnectionManager(connectionProfile, transportService.transport);
+        return new ClusterConnectionManager(connectionProfile, transportService.transport);
     }
 
-    ProtobufConnectionManager getConnectionManager() {
+    ConnectionManager getConnectionManager() {
         return remoteConnectionManager;
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java
index bbcd06df4a1f7..404495e07588d 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java
@@ -125,10 +125,10 @@ public boolean isEnabled() {
         return enabled;
     }
 
-    private final ProtobufTransportService transportService;
+    private final TransportService transportService;
     private final Map<String, ProtobufRemoteClusterConnection> remoteClusters = ConcurrentCollections.newConcurrentMap();
 
-    ProtobufRemoteClusterService(Settings settings, ProtobufTransportService transportService) {
+    ProtobufRemoteClusterService(Settings settings, TransportService transportService) {
         super(settings);
         this.enabled = DiscoveryNode.isRemoteClusterClient(settings);
         this.transportService = transportService;
@@ -185,7 +185,7 @@ public Set<String> getRegisteredRemoteClusterNames() {
     *
     * @throws IllegalArgumentException if the remote cluster is unknown
     */
-    public Transport.ProtobufConnection getConnection(DiscoveryNode node, String cluster) {
+    public Transport.Connection getConnection(DiscoveryNode node, String cluster) {
         return getRemoteClusterConnection(cluster).getConnection(node);
     }
 
@@ -204,7 +204,7 @@ public boolean isSkipUnavailable(String clusterAlias) {
         return getRemoteClusterConnection(clusterAlias).isSkipUnavailable();
     }
 
-    public Transport.ProtobufConnection getConnection(String cluster) {
+    public Transport.Connection getConnection(String cluster) {
         return getRemoteClusterConnection(cluster).getConnection();
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java
index f0c7a093d83f6..38d658aacafa7 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java
@@ -1,215 +1,222 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import org.opensearch.Version;
-import org.opensearch.action.ActionListener;
-import org.opensearch.cluster.node.DiscoveryNode;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.atomic.AtomicLong;
-
-/**
- * Manager for connecting to remote nodes
-*
-* @opensearch.internal
-*/
-public class ProtobufRemoteConnectionManager implements ProtobufConnectionManager {
-
-    private final String clusterAlias;
-    private final ProtobufConnectionManager delegate;
-    private final AtomicLong counter = new AtomicLong();
-    private volatile List<DiscoveryNode> connectedNodes = Collections.emptyList();
-
-    ProtobufRemoteConnectionManager(String clusterAlias, ProtobufConnectionManager delegate) {
-        this.clusterAlias = clusterAlias;
-        this.delegate = delegate;
-        this.delegate.addListener(new ProtobufTransportConnectionListener() {
-            @Override
-            public void onNodeConnected(DiscoveryNode node, Transport.ProtobufConnection connection) {
-                addConnectedNode(node);
-            }
-
-            @Override
-            public void onNodeDisconnected(DiscoveryNode node, Transport.ProtobufConnection connection) {
-                removeConnectedNode(node);
-            }
-        });
-    }
-
-    @Override
-    public void connectToNode(
-        DiscoveryNode node,
-        ProtobufConnectionProfile connectionProfile,
-        ProtobufConnectionManager.ConnectionValidator connectionValidator,
-        ActionListener<Void> listener
-    ) throws ConnectTransportException {
-        delegate.connectToNode(node, connectionProfile, connectionValidator, listener);
-    }
-
-    @Override
-    public void addListener(ProtobufTransportConnectionListener listener) {
-        delegate.addListener(listener);
-    }
-
-    @Override
-    public void removeListener(ProtobufTransportConnectionListener listener) {
-        delegate.removeListener(listener);
-    }
-
-    @Override
-    public void openConnection(
-        DiscoveryNode node,
-        ProtobufConnectionProfile profile,
-        ActionListener<Transport.ProtobufConnection> listener
-    ) {
-        delegate.openConnection(node, profile, listener);
-    }
-
-    @Override
-    public Transport.ProtobufConnection getConnection(DiscoveryNode node) {
-        try {
-            return delegate.getConnection(node);
-        } catch (NodeNotConnectedException e) {
-            return new ProxyConnection(getAnyRemoteConnection(), node);
-        }
-    }
-
-    @Override
-    public boolean nodeConnected(DiscoveryNode node) {
-        return delegate.nodeConnected(node);
-    }
-
-    @Override
-    public void disconnectFromNode(DiscoveryNode node) {
-        delegate.disconnectFromNode(node);
-    }
-
-    @Override
-    public ProtobufConnectionProfile getConnectionProfile() {
-        return delegate.getConnectionProfile();
-    }
-
-    public Transport.ProtobufConnection getAnyRemoteConnection() {
-        List<DiscoveryNode> localConnectedNodes = this.connectedNodes;
-        long curr;
-        while ((curr = counter.incrementAndGet()) == Long.MIN_VALUE)
-            ;
-        if (localConnectedNodes.isEmpty() == false) {
-            DiscoveryNode nextNode = localConnectedNodes.get(Math.toIntExact(Math.floorMod(curr, (long) localConnectedNodes.size())));
-            try {
-                return delegate.getConnection(nextNode);
-            } catch (NodeNotConnectedException e) {
-                // Ignore. We will manually create an iterator of open nodes
-            }
-        }
-        Set<DiscoveryNode> allConnectionNodes = getAllConnectedNodes();
-        for (DiscoveryNode connectedNode : allConnectionNodes) {
-            try {
-                return delegate.getConnection(connectedNode);
-            } catch (NodeNotConnectedException e) {
-                // Ignore. We will try the next one until all are exhausted.
-            }
-        }
-        throw new NoSuchRemoteClusterException(clusterAlias);
-    }
-
-    @Override
-    public Set<DiscoveryNode> getAllConnectedNodes() {
-        return delegate.getAllConnectedNodes();
-    }
-
-    @Override
-    public int size() {
-        return delegate.size();
-    }
-
-    @Override
-    public void close() {
-        delegate.closeNoBlock();
-    }
-
-    @Override
-    public void closeNoBlock() {
-        delegate.closeNoBlock();
-    }
-
-    private synchronized void addConnectedNode(DiscoveryNode addedNode) {
-        ArrayList<DiscoveryNode> newConnections = new ArrayList<>(this.connectedNodes);
-        newConnections.add(addedNode);
-        this.connectedNodes = Collections.unmodifiableList(newConnections);
-    }
-
-    private synchronized void removeConnectedNode(DiscoveryNode removedNode) {
-        int newSize = this.connectedNodes.size() - 1;
-        ArrayList<DiscoveryNode> newConnectedNodes = new ArrayList<>(newSize);
-        for (DiscoveryNode connectedNode : this.connectedNodes) {
-            if (connectedNode.equals(removedNode) == false) {
-                newConnectedNodes.add(connectedNode);
-            }
-        }
-        assert newConnectedNodes.size() == newSize : "Expected connection node count: " + newSize + ", Found: " + newConnectedNodes.size();
-        this.connectedNodes = Collections.unmodifiableList(newConnectedNodes);
-    }
-
-    static final class ProxyConnection implements Transport.ProtobufConnection {
-        private final Transport.ProtobufConnection connection;
-        private final DiscoveryNode targetNode;
-
-        private ProxyConnection(Transport.ProtobufConnection connection, DiscoveryNode targetNode) {
-            this.connection = connection;
-            this.targetNode = targetNode;
-        }
-
-        @Override
-        public DiscoveryNode getNode() {
-            return targetNode;
-        }
-
-        @Override
-        public void sendRequest(long requestId, String action, ProtobufTransportRequest request, TransportRequestOptions options)
-            throws IOException, TransportException {
-            connection.sendRequest(
-                requestId,
-                ProtobufTransportActionProxy.getProxyAction(action),
-                ProtobufTransportActionProxy.wrapRequest(targetNode, request),
-                options
-            );
-        }
-
-        @Override
-        public void close() {
-            assert false : "proxy connections must not be closed";
-        }
-
-        @Override
-        public void addCloseListener(ActionListener<Void> listener) {
-            connection.addCloseListener(listener);
-        }
-
-        @Override
-        public boolean isClosed() {
-            return connection.isClosed();
-        }
-
-        @Override
-        public Version getVersion() {
-            return connection.getVersion();
-        }
-
-        @Override
-        public Object getCacheKey() {
-            return connection.getCacheKey();
-        }
-    }
-}
+// /*
+// * 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.
+// */
+
+// package org.opensearch.transport;
+
+// import org.opensearch.Version;
+// import org.opensearch.action.ActionListener;
+// import org.opensearch.cluster.node.DiscoveryNode;
+
+// import java.io.IOException;
+// import java.util.ArrayList;
+// import java.util.Collections;
+// import java.util.List;
+// import java.util.Set;
+// import java.util.concurrent.atomic.AtomicLong;
+
+// /**
+//  * Manager for connecting to remote nodes
+// *
+// * @opensearch.internal
+// */
+// public class ProtobufRemoteConnectionManager implements ConnectionManager {
+
+//     private final String clusterAlias;
+//     private final ConnectionManager delegate;
+//     private final AtomicLong counter = new AtomicLong();
+//     private volatile List<DiscoveryNode> connectedNodes = Collections.emptyList();
+
+//     ProtobufRemoteConnectionManager(String clusterAlias, ConnectionManager delegate) {
+//         this.clusterAlias = clusterAlias;
+//         this.delegate = delegate;
+//         this.delegate.addListener(new TransportConnectionListener() {
+//             @Override
+//             public void onNodeConnected(DiscoveryNode node, Transport.Connection connection) {
+//                 addConnectedNode(node);
+//             }
+
+//             @Override
+//             public void onNodeDisconnected(DiscoveryNode node, Transport.Connection connection) {
+//                 removeConnectedNode(node);
+//             }
+//         });
+//     }
+
+//     @Override
+//     public void connectToNode(
+//         DiscoveryNode node,
+//         ConnectionProfile connectionProfile,
+//         ConnectionManager.ConnectionValidator connectionValidator,
+//         ActionListener<Void> listener
+//     ) throws ConnectTransportException {
+//         delegate.connectToNode(node, connectionProfile, connectionValidator, listener);
+//     }
+
+//     @Override
+//     public void addListener(TransportConnectionListener listener) {
+//         delegate.addListener(listener);
+//     }
+
+//     @Override
+//     public void removeListener(TransportConnectionListener listener) {
+//         delegate.removeListener(listener);
+//     }
+
+//     @Override
+//     public void openConnection(
+//         DiscoveryNode node,
+//         ConnectionProfile profile,
+//         ActionListener<Transport.Connection> listener
+//     ) {
+//         delegate.openConnection(node, profile, listener);
+//     }
+
+//     @Override
+//     public Transport.Connection getConnection(DiscoveryNode node) {
+//         try {
+//             return delegate.getConnection(node);
+//         } catch (NodeNotConnectedException e) {
+//             return new ProxyConnection(getAnyRemoteConnection(), node);
+//         }
+//     }
+
+//     @Override
+//     public boolean nodeConnected(DiscoveryNode node) {
+//         return delegate.nodeConnected(node);
+//     }
+
+//     @Override
+//     public void disconnectFromNode(DiscoveryNode node) {
+//         delegate.disconnectFromNode(node);
+//     }
+
+//     @Override
+//     public ConnectionProfile getConnectionProfile() {
+//         return delegate.getConnectionProfile();
+//     }
+
+//     public Transport.Connection getAnyRemoteConnection() {
+//         List<DiscoveryNode> localConnectedNodes = this.connectedNodes;
+//         long curr;
+//         while ((curr = counter.incrementAndGet()) == Long.MIN_VALUE)
+//             ;
+//         if (localConnectedNodes.isEmpty() == false) {
+//             DiscoveryNode nextNode = localConnectedNodes.get(Math.toIntExact(Math.floorMod(curr, (long) localConnectedNodes.size())));
+//             try {
+//                 return delegate.getConnection(nextNode);
+//             } catch (NodeNotConnectedException e) {
+//                 // Ignore. We will manually create an iterator of open nodes
+//             }
+//         }
+//         Set<DiscoveryNode> allConnectionNodes = getAllConnectedNodes();
+//         for (DiscoveryNode connectedNode : allConnectionNodes) {
+//             try {
+//                 return delegate.getConnection(connectedNode);
+//             } catch (NodeNotConnectedException e) {
+//                 // Ignore. We will try the next one until all are exhausted.
+//             }
+//         }
+//         throw new NoSuchRemoteClusterException(clusterAlias);
+//     }
+
+//     @Override
+//     public Set<DiscoveryNode> getAllConnectedNodes() {
+//         return delegate.getAllConnectedNodes();
+//     }
+
+//     @Override
+//     public int size() {
+//         return delegate.size();
+//     }
+
+//     @Override
+//     public void close() {
+//         delegate.closeNoBlock();
+//     }
+
+//     @Override
+//     public void closeNoBlock() {
+//         delegate.closeNoBlock();
+//     }
+
+//     private synchronized void addConnectedNode(DiscoveryNode addedNode) {
+//         ArrayList<DiscoveryNode> newConnections = new ArrayList<>(this.connectedNodes);
+//         newConnections.add(addedNode);
+//         this.connectedNodes = Collections.unmodifiableList(newConnections);
+//     }
+
+//     private synchronized void removeConnectedNode(DiscoveryNode removedNode) {
+//         int newSize = this.connectedNodes.size() - 1;
+//         ArrayList<DiscoveryNode> newConnectedNodes = new ArrayList<>(newSize);
+//         for (DiscoveryNode connectedNode : this.connectedNodes) {
+//             if (connectedNode.equals(removedNode) == false) {
+//                 newConnectedNodes.add(connectedNode);
+//             }
+//         }
+//         assert newConnectedNodes.size() == newSize : "Expected connection node count: " + newSize + ", Found: " + newConnectedNodes.size();
+//         this.connectedNodes = Collections.unmodifiableList(newConnectedNodes);
+//     }
+
+//     static final class ProxyConnection implements Transport.Connection {
+//         private final Transport.Connection connection;
+//         private final DiscoveryNode targetNode;
+
+//         private ProxyConnection(Transport.Connection connection, DiscoveryNode targetNode) {
+//             this.connection = connection;
+//             this.targetNode = targetNode;
+//         }
+
+//         @Override
+//         public DiscoveryNode getNode() {
+//             return targetNode;
+//         }
+
+//         @Override
+//         public void sendRequestProtobuf(long requestId, String action, ProtobufTransportRequest request, TransportRequestOptions options)
+//             throws IOException, TransportException {
+//             connection.sendRequestProtobuf(
+//                 requestId,
+//                 ProtobufTransportActionProxy.getProxyAction(action),
+//                 ProtobufTransportActionProxy.wrapRequest(targetNode, request),
+//                 options
+//             );
+//         }
+
+//         @Override
+//         public void close() {
+//             assert false : "proxy connections must not be closed";
+//         }
+
+//         @Override
+//         public void addCloseListener(ActionListener<Void> listener) {
+//             connection.addCloseListener(listener);
+//         }
+
+//         @Override
+//         public boolean isClosed() {
+//             return connection.isClosed();
+//         }
+
+//         @Override
+//         public Version getVersion() {
+//             return connection.getVersion();
+//         }
+
+//         @Override
+//         public Object getCacheKey() {
+//             return connection.getCacheKey();
+//         }
+
+//         @Override
+//         public void sendRequest(long requestId, String action, TransportRequest request,
+//                 TransportRequestOptions options) throws IOException, TransportException {
+//             // TODO Auto-generated method stub
+//             throw new UnsupportedOperationException("Unimplemented method 'sendRequest'");
+//         }
+//     }
+// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java
index 3b9b68a3b5be3..ffab5879f527b 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java
@@ -73,7 +73,7 @@
 *
 * @opensearch.internal
 */
-public abstract class ProtobufRemoteConnectionStrategy implements ProtobufTransportConnectionListener, Closeable {
+public abstract class ProtobufRemoteConnectionStrategy implements TransportConnectionListener, Closeable {
 
     enum ProtobufConnectionStrategy {
         SNIFF(
@@ -151,14 +151,14 @@ public ProtobufWriteable.Reader<ProtobufRemoteConnectionInfo.ModeInfo> getReader
     private final Object mutex = new Object();
     private List<ActionListener<Void>> listeners = new ArrayList<>();
 
-    protected final ProtobufTransportService transportService;
-    protected final ProtobufRemoteConnectionManager connectionManager;
+    protected final TransportService transportService;
+    protected final RemoteConnectionManager connectionManager;
     protected final String clusterAlias;
 
     ProtobufRemoteConnectionStrategy(
         String clusterAlias,
-        ProtobufTransportService transportService,
-        ProtobufRemoteConnectionManager connectionManager,
+        TransportService transportService,
+        RemoteConnectionManager connectionManager,
         Settings settings
     ) {
         this.clusterAlias = clusterAlias;
@@ -168,9 +168,9 @@ public ProtobufWriteable.Reader<ProtobufRemoteConnectionInfo.ModeInfo> getReader
         connectionManager.addListener(this);
     }
 
-    static ProtobufConnectionProfile buildConnectionProfile(String clusterAlias, Settings settings) {
+    static ConnectionProfile buildConnectionProfile(String clusterAlias, Settings settings) {
         ProtobufConnectionStrategy mode = REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(clusterAlias).get(settings);
-        ProtobufConnectionProfile.Builder builder = new ProtobufConnectionProfile.Builder().setConnectTimeout(
+        ConnectionProfile.Builder builder = new ConnectionProfile.Builder().setConnectTimeout(
             TransportSettings.CONNECT_TIMEOUT.get(settings)
         )
             .setHandshakeTimeout(TransportSettings.CONNECT_TIMEOUT.get(settings))
@@ -189,8 +189,8 @@ static ProtobufConnectionProfile buildConnectionProfile(String clusterAlias, Set
 
     static ProtobufRemoteConnectionStrategy buildStrategy(
         String clusterAlias,
-        ProtobufTransportService transportService,
-        ProtobufRemoteConnectionManager connectionManager,
+        TransportService transportService,
+        RemoteConnectionManager connectionManager,
         Settings settings
     ) {
         ProtobufConnectionStrategy mode = REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(clusterAlias).get(settings);
@@ -347,11 +347,11 @@ boolean shouldRebuildConnection(Settings newSettings) {
             TimeValue pingSchedule = RemoteClusterService.REMOTE_CLUSTER_PING_SCHEDULE.getConcreteSettingForNamespace(clusterAlias)
                 .get(newSettings);
 
-            ProtobufConnectionProfile oldProfile = connectionManager.getConnectionProfile();
-            ProtobufConnectionProfile.Builder builder = new ProtobufConnectionProfile.Builder(oldProfile);
+            ConnectionProfile oldProfile = connectionManager.getConnectionProfile();
+            ConnectionProfile.Builder builder = new ConnectionProfile.Builder(oldProfile);
             builder.setCompressionEnabled(compressionEnabled);
             builder.setPingInterval(pingSchedule);
-            ProtobufConnectionProfile newProfile = builder.build();
+            ConnectionProfile newProfile = builder.build();
             return connectionProfileChanged(oldProfile, newProfile) || strategyMustBeRebuilt(newSettings);
         }
     }
@@ -361,7 +361,7 @@ boolean shouldRebuildConnection(Settings newSettings) {
     protected abstract ProtobufConnectionStrategy strategyType();
 
     @Override
-    public void onNodeDisconnected(DiscoveryNode node, Transport.ProtobufConnection connection) {
+    public void onNodeDisconnected(DiscoveryNode node, Transport.Connection connection) {
         if (shouldOpenMoreConnections()) {
             // try to reconnect and fill up the slot of the disconnected node
             connect(
@@ -422,7 +422,7 @@ private List<ActionListener<Void>> getAndClearListeners() {
         return result;
     }
 
-    private boolean connectionProfileChanged(ProtobufConnectionProfile oldProfile, ProtobufConnectionProfile newProfile) {
+    private boolean connectionProfileChanged(ConnectionProfile oldProfile, ConnectionProfile newProfile) {
         return Objects.equals(oldProfile.getCompressionEnabled(), newProfile.getCompressionEnabled()) == false
             || Objects.equals(oldProfile.getPingInterval(), newProfile.getPingInterval()) == false;
     }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteTransportException.java
index b720a95e19264..9c2f0484b9d1a 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteTransportException.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteTransportException.java
@@ -10,7 +10,7 @@
 
 import com.google.protobuf.CodedInputStream;
 import org.opensearch.OpenSearchWrapperException;
-import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.common.transport.TransportAddress;
 
 import java.io.IOException;
 
@@ -26,7 +26,7 @@ public ProtobufRemoteTransportException(String msg, Throwable cause) {
         super(msg, null, null, cause);
     }
 
-    public ProtobufRemoteTransportException(String name, ProtobufTransportAddress address, String action, Throwable cause) {
+    public ProtobufRemoteTransportException(String name, TransportAddress address, String action, Throwable cause) {
         super(name, address, action, cause);
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
index f2c65666bd7b9..06c6d7886a955 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
@@ -24,7 +24,7 @@
 *
 * @opensearch.internal
 */
-public final class ProtobufRequestHandlerRegistry<Request extends ProtobufTransportRequest> {
+public final class ProtobufRequestHandlerRegistry<Request extends TransportRequest> {
 
     private final String action;
     private final ProtobufTransportRequestHandler<Request> handler;
@@ -60,27 +60,27 @@ public Request newRequest(CodedInputStream in) throws IOException {
         return requestReader.read(in);
     }
 
-    public void processMessageReceived(Request request, ProtobufTransportChannel channel) throws Exception {
+    public void processMessageReceived(Request request, TransportChannel channel) throws Exception {
         final ProtobufTask task = taskManager.registerProtobuf(channel.getChannelType(), action, request);
         ThreadContext.StoredContext contextToRestore = taskManager.protobufTaskExecutionStarted(task);
 
         Releasable unregisterTask = () -> taskManager.unregisterProtobufTask(task);
         try {
-            if (channel instanceof ProtobufTcpTransportChannel && task instanceof ProtobufCancellableTask) {
+            if (channel instanceof TcpTransportChannel && task instanceof ProtobufCancellableTask) {
                 // if (request instanceof ShardSearchRequest) {
                 // // on receiving request, update the inbound network time to reflect time spent in transit over the network
                 // ((ShardSearchRequest) request).setInboundNetworkTime(
                 // Math.max(0, System.currentTimeMillis() - ((ShardSearchRequest) request).getInboundNetworkTime())
                 // );
                 // }
-                final TcpChannel tcpChannel = ((ProtobufTcpTransportChannel) channel).getChannel();
+                final TcpChannel tcpChannel = ((TcpTransportChannel) channel).getChannel();
                 final Releasable stopTracking = taskManager.startProtobufTrackingCancellableChannelTask(
                     tcpChannel,
                     (ProtobufCancellableTask) task
                 );
                 unregisterTask = Releasables.wrap(unregisterTask, stopTracking);
             }
-            final ProtobufTaskTransportChannel taskTransportChannel = new ProtobufTaskTransportChannel(channel, unregisterTask);
+            final TaskTransportChannel taskTransportChannel = new TaskTransportChannel(channel, unregisterTask);
             handler.messageReceived(request, taskTransportChannel, task);
             unregisterTask = null;
         } finally {
@@ -110,7 +110,7 @@ public String toString() {
         return handler.toString();
     }
 
-    public static <R extends ProtobufTransportRequest> ProtobufRequestHandlerRegistry<R> replaceHandler(
+    public static <R extends TransportRequest> ProtobufRequestHandlerRegistry<R> replaceHandler(
         ProtobufRequestHandlerRegistry<R> registry,
         ProtobufTransportRequestHandler<R> handler
     ) {
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufSendRequestTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufSendRequestTransportException.java
index 0281f1c530a44..88abf8e1bc4f1 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufSendRequestTransportException.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufSendRequestTransportException.java
@@ -22,7 +22,7 @@
 public class ProtobufSendRequestTransportException extends ProtobufActionTransportException implements OpenSearchWrapperException {
 
     public ProtobufSendRequestTransportException(DiscoveryNode node, String action, Throwable cause) {
-        super(node == null ? null : node.getName(), node == null ? null : node.getProtobufAddress(), action, cause);
+        super(node == null ? null : node.getName(), node == null ? null : node.getAddress(), action, cause);
     }
 
     public ProtobufSendRequestTransportException(CodedInputStream in) throws IOException {
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java
index edf73810a43c2..3c4fb1208120c 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java
@@ -27,6 +27,7 @@
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.transport.TransportAddress;
@@ -130,8 +131,8 @@ public class ProtobufSniffConnectionStrategy extends ProtobufRemoteConnectionStr
 
     ProtobufSniffConnectionStrategy(
         String clusterAlias,
-        ProtobufTransportService transportService,
-        ProtobufRemoteConnectionManager connectionManager,
+        TransportService transportService,
+        RemoteConnectionManager connectionManager,
         Settings settings
     ) {
         this(
@@ -148,8 +149,8 @@ public class ProtobufSniffConnectionStrategy extends ProtobufRemoteConnectionStr
 
     ProtobufSniffConnectionStrategy(
         String clusterAlias,
-        ProtobufTransportService transportService,
-        ProtobufRemoteConnectionManager connectionManager,
+        TransportService transportService,
+        RemoteConnectionManager connectionManager,
         String proxyAddress,
         Settings settings,
         int maxNumRemoteConnections,
@@ -173,8 +174,8 @@ public class ProtobufSniffConnectionStrategy extends ProtobufRemoteConnectionStr
 
     ProtobufSniffConnectionStrategy(
         String clusterAlias,
-        ProtobufTransportService transportService,
-        ProtobufRemoteConnectionManager connectionManager,
+        TransportService transportService,
+        RemoteConnectionManager connectionManager,
         String proxyAddress,
         Settings settings,
         int maxNumRemoteConnections,
@@ -256,16 +257,16 @@ private void collectRemoteNodes(Iterator<Supplier<DiscoveryNode>> seedNodes, Act
 
             final DiscoveryNode seedNode = seedNodes.next().get();
             logger.trace("[{}] opening transient connection to seed node: [{}]", clusterAlias, seedNode);
-            final StepListener<Transport.ProtobufConnection> openConnectionStep = new StepListener<>();
+            final StepListener<Transport.Connection> openConnectionStep = new StepListener<>();
             try {
                 connectionManager.openConnection(seedNode, null, openConnectionStep);
             } catch (Exception e) {
                 onFailure.accept(e);
             }
 
-            final StepListener<ProtobufTransportService.HandshakeResponse> handshakeStep = new StepListener<>();
+            final StepListener<TransportService.HandshakeResponse> handshakeStep = new StepListener<>();
             openConnectionStep.whenComplete(connection -> {
-                ProtobufConnectionProfile connectionProfile = connectionManager.getConnectionProfile();
+                ConnectionProfile connectionProfile = connectionManager.getConnectionProfile();
                 transportService.handshake(
                     connection,
                     connectionProfile.getHandshakeTimeout().millis(),
@@ -296,7 +297,7 @@ private void collectRemoteNodes(Iterator<Supplier<DiscoveryNode>> seedNodes, Act
                     fullConnectionStep.onResponse(null);
                 }
             }, e -> {
-                final Transport.ProtobufConnection connection = openConnectionStep.result();
+                final Transport.Connection connection = openConnectionStep.result();
                 final DiscoveryNode node = connection.getNode();
                 logger.debug(() -> new ParameterizedMessage("[{}] failed to handshake with seed node: [{}]", clusterAlias, node), e);
                 IOUtils.closeWhileHandlingException(connection);
@@ -305,11 +306,11 @@ private void collectRemoteNodes(Iterator<Supplier<DiscoveryNode>> seedNodes, Act
 
             fullConnectionStep.whenComplete(aVoid -> {
                 if (remoteClusterName.get() == null) {
-                    ProtobufTransportService.HandshakeResponse handshakeResponse = handshakeStep.result();
+                    TransportService.HandshakeResponse handshakeResponse = handshakeStep.result();
                     assert handshakeResponse.getClusterName().value() != null;
                     remoteClusterName.set(handshakeResponse.getClusterName());
                 }
-                final Transport.ProtobufConnection connection = openConnectionStep.result();
+                final Transport.Connection connection = openConnectionStep.result();
 
                 ProtobufClusterStateRequest request = new ProtobufClusterStateRequest();
                 request.clear();
@@ -319,8 +320,8 @@ private void collectRemoteNodes(Iterator<Supplier<DiscoveryNode>> seedNodes, Act
                 // due to an already closed connection.
                 ThreadPool threadPool = transportService.getThreadPool();
                 ThreadContext threadContext = threadPool.getThreadContext();
-                ProtobufTransportService.ContextRestoreResponseHandler<ProtobufClusterStateResponse> responseHandler =
-                    new ProtobufTransportService.ContextRestoreResponseHandler<>(
+                TransportService.ContextRestoreResponseHandler<ProtobufClusterStateResponse> responseHandler =
+                    new TransportService.ContextRestoreResponseHandler<>(
                         threadContext.newRestorableContext(false),
                         new SniffClusterStateResponseHandler(connection, listener, seedNodes)
                     );
@@ -337,7 +338,7 @@ private void collectRemoteNodes(Iterator<Supplier<DiscoveryNode>> seedNodes, Act
                     );
                 }
             }, e -> {
-                final Transport.ProtobufConnection connection = openConnectionStep.result();
+                final Transport.Connection connection = openConnectionStep.result();
                 final DiscoveryNode node = connection.getNode();
                 logger.debug(
                     () -> new ParameterizedMessage("[{}] failed to open managed connection to seed node: [{}]", clusterAlias, node),
@@ -352,14 +353,14 @@ private void collectRemoteNodes(Iterator<Supplier<DiscoveryNode>> seedNodes, Act
     }
 
     /* This class handles the _state response from the remote cluster when sniffing nodes to connect to */
-    private class SniffClusterStateResponseHandler implements ProtobufTransportResponseHandler<ProtobufClusterStateResponse> {
+    private class SniffClusterStateResponseHandler implements TransportResponseHandler<ProtobufClusterStateResponse> {
 
-        private final Transport.ProtobufConnection connection;
+        private final Transport.Connection connection;
         private final ActionListener<Void> listener;
         private final Iterator<Supplier<DiscoveryNode>> seedNodes;
 
         SniffClusterStateResponseHandler(
-            Transport.ProtobufConnection connection,
+            Transport.Connection connection,
             ActionListener<Void> listener,
             Iterator<Supplier<DiscoveryNode>> seedNodes
         ) {
@@ -435,7 +436,7 @@ public void onFailure(Exception e) {
         }
 
         @Override
-        public void handleException(ProtobufTransportException exp) {
+        public void handleExceptionProtobuf(ProtobufTransportException exp) {
             logger.warn(new ParameterizedMessage("fetching nodes from external cluster {} failed", clusterAlias), exp);
             try {
                 IOUtils.closeWhileHandlingException(connection);
@@ -449,6 +450,18 @@ public void handleException(ProtobufTransportException exp) {
         public String executor() {
             return ThreadPool.Names.MANAGEMENT;
         }
+
+        @Override
+        public ProtobufClusterStateResponse read(StreamInput in) throws IOException {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'read'");
+        }
+
+        @Override
+        public void handleException(TransportException exp) {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'handleException'");
+        }
     }
 
     private Predicate<ClusterName> getRemoteClusterNamePredicate() {
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTaskTransportChannel.java b/server/src/main/java/org/opensearch/transport/ProtobufTaskTransportChannel.java
index 4e4851331de12..72927d10b26d7 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTaskTransportChannel.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTaskTransportChannel.java
@@ -1,67 +1,67 @@
-/*
-* 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.
-*/
+// /*
+// * 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.
+// */
 
-package org.opensearch.transport;
+// package org.opensearch.transport;
 
-import org.opensearch.Version;
-import org.opensearch.common.lease.Releasable;
+// import org.opensearch.Version;
+// import org.opensearch.common.lease.Releasable;
 
-import java.io.IOException;
+// import java.io.IOException;
 
-/**
- * Transport channel for tasks
-*
-* @opensearch.internal
-*/
-public class ProtobufTaskTransportChannel implements ProtobufTransportChannel {
+// /**
+//  * Transport channel for tasks
+// *
+// * @opensearch.internal
+// */
+// public class ProtobufTaskTransportChannel implements ProtobufTransportChannel {
 
-    private final ProtobufTransportChannel channel;
-    private final Releasable onTaskFinished;
+//     private final ProtobufTransportChannel channel;
+//     private final Releasable onTaskFinished;
 
-    ProtobufTaskTransportChannel(ProtobufTransportChannel channel, Releasable onTaskFinished) {
-        this.channel = channel;
-        this.onTaskFinished = onTaskFinished;
-    }
+//     ProtobufTaskTransportChannel(ProtobufTransportChannel channel, Releasable onTaskFinished) {
+//         this.channel = channel;
+//         this.onTaskFinished = onTaskFinished;
+//     }
 
-    @Override
-    public String getProfileName() {
-        return channel.getProfileName();
-    }
+//     @Override
+//     public String getProfileName() {
+//         return channel.getProfileName();
+//     }
 
-    @Override
-    public String getChannelType() {
-        return channel.getChannelType();
-    }
+//     @Override
+//     public String getChannelType() {
+//         return channel.getChannelType();
+//     }
 
-    @Override
-    public void sendResponse(ProtobufTransportResponse response) throws IOException {
-        try {
-            onTaskFinished.close();
-        } finally {
-            channel.sendResponse(response);
-        }
-    }
+//     @Override
+//     public void sendResponse(TransportResponse response) throws IOException {
+//         try {
+//             onTaskFinished.close();
+//         } finally {
+//             channel.sendResponse(response);
+//         }
+//     }
 
-    @Override
-    public void sendResponse(Exception exception) throws IOException {
-        try {
-            onTaskFinished.close();
-        } finally {
-            channel.sendResponse(exception);
-        }
-    }
+//     @Override
+//     public void sendResponse(Exception exception) throws IOException {
+//         try {
+//             onTaskFinished.close();
+//         } finally {
+//             channel.sendResponse(exception);
+//         }
+//     }
 
-    @Override
-    public Version getVersion() {
-        return channel.getVersion();
-    }
+//     @Override
+//     public Version getVersion() {
+//         return channel.getVersion();
+//     }
 
-    public ProtobufTransportChannel getChannel() {
-        return channel;
-    }
-}
+//     public ProtobufTransportChannel getChannel() {
+//         return channel;
+//     }
+// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTcpTransportChannel.java b/server/src/main/java/org/opensearch/transport/ProtobufTcpTransportChannel.java
index 03daaec9409a9..e098801534237 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTcpTransportChannel.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTcpTransportChannel.java
@@ -1,110 +1,110 @@
-/*
-* 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.
-*/
+// /*
+// * 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.
+// */
 
-package org.opensearch.transport;
+// package org.opensearch.transport;
 
-import org.opensearch.Version;
-import org.opensearch.common.lease.Releasable;
-import java.io.IOException;
-import java.util.Set;
-import java.util.concurrent.atomic.AtomicBoolean;
+// import org.opensearch.Version;
+// import org.opensearch.common.lease.Releasable;
+// import java.io.IOException;
+// import java.util.Set;
+// import java.util.concurrent.atomic.AtomicBoolean;
 
-/**
- * Channel for a TCP connection
-*
-* @opensearch.internal
-*/
-public final class ProtobufTcpTransportChannel implements ProtobufTransportChannel {
+// /**
+//  * Channel for a TCP connection
+// *
+// * @opensearch.internal
+// */
+// public final class ProtobufTcpTransportChannel implements ProtobufTransportChannel {
 
-    private final AtomicBoolean released = new AtomicBoolean();
-    private final ProtobufOutboundHandler outboundHandler;
-    private final TcpChannel channel;
-    private final String action;
-    private final long requestId;
-    private final Version version;
-    private final Set<String> features;
-    private final boolean compressResponse;
-    private final boolean isHandshake;
-    private final Releasable breakerRelease;
+//     private final AtomicBoolean released = new AtomicBoolean();
+//     private final ProtobufOutboundHandler outboundHandler;
+//     private final TcpChannel channel;
+//     private final String action;
+//     private final long requestId;
+//     private final Version version;
+//     private final Set<String> features;
+//     private final boolean compressResponse;
+//     private final boolean isHandshake;
+//     private final Releasable breakerRelease;
 
-    ProtobufTcpTransportChannel(
-        ProtobufOutboundHandler outboundHandler,
-        TcpChannel channel,
-        String action,
-        long requestId,
-        Version version,
-        Set<String> features,
-        boolean compressResponse,
-        boolean isHandshake,
-        Releasable breakerRelease
-    ) {
-        this.version = version;
-        this.features = features;
-        this.channel = channel;
-        this.outboundHandler = outboundHandler;
-        this.action = action;
-        this.requestId = requestId;
-        this.compressResponse = compressResponse;
-        this.isHandshake = isHandshake;
-        this.breakerRelease = breakerRelease;
-    }
+//     ProtobufTcpTransportChannel(
+//         ProtobufOutboundHandler outboundHandler,
+//         TcpChannel channel,
+//         String action,
+//         long requestId,
+//         Version version,
+//         Set<String> features,
+//         boolean compressResponse,
+//         boolean isHandshake,
+//         Releasable breakerRelease
+//     ) {
+//         this.version = version;
+//         this.features = features;
+//         this.channel = channel;
+//         this.outboundHandler = outboundHandler;
+//         this.action = action;
+//         this.requestId = requestId;
+//         this.compressResponse = compressResponse;
+//         this.isHandshake = isHandshake;
+//         this.breakerRelease = breakerRelease;
+//     }
 
-    @Override
-    public String getProfileName() {
-        return channel.getProfile();
-    }
+//     @Override
+//     public String getProfileName() {
+//         return channel.getProfile();
+//     }
 
-    @Override
-    public void sendResponse(ProtobufTransportResponse response) throws IOException {
-        try {
-            // if (response instanceof QuerySearchResult && ((QuerySearchResult) response).getShardSearchRequest() != null) {
-            // // update outbound network time with current time before sending response over network
-            // ((QuerySearchResult) response).getShardSearchRequest().setOutboundNetworkTime(System.currentTimeMillis());
-            // }
-            outboundHandler.sendResponse(version, features, channel, requestId, action, response, compressResponse, isHandshake);
-        } finally {
-            release(false);
-        }
-    }
+//     @Override
+//     public void sendResponse(TransportResponse response) throws IOException {
+//         try {
+//             // if (response instanceof QuerySearchResult && ((QuerySearchResult) response).getShardSearchRequest() != null) {
+//             // // update outbound network time with current time before sending response over network
+//             // ((QuerySearchResult) response).getShardSearchRequest().setOutboundNetworkTime(System.currentTimeMillis());
+//             // }
+//             outboundHandler.sendResponse(version, features, channel, requestId, action, response, compressResponse, isHandshake);
+//         } finally {
+//             release(false);
+//         }
+//     }
 
-    @Override
-    public void sendResponse(Exception exception) throws IOException {
-        try {
-            outboundHandler.sendErrorResponse(version, features, channel, requestId, action, exception);
-        } finally {
-            release(true);
-        }
-    }
+//     @Override
+//     public void sendResponse(Exception exception) throws IOException {
+//         try {
+//             outboundHandler.sendErrorResponse(version, features, channel, requestId, action, exception);
+//         } finally {
+//             release(true);
+//         }
+//     }
 
-    private Exception releaseBy;
+//     private Exception releaseBy;
 
-    private void release(boolean isExceptionResponse) {
-        if (released.compareAndSet(false, true)) {
-            assert (releaseBy = new Exception()) != null; // easier to debug if it's already closed
-            breakerRelease.close();
-        } else if (isExceptionResponse == false) {
-            // only fail if we are not sending an error - we might send the error triggered by the previous
-            // sendResponse call
-            throw new IllegalStateException("reserved bytes are already released", releaseBy);
-        }
-    }
+//     private void release(boolean isExceptionResponse) {
+//         if (released.compareAndSet(false, true)) {
+//             assert (releaseBy = new Exception()) != null; // easier to debug if it's already closed
+//             breakerRelease.close();
+//         } else if (isExceptionResponse == false) {
+//             // only fail if we are not sending an error - we might send the error triggered by the previous
+//             // sendResponse call
+//             throw new IllegalStateException("reserved bytes are already released", releaseBy);
+//         }
+//     }
 
-    @Override
-    public String getChannelType() {
-        return "transport";
-    }
+//     @Override
+//     public String getChannelType() {
+//         return "transport";
+//     }
 
-    @Override
-    public Version getVersion() {
-        return version;
-    }
+//     @Override
+//     public Version getVersion() {
+//         return version;
+//     }
 
-    public TcpChannel getChannel() {
-        return channel;
-    }
-}
+//     public TcpChannel getChannel() {
+//         return channel;
+//     }
+// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java
index 22e52438a8e99..ffeb0aae71ea7 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java
@@ -12,6 +12,7 @@
 import com.google.protobuf.CodedOutputStream;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.tasks.ProtobufTask;
 import org.opensearch.threadpool.ThreadPool;
 
@@ -37,14 +38,14 @@ private ProtobufTransportActionProxy() {} // no instance
     */
     private static class ProxyRequestHandler<T extends ProxyRequest> implements ProtobufTransportRequestHandler<T> {
 
-        private final ProtobufTransportService service;
+        private final TransportService service;
         private final String action;
-        private final Function<ProtobufTransportRequest, ProtobufWriteable.Reader<? extends ProtobufTransportResponse>> responseFunction;
+        private final Function<TransportRequest, ProtobufWriteable.Reader<? extends TransportResponse>> responseFunction;
 
         ProxyRequestHandler(
-            ProtobufTransportService service,
+            TransportService service,
             String action,
-            Function<ProtobufTransportRequest, ProtobufWriteable.Reader<? extends ProtobufTransportResponse>> responseFunction
+            Function<TransportRequest, ProtobufWriteable.Reader<? extends TransportResponse>> responseFunction
         ) {
             this.service = service;
             this.action = action;
@@ -52,9 +53,9 @@ private static class ProxyRequestHandler<T extends ProxyRequest> implements Prot
         }
 
         @Override
-        public void messageReceived(T request, ProtobufTransportChannel channel, ProtobufTask task) throws Exception {
+        public void messageReceived(T request, TransportChannel channel, ProtobufTask task) throws Exception {
             DiscoveryNode targetNode = request.targetNode;
-            ProtobufTransportRequest wrappedRequest = request.wrapped;
+            TransportRequest wrappedRequest = request.wrapped;
             service.sendRequest(
                 targetNode,
                 action,
@@ -69,12 +70,12 @@ public void messageReceived(T request, ProtobufTransportChannel channel, Protobu
     *
     * @opensearch.internal
     */
-    private static class ProxyResponseHandler<T extends ProtobufTransportResponse> implements ProtobufTransportResponseHandler<T> {
+    private static class ProxyResponseHandler<T extends TransportResponse> implements TransportResponseHandler<T> {
 
         private final ProtobufWriteable.Reader<T> reader;
-        private final ProtobufTransportChannel channel;
+        private final TransportChannel channel;
 
-        ProxyResponseHandler(ProtobufTransportChannel channel, ProtobufWriteable.Reader<T> reader) {
+        ProxyResponseHandler(TransportChannel channel, ProtobufWriteable.Reader<T> reader) {
             this.reader = reader;
             this.channel = channel;
         }
@@ -94,7 +95,7 @@ public void handleResponse(T response) {
         }
 
         @Override
-        public void handleException(ProtobufTransportException exp) {
+        public void handleExceptionProtobuf(ProtobufTransportException exp) {
             try {
                 channel.sendResponse(exp);
             } catch (IOException e) {
@@ -106,6 +107,18 @@ public void handleException(ProtobufTransportException exp) {
         public String executor() {
             return ThreadPool.Names.SAME;
         }
+
+        @Override
+        public T read(StreamInput in) throws IOException {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'read'");
+        }
+
+        @Override
+        public void handleException(TransportException exp) {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'handleException'");
+        }
     }
 
     /**
@@ -113,7 +126,7 @@ public String executor() {
     *
     * @opensearch.internal
     */
-    static class ProxyRequest<T extends ProtobufTransportRequest> extends ProtobufTransportRequest {
+    static class ProxyRequest<T extends TransportRequest> extends TransportRequest {
         final T wrapped;
         final DiscoveryNode targetNode;
 
@@ -141,12 +154,12 @@ public void writeTo(CodedOutputStream out) throws IOException {
     * response type changes based on the upcoming request (quite rare)
     */
     public static void registerProxyActionWithDynamicResponseType(
-        ProtobufTransportService service,
+        TransportService service,
         String action,
-        Function<ProtobufTransportRequest, ProtobufWriteable.Reader<? extends ProtobufTransportResponse>> responseFunction
+        Function<TransportRequest, ProtobufWriteable.Reader<? extends TransportResponse>> responseFunction
     ) {
-        ProtobufRequestHandlerRegistry<? extends ProtobufTransportRequest> requestHandler = service.getRequestHandler(action);
-        service.registerRequestHandler(
+        ProtobufRequestHandlerRegistry<? extends TransportRequest> requestHandler = service.getRequestHandlerProtobuf(action);
+        service.registerRequestHandlerProtobuf(
             getProxyAction(action),
             ThreadPool.Names.SAME,
             true,
@@ -161,12 +174,12 @@ public static void registerProxyActionWithDynamicResponseType(
     * response type is always the same (most of the cases).
     */
     public static void registerProxyAction(
-        ProtobufTransportService service,
+        TransportService service,
         String action,
-        ProtobufWriteable.Reader<? extends ProtobufTransportResponse> reader
+        ProtobufWriteable.Reader<? extends TransportResponse> reader
     ) {
-        ProtobufRequestHandlerRegistry<? extends ProtobufTransportRequest> requestHandler = service.getRequestHandler(action);
-        service.registerRequestHandler(
+        ProtobufRequestHandlerRegistry<? extends TransportRequest> requestHandler = service.getRequestHandlerProtobuf(action);
+        service.registerRequestHandlerProtobuf(
             getProxyAction(action),
             ThreadPool.Names.SAME,
             true,
@@ -188,14 +201,14 @@ public static String getProxyAction(String action) {
     /**
      * Wraps the actual request in a proxy request object that encodes the target node.
     */
-    public static ProtobufTransportRequest wrapRequest(DiscoveryNode node, ProtobufTransportRequest request) {
+    public static TransportRequest wrapRequest(DiscoveryNode node, TransportRequest request) {
         return new ProxyRequest<>(request, node);
     }
 
     /**
      * Unwraps a proxy request and returns the original request
     */
-    public static ProtobufTransportRequest unwrapRequest(ProtobufTransportRequest request) {
+    public static TransportRequest unwrapRequest(TransportRequest request) {
         if (request instanceof ProxyRequest) {
             return ((ProxyRequest) request).wrapped;
         }
@@ -220,7 +233,7 @@ public static boolean isProxyAction(String action) {
     /**
      * Returns <code>true</code> iff the given request is a proxy request
     */
-    public static boolean isProxyRequest(ProtobufTransportRequest request) {
+    public static boolean isProxyRequest(TransportRequest request) {
         return request instanceof ProxyRequest;
     }
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportChannel.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportChannel.java
index f9eac58f4e246..36148be7bd662 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportChannel.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportChannel.java
@@ -1,56 +1,56 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.message.ParameterizedMessage;
-import org.opensearch.Version;
-
-import java.io.IOException;
-
-/**
- * A transport channel allows to send a response to a request on the channel.
-*
-* @opensearch.internal
-*/
-public interface ProtobufTransportChannel {
-
-    Logger logger = LogManager.getLogger(ProtobufTransportChannel.class);
-
-    String getProfileName();
-
-    String getChannelType();
-
-    void sendResponse(ProtobufTransportResponse response) throws IOException;
-
-    void sendResponse(Exception exception) throws IOException;
-
-    /**
-     * Returns the version of the other party that this channel will send a response to.
-    */
-    default Version getVersion() {
-        return Version.CURRENT;
-    }
-
-    /**
-     * A helper method to send an exception and handle and log a subsequent exception
-    */
-    static void sendErrorResponse(ProtobufTransportChannel channel, String actionName, ProtobufTransportRequest request, Exception e) {
-        try {
-            channel.sendResponse(e);
-        } catch (Exception sendException) {
-            sendException.addSuppressed(e);
-            logger.warn(
-                () -> new ParameterizedMessage("Failed to send error response for action [{}] and request [{}]", actionName, request),
-                sendException
-            );
-        }
-    }
-}
+// /*
+// * 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.
+// */
+
+// package org.opensearch.transport;
+
+// import org.apache.logging.log4j.LogManager;
+// import org.apache.logging.log4j.Logger;
+// import org.apache.logging.log4j.message.ParameterizedMessage;
+// import org.opensearch.Version;
+
+// import java.io.IOException;
+
+// /**
+//  * A transport channel allows to send a response to a request on the channel.
+// *
+// * @opensearch.internal
+// */
+// public interface ProtobufTransportChannel {
+
+//     Logger logger = LogManager.getLogger(ProtobufTransportChannel.class);
+
+//     String getProfileName();
+
+//     String getChannelType();
+
+//     void sendResponse(TransportResponse response) throws IOException;
+
+//     void sendResponse(Exception exception) throws IOException;
+
+//     /**
+//      * Returns the version of the other party that this channel will send a response to.
+//     */
+//     default Version getVersion() {
+//         return Version.CURRENT;
+//     }
+
+//     /**
+//      * A helper method to send an exception and handle and log a subsequent exception
+//     */
+//     static void sendErrorResponse(ProtobufTransportChannel channel, String actionName, TransportRequest request, Exception e) {
+//         try {
+//             channel.sendResponse(e);
+//         } catch (Exception sendException) {
+//             sendException.addSuppressed(e);
+//             logger.warn(
+//                 () -> new ParameterizedMessage("Failed to send error response for action [{}] and request [{}]", actionName, request),
+//                 sendException
+//             );
+//         }
+//     }
+// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java
index 228a5dfe5367e..75481d6eaa6d1 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java
@@ -1,43 +1,43 @@
-/*
-* 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.
-*/
+// /*
+// * 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.
+// */
 
-package org.opensearch.transport;
+// package org.opensearch.transport;
 
-import org.opensearch.cluster.node.DiscoveryNode;
+// import org.opensearch.cluster.node.DiscoveryNode;
 
-/**
- * A listener interface that allows to react on transport events. All methods may be
-* executed on network threads. Consumers must fork in the case of long running or blocking
-* operations.
-*
-* @opensearch.internal
-*/
-public interface ProtobufTransportConnectionListener {
+// /**
+//  * A listener interface that allows to react on transport events. All methods may be
+// * executed on network threads. Consumers must fork in the case of long running or blocking
+// * operations.
+// *
+// * @opensearch.internal
+// */
+// public interface ProtobufTransportConnectionListener {
 
-    /**
-     * Called once a connection was opened
-    * @param connection the connection
-    */
-    default void onConnectionOpened(Transport.ProtobufConnection connection) {}
+//     /**
+//      * Called once a connection was opened
+//     * @param connection the connection
+//     */
+//     default void onConnectionOpened(Transport.Connection connection) {}
 
-    /**
-     * Called once a connection ws closed.
-    * @param connection the closed connection
-    */
-    default void onConnectionClosed(Transport.ProtobufConnection connection) {}
+//     /**
+//      * Called once a connection ws closed.
+//     * @param connection the closed connection
+//     */
+//     default void onConnectionClosed(Transport.Connection connection) {}
 
-    /**
-     * Called once a node connection is opened and registered.
-    */
-    default void onNodeConnected(DiscoveryNode node, Transport.ProtobufConnection connection) {}
+//     /**
+//      * Called once a node connection is opened and registered.
+//     */
+//     default void onNodeConnected(DiscoveryNode node, Transport.Connection connection) {}
 
-    /**
-     * Called once a node connection is closed and unregistered.
-    */
-    default void onNodeDisconnected(DiscoveryNode node, Transport.ProtobufConnection connection) {}
-}
+//     /**
+//      * Called once a node connection is closed and unregistered.
+//     */
+//     default void onNodeDisconnected(DiscoveryNode node, Transport.Connection connection) {}
+// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportInfo.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportInfo.java
index ff3dc3bb434ad..b7dcf9ab402a3 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportInfo.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportInfo.java
@@ -18,9 +18,8 @@
 import org.opensearch.common.Nullable;
 import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.network.InetAddresses;
-import org.opensearch.common.transport.ProtobufBoundTransportAddress;
-import org.opensearch.common.transport.ProtobufTransportAddress;
-import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.node.ProtobufReportingService;
 
@@ -45,20 +44,20 @@ public class ProtobufTransportInfo implements ProtobufReportingService.ProtobufI
         false
     );
 
-    private final ProtobufBoundTransportAddress address;
-    private Map<String, ProtobufBoundTransportAddress> profileAddresses;
+    private final BoundTransportAddress address;
+    private Map<String, BoundTransportAddress> profileAddresses;
     private final boolean cnameInPublishAddress;
 
     public ProtobufTransportInfo(
-        ProtobufBoundTransportAddress address,
-        @Nullable Map<String, ProtobufBoundTransportAddress> profileAddresses
+        BoundTransportAddress address,
+        @Nullable Map<String, BoundTransportAddress> profileAddresses
     ) {
         this(address, profileAddresses, CNAME_IN_PUBLISH_ADDRESS);
     }
 
     public ProtobufTransportInfo(
-        ProtobufBoundTransportAddress address,
-        @Nullable Map<String, ProtobufBoundTransportAddress> profileAddresses,
+        BoundTransportAddress address,
+        @Nullable Map<String, BoundTransportAddress> profileAddresses,
         boolean cnameInPublishAddress
     ) {
         this.address = address;
@@ -67,13 +66,13 @@ public ProtobufTransportInfo(
     }
 
     public ProtobufTransportInfo(CodedInputStream in) throws IOException {
-        address = new ProtobufBoundTransportAddress(in);
+        address = new BoundTransportAddress(in);
         int size = in.readInt32();
         if (size > 0) {
             profileAddresses = new HashMap<>(size);
             for (int i = 0; i < size; i++) {
                 String key = in.readString();
-                ProtobufBoundTransportAddress value = new ProtobufBoundTransportAddress(in);
+                BoundTransportAddress value = new BoundTransportAddress(in);
                 profileAddresses.put(key, value);
             }
         }
@@ -89,7 +88,7 @@ public void writeTo(CodedOutputStream out) throws IOException {
             out.writeInt32NoTag(0);
         }
         if (profileAddresses != null && profileAddresses.size() > 0) {
-            for (Map.Entry<String, ProtobufBoundTransportAddress> entry : profileAddresses.entrySet()) {
+            for (Map.Entry<String, BoundTransportAddress> entry : profileAddresses.entrySet()) {
                 out.writeStringNoTag(entry.getKey());
                 entry.getValue().writeTo(out);
             }
@@ -103,7 +102,7 @@ static final class Fields {
         static final String PROFILES = "profiles";
     }
 
-    private String formatPublishAddressString(String propertyName, ProtobufTransportAddress publishAddress) {
+    private String formatPublishAddressString(String propertyName, TransportAddress publishAddress) {
         String publishAddressString = publishAddress.toString();
         String hostString = publishAddress.address().getHostString();
         if (InetAddresses.isInetAddress(hostString) == false) {
@@ -122,19 +121,19 @@ private String formatPublishAddressString(String propertyName, ProtobufTransport
         return publishAddressString;
     }
 
-    public ProtobufBoundTransportAddress address() {
+    public BoundTransportAddress address() {
         return address;
     }
 
-    public ProtobufBoundTransportAddress getAddress() {
+    public BoundTransportAddress getAddress() {
         return address();
     }
 
-    public Map<String, ProtobufBoundTransportAddress> getProfileAddresses() {
+    public Map<String, BoundTransportAddress> getProfileAddresses() {
         return profileAddresses();
     }
 
-    public Map<String, ProtobufBoundTransportAddress> profileAddresses() {
+    public Map<String, BoundTransportAddress> profileAddresses() {
         return profileAddresses;
     }
 
@@ -145,7 +144,7 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         builder.field(Fields.PUBLISH_ADDRESS, formatPublishAddressString("transport.publish_address", address.publishAddress()));
         builder.startObject(Fields.PROFILES);
         if (profileAddresses != null && profileAddresses.size() > 0) {
-            for (Map.Entry<String, ProtobufBoundTransportAddress> entry : profileAddresses.entrySet()) {
+            for (Map.Entry<String, BoundTransportAddress> entry : profileAddresses.entrySet()) {
                 builder.startObject(entry.getKey());
                 builder.array(Fields.BOUND_ADDRESS, (Object[]) entry.getValue().boundAddresses());
                 String propertyName = "transport." + entry.getKey() + ".publish_address";
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java
index e2624a1a16b20..32d9c4bdb7a05 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java
@@ -1,59 +1,59 @@
-/*
-* 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.
-*/
+// /*
+// * 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.
+// */
 
-package org.opensearch.transport;
+// package org.opensearch.transport;
 
-import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.common.io.stream.ProtobufWriteable.Reader;
+// import org.opensearch.cluster.node.DiscoveryNode;
+// import org.opensearch.common.io.stream.ProtobufWriteable.Reader;
 
-/**
- * This interface allows plugins to intercept requests on both the sender and the receiver side.
-*
-* @opensearch.internal
-*/
-public interface ProtobufTransportInterceptor {
-    /**
-     * This is called for each handler that is registered via
-    * {@link ProtobufTransportService#registerRequestHandler(String, String, boolean, boolean, Reader, ProtobufTransportRequestHandler)} or
-    * {@link ProtobufTransportService#registerRequestHandler(String, String, Reader, ProtobufTransportRequestHandler)}. The returned handler is
-    * used instead of the passed in handler. By default the provided handler is returned.
-    */
-    default <T extends ProtobufTransportRequest> ProtobufTransportRequestHandler<T> interceptHandler(
-        String action,
-        String executor,
-        boolean forceExecution,
-        ProtobufTransportRequestHandler<T> actualHandler
-    ) {
-        return actualHandler;
-    }
+// /**
+//  * This interface allows plugins to intercept requests on both the sender and the receiver side.
+// *
+// * @opensearch.internal
+// */
+// public interface ProtobufTransportInterceptor {
+//     /**
+//      * This is called for each handler that is registered via
+//     * {@link ProtobufTransportService#registerRequestHandler(String, String, boolean, boolean, Reader, ProtobufTransportRequestHandler)} or
+//     * {@link ProtobufTransportService#registerRequestHandler(String, String, Reader, ProtobufTransportRequestHandler)}. The returned handler is
+//     * used instead of the passed in handler. By default the provided handler is returned.
+//     */
+//     default <T extends ProtobufTransportRequest> ProtobufTransportRequestHandler<T> interceptHandler(
+//         String action,
+//         String executor,
+//         boolean forceExecution,
+//         ProtobufTransportRequestHandler<T> actualHandler
+//     ) {
+//         return actualHandler;
+//     }
 
-    /**
-     * This is called up-front providing the actual low level {@link AsyncSender} that performs the low level send request.
-    * The returned sender is used to send all requests that come in via
-    * {@link ProtobufTransportService#sendRequest(DiscoveryNode, String, ProtobufTransportRequest, ProtobufTransportResponseHandler)} or
-    * {@link ProtobufTransportService#sendRequest(DiscoveryNode, String, ProtobufTransportRequest, TransportRequestOptions, ProtobufTransportResponseHandler)}.
-    * This allows plugins to perform actions on each send request including modifying the request context etc.
-    */
-    default AsyncSender interceptSender(AsyncSender sender) {
-        return sender;
-    }
+//     /**
+//      * This is called up-front providing the actual low level {@link AsyncSender} that performs the low level send request.
+//     * The returned sender is used to send all requests that come in via
+//     * {@link ProtobufTransportService#sendRequest(DiscoveryNode, String, ProtobufTransportRequest, TransportResponseHandler)} or
+//     * {@link ProtobufTransportService#sendRequest(DiscoveryNode, String, ProtobufTransportRequest, TransportRequestOptions, TransportResponseHandler)}.
+//     * This allows plugins to perform actions on each send request including modifying the request context etc.
+//     */
+//     default AsyncSender interceptSender(AsyncSender sender) {
+//         return sender;
+//     }
 
-    /**
-     * A simple interface to decorate
-    * {@link #sendRequest(Transport.ProtobufConnection, String, ProtobufTransportRequest, TransportRequestOptions, ProtobufTransportResponseHandler)}
-    */
-    interface AsyncSender {
-        <T extends ProtobufTransportResponse> void sendRequest(
-            Transport.ProtobufConnection connection,
-            String action,
-            ProtobufTransportRequest request,
-            TransportRequestOptions options,
-            ProtobufTransportResponseHandler<T> handler
-        );
-    }
-}
+//     /**
+//      * A simple interface to decorate
+//     * {@link #sendRequest(Transport.Connection, String, ProtobufTransportRequest, TransportRequestOptions, TransportResponseHandler)}
+//     */
+//     interface AsyncSender {
+//         <T extends ProtobufTransportResponse> void sendRequest(
+//             Transport.Connection connection,
+//             String action,
+//             ProtobufTransportRequest request,
+//             TransportRequestOptions options,
+//             TransportResponseHandler<T> handler
+//         );
+//     }
+// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportMessage.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportMessage.java
index 0ec5f5cb5de9c..7f5c4e3a66e91 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportMessage.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportMessage.java
@@ -1,45 +1,45 @@
-/*
-* 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.
-*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.transport.TransportAddress;
-
-/**
- * Message over the transport interface with Protobuf serialization.
-*
-* @opensearch.internal
-*/
-public abstract class ProtobufTransportMessage implements ProtobufWriteable {
-
-    private TransportAddress remoteAddress;
-
-    public void remoteAddress(TransportAddress remoteAddress) {
-        this.remoteAddress = remoteAddress;
-    }
-
-    public TransportAddress remoteAddress() {
-        return remoteAddress;
-    }
-
-    /**
-     * Constructs a new empty transport message
-    */
-    public ProtobufTransportMessage() {}
-
-    /**
-     * Constructs a new transport message with the data from the {@link CodedInputStream}. This is
-    * currently a no-op
-    */
-    public ProtobufTransportMessage(CodedInputStream in) {}
-}
+// /*
+// * 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.
+// *
+// * Modifications Copyright OpenSearch Contributors. See
+// * GitHub history for details.
+// */
+
+// package org.opensearch.transport;
+
+// import com.google.protobuf.CodedInputStream;
+// import org.opensearch.common.io.stream.ProtobufWriteable;
+// import org.opensearch.common.transport.TransportAddress;
+
+// /**
+//  * Message over the transport interface with Protobuf serialization.
+// *
+// * @opensearch.internal
+// */
+// public abstract class ProtobufTransportMessage implements ProtobufWriteable {
+
+//     private TransportAddress remoteAddress;
+
+//     public void remoteAddress(TransportAddress remoteAddress) {
+//         this.remoteAddress = remoteAddress;
+//     }
+
+//     public TransportAddress remoteAddress() {
+//         return remoteAddress;
+//     }
+
+//     /**
+//      * Constructs a new empty transport message
+//     */
+//     public ProtobufTransportMessage() {}
+
+//     /**
+//      * Constructs a new transport message with the data from the {@link CodedInputStream}. This is
+//     * currently a no-op
+//     */
+//     public ProtobufTransportMessage(CodedInputStream in) {}
+// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java
index d0167c8c61570..e71726a8b6435 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java
@@ -1,69 +1,69 @@
-/*
-* 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.
-*/
+// /*
+// * 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.
+// */
 
-package org.opensearch.transport;
+// package org.opensearch.transport;
 
-import org.opensearch.cluster.node.DiscoveryNode;
+// import org.opensearch.cluster.node.DiscoveryNode;
 
-/**
- * Listens for transport messages
-*
-* @opensearch.internal
-*/
-public interface ProtobufTransportMessageListener {
+// /**
+//  * Listens for transport messages
+// *
+// * @opensearch.internal
+// */
+// public interface ProtobufTransportMessageListener {
 
-    ProtobufTransportMessageListener NOOP_LISTENER = new ProtobufTransportMessageListener() {
-    };
+//     ProtobufTransportMessageListener NOOP_LISTENER = new ProtobufTransportMessageListener() {
+//     };
 
-    /**
-     * Called once a request is received
-    * @param requestId the internal request ID
-    * @param action the request action
-    *
-    */
-    default void onRequestReceived(long requestId, String action) {}
+//     /**
+//      * Called once a request is received
+//     * @param requestId the internal request ID
+//     * @param action the request action
+//     *
+//     */
+//     default void onRequestReceived(long requestId, String action) {}
 
-    /**
-     * Called for every action response sent after the response has been passed to the underlying network implementation.
-    * @param requestId the request ID (unique per client)
-    * @param action the request action
-    * @param response the response send
-    */
-    default void onResponseSent(long requestId, String action, ProtobufTransportResponse response) {}
+//     /**
+//      * Called for every action response sent after the response has been passed to the underlying network implementation.
+//     * @param requestId the request ID (unique per client)
+//     * @param action the request action
+//     * @param response the response send
+//     */
+//     default void onResponseSent(long requestId, String action, TransportResponse response) {}
 
-    /***
-     * Called for every failed action response after the response has been passed to the underlying network implementation.
-    * @param requestId the request ID (unique per client)
-    * @param action the request action
-    * @param error the error sent back to the caller
-    */
-    default void onResponseSent(long requestId, String action, Exception error) {}
+//     /***
+//      * Called for every failed action response after the response has been passed to the underlying network implementation.
+//     * @param requestId the request ID (unique per client)
+//     * @param action the request action
+//     * @param error the error sent back to the caller
+//     */
+//     default void onResponseSent(long requestId, String action, Exception error) {}
 
-    /**
-     * Called for every request sent to a server after the request has been passed to the underlying network implementation
-    * @param node the node the request was sent to
-    * @param requestId the internal request id
-    * @param action the action name
-    * @param request the actual request
-    * @param finalOptions the request options
-    */
-    default void onRequestSent(
-        DiscoveryNode node,
-        long requestId,
-        String action,
-        ProtobufTransportRequest request,
-        TransportRequestOptions finalOptions
-    ) {}
+//     /**
+//      * Called for every request sent to a server after the request has been passed to the underlying network implementation
+//     * @param node the node the request was sent to
+//     * @param requestId the internal request id
+//     * @param action the action name
+//     * @param request the actual request
+//     * @param finalOptions the request options
+//     */
+//     default void onRequestSent(
+//         DiscoveryNode node,
+//         long requestId,
+//         String action,
+//         TransportRequest request,
+//         TransportRequestOptions finalOptions
+//     ) {}
 
-    /**
-     * Called for every response received
-    * @param requestId the request id for this reponse
-    * @param context the response context or null if the context was already processed ie. due to a timeout.
-    */
-    default void onResponseReceived(long requestId, Transport.ProtobufResponseContext context) {}
-}
+//     /**
+//      * Called for every response received
+//     * @param requestId the request id for this reponse
+//     * @param context the response context or null if the context was already processed ie. due to a timeout.
+//     */
+//     default void onResponseReceived(long requestId, Transport.ProtobufResponseContext context) {}
+// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportRequest.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportRequest.java
index 3511655702a89..c09bddc320a85 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportRequest.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportRequest.java
@@ -1,60 +1,60 @@
-/*
-* 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.
-*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.tasks.ProtobufTaskId;
-import org.opensearch.tasks.ProtobufTaskAwareRequest;
-import org.opensearch.tasks.TaskId;
-
-import java.io.IOException;
-
-/**
- * A transport request with Protobuf serialization.
-*
-* @opensearch.internal
-*/
-public abstract class ProtobufTransportRequest extends ProtobufTransportMessage implements ProtobufTaskAwareRequest {
-
-    /**
-     * Parent of this request. Defaults to {@link TaskId#EMPTY_TASK_ID}, meaning "no parent".
-    */
-    private ProtobufTaskId parentTaskId = ProtobufTaskId.EMPTY_TASK_ID;
-
-    public ProtobufTransportRequest() {}
-
-    public ProtobufTransportRequest(CodedInputStream in) throws IOException {
-        parentTaskId = ProtobufTaskId.readFromStream(in);
-    }
-
-    /**
-     * Set a reference to task that created this request.
-    */
-    @Override
-    public void setParentTask(ProtobufTaskId taskId) {
-        this.parentTaskId = taskId;
-    }
-
-    /**
-     * Get a reference to the task that created this request. Defaults to {@link TaskId#EMPTY_TASK_ID}, meaning "there is no parent".
-    */
-    @Override
-    public ProtobufTaskId getParentTask() {
-        return parentTaskId;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        parentTaskId.writeTo(out);
-    }
-}
+// /*
+// * 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.
+// *
+// * Modifications Copyright OpenSearch Contributors. See
+// * GitHub history for details.
+// */
+
+// package org.opensearch.transport;
+
+// import com.google.protobuf.CodedInputStream;
+// import com.google.protobuf.CodedOutputStream;
+// import org.opensearch.tasks.ProtobufTaskId;
+// import org.opensearch.tasks.ProtobufTaskAwareRequest;
+// import org.opensearch.tasks.TaskId;
+
+// import java.io.IOException;
+
+// /**
+//  * A transport request with Protobuf serialization.
+// *
+// * @opensearch.internal
+// */
+// public abstract class ProtobufTransportRequest extends ProtobufTransportMessage implements ProtobufTaskAwareRequest {
+
+//     /**
+//      * Parent of this request. Defaults to {@link TaskId#EMPTY_TASK_ID}, meaning "no parent".
+//     */
+//     private ProtobufTaskId parentTaskId = ProtobufTaskId.EMPTY_TASK_ID;
+
+//     public ProtobufTransportRequest() {}
+
+//     public ProtobufTransportRequest(CodedInputStream in) throws IOException {
+//         parentTaskId = ProtobufTaskId.readFromStream(in);
+//     }
+
+//     /**
+//      * Set a reference to task that created this request.
+//     */
+//     @Override
+//     public void setParentTask(ProtobufTaskId taskId) {
+//         this.parentTaskId = taskId;
+//     }
+
+//     /**
+//      * Get a reference to the task that created this request. Defaults to {@link TaskId#EMPTY_TASK_ID}, meaning "there is no parent".
+//     */
+//     @Override
+//     public ProtobufTaskId getParentTask() {
+//         return parentTaskId;
+//     }
+
+//     @Override
+//     public void writeTo(CodedOutputStream out) throws IOException {
+//         parentTaskId.writeTo(out);
+//     }
+// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportRequestHandler.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportRequestHandler.java
index abfc5c91e7645..3feb88696a51a 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportRequestHandler.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportRequestHandler.java
@@ -15,7 +15,7 @@
 *
 * @opensearch.internal
 */
-public interface ProtobufTransportRequestHandler<T extends ProtobufTransportRequest> {
+public interface ProtobufTransportRequestHandler<T extends TransportRequest> {
 
-    void messageReceived(T request, ProtobufTransportChannel channel, ProtobufTask task) throws Exception;
+    void messageReceived(T request, TransportChannel channel, ProtobufTask task) throws Exception;
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportResponse.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportResponse.java
index 9a5a0d90328b3..021e6c4c52ce4 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportResponse.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportResponse.java
@@ -1,59 +1,59 @@
-/*
-* 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.
-*/
-
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.StreamInput;
-
-import java.io.IOException;
-
-/**
- * Response over the transport interface
-*
-* @opensearch.internal
-*/
-public abstract class ProtobufTransportResponse extends ProtobufTransportMessage {
-
-    /**
-     * Constructs a new empty transport response
-    */
-    public ProtobufTransportResponse() {}
-
-    /**
-     * Constructs a new transport response with the data from the {@link StreamInput}. This is
-    * currently a no-op. However, this exists to allow extenders to call <code>super(in)</code>
-    * so that reading can mirror writing where we often call <code>super.writeTo(out)</code>.
-    */
-    public ProtobufTransportResponse(CodedInputStream in) throws IOException {
-        super(in);
-    }
-
-    /**
-     * Empty transport response
-    *
-    * @opensearch.internal
-    */
-    public static class Empty extends ProtobufTransportResponse {
-        public static final Empty INSTANCE = new Empty();
-
-        @Override
-        public String toString() {
-            return "Empty{}";
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {}
-    }
-}
+// /*
+// * 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.
+// */
+
+// /*
+// * Modifications Copyright OpenSearch Contributors. See
+// * GitHub history for details.
+// */
+
+// package org.opensearch.transport;
+
+// import com.google.protobuf.CodedInputStream;
+// import com.google.protobuf.CodedOutputStream;
+// import org.opensearch.common.io.stream.StreamInput;
+
+// import java.io.IOException;
+
+// /**
+//  * Response over the transport interface
+// *
+// * @opensearch.internal
+// */
+// public abstract class ProtobufTransportResponse extends ProtobufTransportMessage {
+
+//     /**
+//      * Constructs a new empty transport response
+//     */
+//     public ProtobufTransportResponse() {}
+
+//     /**
+//      * Constructs a new transport response with the data from the {@link StreamInput}. This is
+//     * currently a no-op. However, this exists to allow extenders to call <code>super(in)</code>
+//     * so that reading can mirror writing where we often call <code>super.writeTo(out)</code>.
+//     */
+//     public ProtobufTransportResponse(CodedInputStream in) throws IOException {
+//         super(in);
+//     }
+
+//     /**
+//      * Empty transport response
+//     *
+//     * @opensearch.internal
+//     */
+//     public static class Empty extends ProtobufTransportResponse {
+//         public static final Empty INSTANCE = new Empty();
+
+//         @Override
+//         public String toString() {
+//             return "Empty{}";
+//         }
+
+//         @Override
+//         public void writeTo(CodedOutputStream out) throws IOException {}
+//     }
+// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportResponseHandler.java
index 6da728b512185..a0c5d0745522e 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportResponseHandler.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportResponseHandler.java
@@ -1,57 +1,57 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-
-import java.io.IOException;
-import java.util.function.Function;
-
-/**
- * Handles transport responses
-*
-* @opensearch.internal
-*/
-public interface ProtobufTransportResponseHandler<T extends ProtobufTransportResponse> extends ProtobufWriteable.Reader<T> {
-
-    void handleResponse(T response);
-
-    void handleException(ProtobufTransportException exp);
-
-    String executor();
-
-    default <Q extends ProtobufTransportResponse> ProtobufTransportResponseHandler<Q> wrap(
-        Function<Q, T> converter,
-        ProtobufWriteable.Reader<Q> reader
-    ) {
-        final ProtobufTransportResponseHandler<T> self = this;
-        return new ProtobufTransportResponseHandler<Q>() {
-            @Override
-            public void handleResponse(Q response) {
-                self.handleResponse(converter.apply(response));
-            }
-
-            @Override
-            public void handleException(ProtobufTransportException exp) {
-                self.handleException(exp);
-            }
-
-            @Override
-            public String executor() {
-                return self.executor();
-            }
-
-            @Override
-            public Q read(CodedInputStream in) throws IOException {
-                return reader.read(in);
-            }
-        };
-    }
-}
+// /*
+// * 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.
+// */
+
+// package org.opensearch.transport;
+
+// import com.google.protobuf.CodedInputStream;
+// import org.opensearch.common.io.stream.ProtobufWriteable;
+
+// import java.io.IOException;
+// import java.util.function.Function;
+
+// /**
+//  * Handles transport responses
+// *
+// * @opensearch.internal
+// */
+// public interface ProtobufTransportResponseHandler<T extends TransportResponse> extends ProtobufWriteable.Reader<T> {
+
+//     void handleResponse(T response);
+
+//     void handleException(ProtobufTransportException exp);
+
+//     String executor();
+
+//     default <Q extends TransportResponse> ProtobufTransportResponseHandler<Q> wrap(
+//         Function<Q, T> converter,
+//         ProtobufWriteable.Reader<Q> reader
+//     ) {
+//         final ProtobufTransportResponseHandler<T> self = this;
+//         return new ProtobufTransportResponseHandler<Q>() {
+//             @Override
+//             public void handleResponse(Q response) {
+//                 self.handleResponse(converter.apply(response));
+//             }
+
+//             @Override
+//             public void handleException(ProtobufTransportException exp) {
+//                 self.handleException(exp);
+//             }
+
+//             @Override
+//             public String executor() {
+//                 return self.executor();
+//             }
+
+//             @Override
+//             public Q read(CodedInputStream in) throws IOException {
+//                 return reader.read(in);
+//             }
+//         };
+//     }
+// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java
index 3f708b5be1a03..d87e7443a2dfd 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java
@@ -1,1598 +1,1610 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.message.ParameterizedMessage;
-import org.opensearch.Version;
-import org.opensearch.action.ActionListener;
-import org.opensearch.action.ProtobufActionListenerResponseHandler;
-import org.opensearch.action.support.PlainActionFuture;
-import org.opensearch.cluster.ClusterName;
-import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.common.Nullable;
-import org.opensearch.common.Strings;
-import org.opensearch.common.component.AbstractLifecycleComponent;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.lease.Releasable;
-import org.opensearch.common.logging.Loggers;
-import org.opensearch.common.regex.Regex;
-import org.opensearch.common.settings.ClusterSettings;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.ProtobufBoundTransportAddress;
-import org.opensearch.common.transport.ProtobufBoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.common.util.concurrent.AbstractRunnable;
-import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
-import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.common.util.io.IOUtils;
-import org.opensearch.node.ProtobufNodeClosedException;
-import org.opensearch.node.ProtobufReportingService;
-import org.opensearch.tasks.ProtobufTask;
-import org.opensearch.tasks.TaskManager;
-import org.opensearch.threadpool.Scheduler;
-import org.opensearch.threadpool.ThreadPool;
-
-import java.io.IOException;
-import java.io.UncheckedIOException;
-import java.net.UnknownHostException;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.function.Supplier;
-
-/**
- * The main OpenSearch transport service
-*
-* @opensearch.internal
-*/
-public class ProtobufTransportService extends AbstractLifecycleComponent
-    implements
-        ProtobufReportingService<ProtobufTransportInfo>,
-        ProtobufTransportMessageListener,
-        ProtobufTransportConnectionListener {
-    private static final Logger logger = LogManager.getLogger(ProtobufTransportService.class);
-
-    public static final String DIRECT_RESPONSE_PROFILE = ".direct";
-    public static final String HANDSHAKE_ACTION_NAME = "internal:transport/handshake";
-
-    private final AtomicBoolean handleIncomingRequests = new AtomicBoolean();
-    private final DelegatingTransportMessageListener messageListener = new DelegatingTransportMessageListener();
-    protected final Transport transport;
-    protected final ProtobufConnectionManager connectionManager;
-    protected final ThreadPool threadPool;
-    protected final ClusterName clusterName;
-    protected final TaskManager taskManager;
-    private final ProtobufTransportInterceptor.AsyncSender asyncSender;
-    private final Function<ProtobufBoundTransportAddress, DiscoveryNode> localNodeFactory;
-    private final boolean remoteClusterClient;
-    private final Transport.ProtobufResponseHandlers responseHandlers;
-    private final ProtobufTransportInterceptor interceptor;
-
-    // An LRU (don't really care about concurrency here) that holds the latest timed out requests so if they
-    // do show up, we can print more descriptive information about them
-    final Map<Long, TimeoutInfoHolder> timeoutInfoHandlers = Collections.synchronizedMap(
-        new LinkedHashMap<Long, TimeoutInfoHolder>(100, .75F, true) {
-            @Override
-            protected boolean removeEldestEntry(Map.Entry eldest) {
-                return size() > 100;
-            }
-        }
-    );
-
-    public static final ProtobufTransportInterceptor NOOP_TRANSPORT_INTERCEPTOR = new ProtobufTransportInterceptor() {
-    };
-
-    // tracer log
-
-    private final Logger tracerLog;
-
-    volatile String[] tracerLogInclude;
-    volatile String[] tracerLogExclude;
-
-    private final RemoteClusterService remoteClusterService;
-
-    /** if set will call requests sent to this id to shortcut and executed locally */
-    volatile DiscoveryNode localNode = null;
-    private final Transport.ProtobufConnection localNodeConnection = new Transport.ProtobufConnection() {
-        @Override
-        public DiscoveryNode getNode() {
-            return localNode;
-        }
-
-        @Override
-        public void sendRequest(long requestId, String action, ProtobufTransportRequest request, TransportRequestOptions options)
-            throws ProtobufTransportException {
-            sendLocalRequest(requestId, action, request, options);
-        }
-
-        @Override
-        public void addCloseListener(ActionListener<Void> listener) {}
-
-        @Override
-        public boolean isClosed() {
-            return false;
-        }
-
-        @Override
-        public void close() {}
-    };
-
-    /**
-     * Build the service.
-    *
-    * @param clusterSettings if non null, the {@linkplain ProtobufTransportService} will register with the {@link ClusterSettings} for settings
-    *   *    updates for {@link TransportSettings#TRACE_LOG_EXCLUDE_SETTING} and {@link TransportSettings#TRACE_LOG_INCLUDE_SETTING}.
-    */
-    public ProtobufTransportService(
-        Settings settings,
-        Transport transport,
-        ThreadPool threadPool,
-        ProtobufTransportInterceptor transportInterceptor,
-        Function<ProtobufBoundTransportAddress, DiscoveryNode> localNodeFactory,
-        @Nullable ClusterSettings clusterSettings,
-        Set<String> taskHeaders
-    ) {
-        this(
-            settings,
-            transport,
-            threadPool,
-            transportInterceptor,
-            localNodeFactory,
-            clusterSettings,
-            taskHeaders,
-            new ProtobufClusterConnectionManager(settings, transport)
-        );
-    }
-
-    public ProtobufTransportService(
-        Settings settings,
-        Transport transport,
-        ThreadPool threadPool,
-        ProtobufTransportInterceptor transportInterceptor,
-        Function<ProtobufBoundTransportAddress, DiscoveryNode> localNodeFactory,
-        @Nullable ClusterSettings clusterSettings,
-        Set<String> taskHeaders,
-        ProtobufConnectionManager connectionManager
-    ) {
-        this.transport = transport;
-        transport.setSlowLogThreshold(TransportSettings.SLOW_OPERATION_THRESHOLD_SETTING.get(settings));
-        this.threadPool = threadPool;
-        this.localNodeFactory = localNodeFactory;
-        this.connectionManager = connectionManager;
-        this.clusterName = ClusterName.CLUSTER_NAME_SETTING.get(settings);
-        setTracerLogInclude(TransportSettings.TRACE_LOG_INCLUDE_SETTING.get(settings));
-        setTracerLogExclude(TransportSettings.TRACE_LOG_EXCLUDE_SETTING.get(settings));
-        tracerLog = Loggers.getLogger(logger, ".tracer");
-        taskManager = createTaskManager(settings, clusterSettings, threadPool, taskHeaders);
-        this.interceptor = transportInterceptor;
-        this.asyncSender = interceptor.interceptSender(this::sendRequestInternal);
-        this.remoteClusterClient = DiscoveryNode.isRemoteClusterClient(settings);
-        remoteClusterService = new RemoteClusterService(settings, this);
-        responseHandlers = transport.getProtobufResponseHandlers();
-        if (clusterSettings != null) {
-            clusterSettings.addSettingsUpdateConsumer(TransportSettings.TRACE_LOG_INCLUDE_SETTING, this::setTracerLogInclude);
-            clusterSettings.addSettingsUpdateConsumer(TransportSettings.TRACE_LOG_EXCLUDE_SETTING, this::setTracerLogExclude);
-            if (remoteClusterClient) {
-                remoteClusterService.listenForUpdates(clusterSettings);
-            }
-            clusterSettings.addSettingsUpdateConsumer(TransportSettings.SLOW_OPERATION_THRESHOLD_SETTING, transport::setSlowLogThreshold);
-        }
-        registerRequestHandler(
-            HANDSHAKE_ACTION_NAME,
-            ThreadPool.Names.SAME,
-            false,
-            false,
-            HandshakeRequest::new,
-            (request, channel, task) -> channel.sendResponse(new HandshakeResponse(localNode, clusterName, localNode.getVersion()))
-        );
-    }
-
-    public RemoteClusterService getRemoteClusterService() {
-        return remoteClusterService;
-    }
-
-    public DiscoveryNode getLocalNode() {
-        return localNode;
-    }
-
-    public TaskManager getTaskManager() {
-        return taskManager;
-    }
-
-    protected TaskManager createTaskManager(
-        Settings settings,
-        ClusterSettings clusterSettings,
-        ThreadPool threadPool,
-        Set<String> taskHeaders
-    ) {
-        if (clusterSettings != null) {
-            return TaskManager.createTaskManagerWithClusterSettings(settings, clusterSettings, threadPool, taskHeaders);
-        } else {
-            return new TaskManager(settings, threadPool, taskHeaders);
-        }
-    }
-
-    /**
-     * The executor service for this transport service.
-    *
-    * @return the executor service
-    */
-    private ExecutorService getExecutorService() {
-        return threadPool.generic();
-    }
-
-    void setTracerLogInclude(List<String> tracerLogInclude) {
-        this.tracerLogInclude = tracerLogInclude.toArray(Strings.EMPTY_ARRAY);
-    }
-
-    void setTracerLogExclude(List<String> tracerLogExclude) {
-        this.tracerLogExclude = tracerLogExclude.toArray(Strings.EMPTY_ARRAY);
-    }
-
-    @Override
-    protected void doStart() {
-        transport.setMessageListener(this);
-        connectionManager.addListener(this);
-        transport.start();
-        if (transport.boundAddress() != null && logger.isInfoEnabled()) {
-            logger.info("{}", transport.boundAddress());
-            for (Map.Entry<String, ProtobufBoundTransportAddress> entry : transport.profileProtobufBoundAddresses().entrySet()) {
-                logger.info("profile [{}]: {}", entry.getKey(), entry.getValue());
-            }
-        }
-
-        localNode = localNodeFactory.apply(transport.boundProtobufAddress());
-
-        if (remoteClusterClient) {
-            // here we start to connect to the remote clusters
-            remoteClusterService.initializeRemoteClusters();
-        }
-    }
-
-    public void setLocalNode(DiscoveryNode localNode) {
-        this.localNode = localNode;
-    }
-
-    @Override
-    protected void doStop() {
-        try {
-            IOUtils.close(connectionManager, remoteClusterService, transport::stop);
-        } catch (IOException e) {
-            throw new UncheckedIOException(e);
-        } finally {
-            // in case the transport is not connected to our local node (thus cleaned on node disconnect)
-            // make sure to clean any leftover on going handles
-            for (final Transport.ProtobufResponseContext holderToNotify : responseHandlers.prune(h -> true)) {
-                // callback that an exception happened, but on a different thread since we don't
-                // want handlers to worry about stack overflows
-                getExecutorService().execute(new AbstractRunnable() {
-                    @Override
-                    public void onRejection(Exception e) {
-                        // if we get rejected during node shutdown we don't wanna bubble it up
-                        logger.debug(
-                            () -> new ParameterizedMessage(
-                                "failed to notify response handler on rejection, action: {}",
-                                holderToNotify.action()
-                            ),
-                            e
-                        );
-                    }
-
-                    @Override
-                    public void onFailure(Exception e) {
-                        logger.warn(
-                            () -> new ParameterizedMessage(
-                                "failed to notify response handler on exception, action: {}",
-                                holderToNotify.action()
-                            ),
-                            e
-                        );
-                    }
-
-                    @Override
-                    public void doRun() {
-                        ProtobufTransportException ex = new ProtobufSendRequestTransportException(
-                            holderToNotify.connection().getNode(),
-                            holderToNotify.action(),
-                            new ProtobufNodeClosedException(localNode)
-                        );
-                        holderToNotify.handler().handleException(ex);
-                    }
-                });
-            }
-        }
-    }
-
-    @Override
-    protected void doClose() throws IOException {
-        transport.close();
-    }
-
-    /**
-     * start accepting incoming requests.
-    * when the transport layer starts up it will block any incoming requests until
-    * this method is called
-    */
-    public final void acceptIncomingRequests() {
-        handleIncomingRequests.set(true);
-    }
-
-    @Override
-    public ProtobufTransportInfo protobufInfo() {
-        ProtobufBoundTransportAddress boundTransportAddress = boundAddress();
-        if (boundTransportAddress == null) {
-            return null;
-        }
-        return new ProtobufTransportInfo(boundTransportAddress, transport.profileProtobufBoundAddresses());
-    }
-
-    public ProtobufTransportStats stats() {
-        return transport.getProtobufStats();
-    }
-
-    public boolean isTransportSecure() {
-        return transport.isSecure();
-    }
-
-    public ProtobufBoundTransportAddress boundAddress() {
-        return transport.boundProtobufAddress();
-    }
-
-    public List<String> getDefaultSeedAddresses() {
-        return transport.getDefaultSeedAddresses();
-    }
-
-    /**
-     * Returns <code>true</code> iff the given node is already connected.
-    */
-    public boolean nodeConnected(DiscoveryNode node) {
-        return isLocalNode(node) || connectionManager.nodeConnected(node);
-    }
-
-    /**
-     * Connect to the specified node with the default connection profile
-    *
-    * @param node the node to connect to
-    */
-    public void connectToNode(DiscoveryNode node) throws ProtobufConnectTransportException {
-        connectToNode(node, (ProtobufConnectionProfile) null);
-    }
-
-    // We are skipping node validation for extensibility as extensionNode and opensearchNode(LocalNode) will have different ephemeral id's
-    public void connectToExtensionNode(final DiscoveryNode node) {
-        PlainActionFuture.get(fut -> connectToExtensionNode(node, (ProtobufConnectionProfile) null, ActionListener.map(fut, x -> null)));
-    }
-
-    /**
-     * Connect to the specified node with the given connection profile
-    *
-    * @param node the node to connect to
-    * @param connectionProfile the connection profile to use when connecting to this node
-    */
-    public void connectToNode(final DiscoveryNode node, ProtobufConnectionProfile connectionProfile) {
-        PlainActionFuture.get(fut -> connectToNode(node, connectionProfile, ActionListener.map(fut, x -> null)));
-    }
-
-    public void connectToExtensionNode(final DiscoveryNode node, ProtobufConnectionProfile connectionProfile) {
-        PlainActionFuture.get(fut -> connectToExtensionNode(node, connectionProfile, ActionListener.map(fut, x -> null)));
-    }
-
-    /**
-     * Connect to the specified node with the given connection profile.
-    * The ActionListener will be called on the calling thread or the generic thread pool.
-    *
-    * @param node the node to connect to
-    * @param listener the action listener to notify
-    */
-    public void connectToNode(DiscoveryNode node, ActionListener<Void> listener) throws ProtobufConnectTransportException {
-        connectToNode(node, null, listener);
-    }
-
-    public void connectToExtensionNode(DiscoveryNode node, ActionListener<Void> listener) throws ProtobufConnectTransportException {
-        connectToExtensionNode(node, null, listener);
-    }
-
-    /**
-     * Connect to the specified node with the given connection profile.
-    * The ActionListener will be called on the calling thread or the generic thread pool.
-    *
-    * @param node the node to connect to
-    * @param connectionProfile the connection profile to use when connecting to this node
-    * @param listener the action listener to notify
-    */
-    public void connectToNode(final DiscoveryNode node, ProtobufConnectionProfile connectionProfile, ActionListener<Void> listener) {
-        if (isLocalNode(node)) {
-            listener.onResponse(null);
-            return;
-        }
-        connectionManager.connectToNode(node, connectionProfile, connectionValidator(node), listener);
-    }
-
-    public void connectToExtensionNode(
-        final DiscoveryNode node,
-        ProtobufConnectionProfile connectionProfile,
-        ActionListener<Void> listener
-    ) {
-        if (isLocalNode(node)) {
-            listener.onResponse(null);
-            return;
-        }
-        connectionManager.connectToNode(node, connectionProfile, extensionConnectionValidator(node), listener);
-    }
-
-    public ProtobufConnectionManager.ConnectionValidator connectionValidator(DiscoveryNode node) {
-        return (newConnection, actualProfile, listener) -> {
-            // We don't validate cluster names to allow for CCS connections.
-            handshake(newConnection, actualProfile.getHandshakeTimeout().millis(), cn -> true, ActionListener.map(listener, resp -> {
-                final DiscoveryNode remote = resp.discoveryNode;
-
-                if (node.equals(remote) == false) {
-                    throw new ProtobufConnectTransportException(node, "handshake failed. unexpected remote node " + remote);
-                }
-
-                return null;
-            }));
-        };
-    }
-
-    public ProtobufConnectionManager.ConnectionValidator extensionConnectionValidator(DiscoveryNode node) {
-        return (newConnection, actualProfile, listener) -> {
-            // We don't validate cluster names to allow for CCS connections.
-            handshake(newConnection, actualProfile.getHandshakeTimeout().millis(), cn -> true, ActionListener.map(listener, resp -> {
-                final DiscoveryNode remote = resp.discoveryNode;
-                logger.info("Connection validation was skipped");
-                return null;
-            }));
-        };
-    }
-
-    /**
-     * Establishes and returns a new connection to the given node. The connection is NOT maintained by this service, it's the callers
-    * responsibility to close the connection once it goes out of scope.
-    * The ActionListener will be called on the calling thread or the generic thread pool.
-    * @param node the node to connect to
-    * @param connectionProfile the connection profile to use
-    */
-    public Transport.ProtobufConnection openConnection(final DiscoveryNode node, ProtobufConnectionProfile connectionProfile) {
-        return PlainActionFuture.get(fut -> openConnection(node, connectionProfile, fut));
-    }
-
-    /**
-     * Establishes a new connection to the given node. The connection is NOT maintained by this service, it's the callers
-    * responsibility to close the connection once it goes out of scope.
-    * The ActionListener will be called on the calling thread or the generic thread pool.
-    * @param node the node to connect to
-    * @param connectionProfile the connection profile to use
-    * @param listener the action listener to notify
-    */
-    public void openConnection(
-        final DiscoveryNode node,
-        ProtobufConnectionProfile connectionProfile,
-        ActionListener<Transport.ProtobufConnection> listener
-    ) {
-        if (isLocalNode(node)) {
-            listener.onResponse(localNodeConnection);
-        } else {
-            connectionManager.openConnection(node, connectionProfile, listener);
-        }
-    }
-
-    /**
-     * Executes a high-level handshake using the given connection
-    * and returns the discovery node of the node the connection
-    * was established with. The handshake will fail if the cluster
-    * name on the target node mismatches the local cluster name.
-    * The ActionListener will be called on the calling thread or the generic thread pool.
-    *
-    * @param connection       the connection to a specific node
-    * @param handshakeTimeout handshake timeout
-    * @param listener         action listener to notify
-    * @throws ProtobufConnectTransportException if the connection failed
-    * @throws IllegalStateException if the handshake failed
-    */
-    public void handshake(
-        final Transport.ProtobufConnection connection,
-        final long handshakeTimeout,
-        final ActionListener<DiscoveryNode> listener
-    ) {
-        handshake(
-            connection,
-            handshakeTimeout,
-            clusterName.getEqualityPredicate(),
-            ActionListener.map(listener, HandshakeResponse::getDiscoveryNode)
-        );
-    }
-
-    /**
-     * Executes a high-level handshake using the given connection
-    * and returns the discovery node of the node the connection
-    * was established with. The handshake will fail if the cluster
-    * name on the target node doesn't match the local cluster name.
-    * The ActionListener will be called on the calling thread or the generic thread pool.
-    *
-    * @param connection       the connection to a specific node
-    * @param handshakeTimeout handshake timeout
-    * @param clusterNamePredicate cluster name validation predicate
-    * @param listener         action listener to notify
-    * @throws IllegalStateException if the handshake failed
-    */
-    public void handshake(
-        final Transport.ProtobufConnection connection,
-        final long handshakeTimeout,
-        Predicate<ClusterName> clusterNamePredicate,
-        final ActionListener<HandshakeResponse> listener
-    ) {
-        final DiscoveryNode node = connection.getNode();
-        sendRequest(
-            connection,
-            HANDSHAKE_ACTION_NAME,
-            HandshakeRequest.INSTANCE,
-            TransportRequestOptions.builder().withTimeout(handshakeTimeout).build(),
-            new ProtobufActionListenerResponseHandler<>(new ActionListener<HandshakeResponse>() {
-                @Override
-                public void onResponse(HandshakeResponse response) {
-                    if (clusterNamePredicate.test(response.clusterName) == false) {
-                        listener.onFailure(
-                            new IllegalStateException(
-                                "handshake with ["
-                                    + node
-                                    + "] failed: remote cluster name ["
-                                    + response.clusterName.value()
-                                    + "] does not match "
-                                    + clusterNamePredicate
-                            )
-                        );
-                    } else if (response.version.isCompatible(localNode.getVersion()) == false) {
-                        listener.onFailure(
-                            new IllegalStateException(
-                                "handshake with ["
-                                    + node
-                                    + "] failed: remote node version ["
-                                    + response.version
-                                    + "] is incompatible with local node version ["
-                                    + localNode.getVersion()
-                                    + "]"
-                            )
-                        );
-                    } else {
-                        listener.onResponse(response);
-                    }
-                }
-
-                @Override
-                public void onFailure(Exception e) {
-                    listener.onFailure(e);
-                }
-            }, HandshakeResponse::new, ThreadPool.Names.GENERIC)
-        );
-    }
-
-    public ProtobufConnectionManager getConnectionManager() {
-        return connectionManager;
-    }
-
-    /**
-     * Internal Handshake request
-    *
-    * @opensearch.internal
-    */
-    static class HandshakeRequest extends ProtobufTransportRequest {
-
-        public static final HandshakeRequest INSTANCE = new HandshakeRequest();
-
-        HandshakeRequest(CodedInputStream in) throws IOException {
-            super(in);
-        }
-
-        private HandshakeRequest() {}
-
-    }
-
-    /**
-     * Internal handshake response
-    *
-    * @opensearch.internal
-    */
-    public static class HandshakeResponse extends ProtobufTransportResponse {
-        private final DiscoveryNode discoveryNode;
-        private final ClusterName clusterName;
-        private final Version version;
-
-        public HandshakeResponse(DiscoveryNode discoveryNode, ClusterName clusterName, Version version) {
-            this.discoveryNode = discoveryNode;
-            this.version = version;
-            this.clusterName = clusterName;
-        }
-
-        public HandshakeResponse(CodedInputStream in) throws IOException {
-            super(in);
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-            discoveryNode = protobufStreamInput.readOptionalWriteable(DiscoveryNode::new);
-            clusterName = new ClusterName(in);
-            version = Version.readVersionProtobuf(in);
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            protobufStreamOutput.writeOptionalWriteable(discoveryNode);
-            clusterName.writeTo(out);
-            out.writeInt32NoTag(version.id);
-        }
-
-        public DiscoveryNode getDiscoveryNode() {
-            return discoveryNode;
-        }
-
-        public ClusterName getClusterName() {
-            return clusterName;
-        }
-    }
-
-    public void disconnectFromNode(DiscoveryNode node) {
-        if (isLocalNode(node)) {
-            return;
-        }
-        connectionManager.disconnectFromNode(node);
-    }
-
-    public void addMessageListener(ProtobufTransportMessageListener listener) {
-        messageListener.listeners.add(listener);
-    }
-
-    public boolean removeMessageListener(ProtobufTransportMessageListener listener) {
-        return messageListener.listeners.remove(listener);
-    }
-
-    public void addConnectionListener(ProtobufTransportConnectionListener listener) {
-        connectionManager.addListener(listener);
-    }
-
-    public void removeConnectionListener(ProtobufTransportConnectionListener listener) {
-        connectionManager.removeListener(listener);
-    }
-
-    public <T extends ProtobufTransportResponse> TransportFuture<T> submitRequest(
-        DiscoveryNode node,
-        String action,
-        ProtobufTransportRequest request,
-        ProtobufTransportResponseHandler<T> handler
-    ) throws ProtobufTransportException {
-        return submitRequest(node, action, request, TransportRequestOptions.EMPTY, handler);
-    }
-
-    public <T extends ProtobufTransportResponse> TransportFuture<T> submitRequest(
-        DiscoveryNode node,
-        String action,
-        ProtobufTransportRequest request,
-        TransportRequestOptions options,
-        ProtobufTransportResponseHandler<T> handler
-    ) throws ProtobufTransportException {
-        ProtobufPlainTransportFuture<T> futureHandler = new ProtobufPlainTransportFuture<>(handler);
-        try {
-            Transport.ProtobufConnection connection = getConnection(node);
-            sendRequest(connection, action, request, options, futureHandler);
-        } catch (ProtobufNodeNotConnectedException ex) {
-            // the caller might not handle this so we invoke the handler
-            futureHandler.handleException(ex);
-        }
-        return futureHandler;
-    }
-
-    public <T extends ProtobufTransportResponse> void sendRequest(
-        final DiscoveryNode node,
-        final String action,
-        final ProtobufTransportRequest request,
-        final ProtobufTransportResponseHandler<T> handler
-    ) {
-        final Transport.ProtobufConnection connection;
-        try {
-            connection = getConnection(node);
-        } catch (final ProtobufNodeNotConnectedException ex) {
-            // the caller might not handle this so we invoke the handler
-            handler.handleException(ex);
-            return;
-        }
-        sendRequest(connection, action, request, TransportRequestOptions.EMPTY, handler);
-    }
-
-    public final <T extends ProtobufTransportResponse> void sendRequest(
-        final DiscoveryNode node,
-        final String action,
-        final ProtobufTransportRequest request,
-        final TransportRequestOptions options,
-        ProtobufTransportResponseHandler<T> handler
-    ) {
-        final Transport.ProtobufConnection connection;
-        try {
-            connection = getConnection(node);
-        } catch (final ProtobufNodeNotConnectedException ex) {
-            // the caller might not handle this so we invoke the handler
-            handler.handleException(ex);
-            return;
-        }
-        sendRequest(connection, action, request, options, handler);
-    }
-
-    /**
-     * Sends a request on the specified connection. If there is a failure sending the request, the specified handler is invoked.
-    *
-    * @param connection the connection to send the request on
-    * @param action     the name of the action
-    * @param request    the request
-    * @param options    the options for this request
-    * @param handler    the response handler
-    * @param <T>        the type of the transport response
-    */
-    public final <T extends ProtobufTransportResponse> void sendRequest(
-        final Transport.ProtobufConnection connection,
-        final String action,
-        final ProtobufTransportRequest request,
-        final TransportRequestOptions options,
-        final ProtobufTransportResponseHandler<T> handler
-    ) {
-        try {
-            logger.debug("Action: " + action);
-            final ProtobufTransportResponseHandler<T> delegate;
-            if (request.getParentTask().isSet()) {
-                // TODO: capture the connection instead so that we can cancel child tasks on the remote connections.
-                final Releasable unregisterChildNode = taskManager.registerProtobufChildNode(
-                    request.getParentTask().getId(),
-                    connection.getNode()
-                );
-                delegate = new ProtobufTransportResponseHandler<T>() {
-                    @Override
-                    public void handleResponse(T response) {
-                        unregisterChildNode.close();
-                        handler.handleResponse(response);
-                    }
-
-                    @Override
-                    public void handleException(ProtobufTransportException exp) {
-                        unregisterChildNode.close();
-                        handler.handleException(exp);
-                    }
-
-                    @Override
-                    public String executor() {
-                        return handler.executor();
-                    }
-
-                    @Override
-                    public T read(CodedInputStream in) throws IOException {
-                        return handler.read(in);
-                    }
-
-                    @Override
-                    public String toString() {
-                        return getClass().getName() + "/[" + action + "]:" + handler.toString();
-                    }
-                };
-            } else {
-                delegate = handler;
-            }
-            asyncSender.sendRequest(connection, action, request, options, delegate);
-        } catch (final Exception ex) {
-            // the caller might not handle this so we invoke the handler
-            final ProtobufTransportException te;
-            if (ex instanceof ProtobufTransportException) {
-                te = (ProtobufTransportException) ex;
-            } else {
-                te = new ProtobufTransportException("failure to send", ex);
-            }
-            handler.handleException(te);
-        }
-    }
-
-    /**
-     * Returns either a real transport connection or a local node connection if we are using the local node optimization.
-    * @throws ProtobufNodeNotConnectedException if the given node is not connected
-    */
-    public Transport.ProtobufConnection getConnection(DiscoveryNode node) {
-        if (isLocalNode(node)) {
-            return localNodeConnection;
-        } else {
-            return connectionManager.getConnection(node);
-        }
-    }
-
-    public final <T extends ProtobufTransportResponse> void sendChildRequest(
-        final DiscoveryNode node,
-        final String action,
-        final ProtobufTransportRequest request,
-        final ProtobufTask parentTask,
-        final TransportRequestOptions options,
-        final ProtobufTransportResponseHandler<T> handler
-    ) {
-        final Transport.ProtobufConnection connection;
-        try {
-            connection = getConnection(node);
-        } catch (final ProtobufNodeNotConnectedException ex) {
-            // the caller might not handle this so we invoke the handler
-            handler.handleException(ex);
-            return;
-        }
-        sendChildRequest(connection, action, request, parentTask, options, handler);
-    }
-
-    public <T extends ProtobufTransportResponse> void sendChildRequest(
-        final Transport.ProtobufConnection connection,
-        final String action,
-        final ProtobufTransportRequest request,
-        final ProtobufTask parentTask,
-        final ProtobufTransportResponseHandler<T> handler
-    ) {
-        sendChildRequest(connection, action, request, parentTask, TransportRequestOptions.EMPTY, handler);
-    }
-
-    public <T extends ProtobufTransportResponse> void sendChildRequest(
-        final Transport.ProtobufConnection connection,
-        final String action,
-        final ProtobufTransportRequest request,
-        final ProtobufTask parentTask,
-        final TransportRequestOptions options,
-        final ProtobufTransportResponseHandler<T> handler
-    ) {
-        request.setParentTask(localNode.getId(), parentTask.getId());
-        sendRequest(connection, action, request, options, handler);
-    }
-
-    private <T extends ProtobufTransportResponse> void sendRequestInternal(
-        final Transport.ProtobufConnection connection,
-        final String action,
-        final ProtobufTransportRequest request,
-        final TransportRequestOptions options,
-        ProtobufTransportResponseHandler<T> handler
-    ) {
-        if (connection == null) {
-            throw new IllegalStateException("can't send request to a null connection");
-        }
-        DiscoveryNode node = connection.getNode();
-
-        Supplier<ThreadContext.StoredContext> storedContextSupplier = threadPool.getThreadContext().newRestorableContext(true);
-        ContextRestoreResponseHandler<T> responseHandler = new ContextRestoreResponseHandler<>(storedContextSupplier, handler);
-        // TODO we can probably fold this entire request ID dance into connection.sendReqeust but it will be a bigger refactoring
-        final long requestId = responseHandlers.add(new Transport.ProtobufResponseContext<>(responseHandler, connection, action));
-        final TimeoutHandler timeoutHandler;
-        if (options.timeout() != null) {
-            timeoutHandler = new TimeoutHandler(requestId, connection.getNode(), action);
-            responseHandler.setTimeoutHandler(timeoutHandler);
-        } else {
-            timeoutHandler = null;
-        }
-        try {
-            if (lifecycle.stoppedOrClosed()) {
-                /*
-                * If we are not started the exception handling will remove the request holder again and calls the handler to notify the
-                * caller. It will only notify if toStop hasn't done the work yet.
-                */
-                throw new ProtobufNodeClosedException(localNode);
-            }
-            if (timeoutHandler != null) {
-                assert options.timeout() != null;
-                timeoutHandler.scheduleTimeout(options.timeout());
-            }
-            connection.sendRequest(requestId, action, request, options); // local node optimization happens upstream
-        } catch (final Exception e) {
-            // usually happen either because we failed to connect to the node
-            // or because we failed serializing the message
-            final Transport.ProtobufResponseContext<? extends ProtobufTransportResponse> contextToNotify = responseHandlers.remove(
-                requestId
-            );
-            // If holderToNotify == null then handler has already been taken care of.
-            if (contextToNotify != null) {
-                if (timeoutHandler != null) {
-                    timeoutHandler.cancel();
-                }
-                // callback that an exception happened, but on a different thread since we don't
-                // want handlers to worry about stack overflows. In the special case of running into a closing node we run on the current
-                // thread on a best effort basis though.
-                final ProtobufSendRequestTransportException sendRequestException = new ProtobufSendRequestTransportException(
-                    node,
-                    action,
-                    e
-                );
-                final String executor = lifecycle.stoppedOrClosed() ? ThreadPool.Names.SAME : ThreadPool.Names.GENERIC;
-                threadPool.executor(executor).execute(new AbstractRunnable() {
-                    @Override
-                    public void onRejection(Exception e) {
-                        // if we get rejected during node shutdown we don't wanna bubble it up
-                        logger.debug(
-                            () -> new ParameterizedMessage(
-                                "failed to notify response handler on rejection, action: {}",
-                                contextToNotify.action()
-                            ),
-                            e
-                        );
-                    }
-
-                    @Override
-                    public void onFailure(Exception e) {
-                        logger.warn(
-                            () -> new ParameterizedMessage(
-                                "failed to notify response handler on exception, action: {}",
-                                contextToNotify.action()
-                            ),
-                            e
-                        );
-                    }
-
-                    @Override
-                    protected void doRun() throws Exception {
-                        contextToNotify.handler().handleException(sendRequestException);
-                    }
-                });
-            } else {
-                logger.debug("Exception while sending request, handler likely already notified due to timeout", e);
-            }
-        }
-    }
-
-    private void sendLocalRequest(
-        long requestId,
-        final String action,
-        final ProtobufTransportRequest request,
-        TransportRequestOptions options
-    ) {
-        final DirectResponseChannel channel = new DirectResponseChannel(localNode, action, requestId, this, threadPool);
-        try {
-            onRequestSent(localNode, requestId, action, request, options);
-            onRequestReceived(requestId, action);
-            final ProtobufRequestHandlerRegistry reg = getRequestHandler(action);
-            if (reg == null) {
-                throw new ActionNotFoundTransportException("Action [" + action + "] not found");
-            }
-            final String executor = reg.getExecutor();
-            if (ThreadPool.Names.SAME.equals(executor)) {
-                // noinspection unchecked
-                reg.processMessageReceived(request, channel);
-            } else {
-                threadPool.executor(executor).execute(new AbstractRunnable() {
-                    @Override
-                    protected void doRun() throws Exception {
-                        // noinspection unchecked
-                        reg.processMessageReceived(request, channel);
-                    }
-
-                    @Override
-                    public boolean isForceExecution() {
-                        return reg.isForceExecution();
-                    }
-
-                    @Override
-                    public void onFailure(Exception e) {
-                        try {
-                            channel.sendResponse(e);
-                        } catch (Exception inner) {
-                            inner.addSuppressed(e);
-                            logger.warn(
-                                () -> new ParameterizedMessage("failed to notify channel of error message for action [{}]", action),
-                                inner
-                            );
-                        }
-                    }
-
-                    @Override
-                    public String toString() {
-                        return "processing of [" + requestId + "][" + action + "]: " + request;
-                    }
-                });
-            }
-
-        } catch (Exception e) {
-            try {
-                channel.sendResponse(e);
-            } catch (Exception inner) {
-                inner.addSuppressed(e);
-                logger.warn(() -> new ParameterizedMessage("failed to notify channel of error message for action [{}]", action), inner);
-            }
-        }
-    }
-
-    private boolean shouldTraceAction(String action) {
-        return shouldTraceAction(action, tracerLogInclude, tracerLogExclude);
-    }
-
-    public static boolean shouldTraceAction(String action, String[] include, String[] exclude) {
-        if (include.length > 0) {
-            if (Regex.simpleMatch(include, action) == false) {
-                return false;
-            }
-        }
-        if (exclude.length > 0) {
-            return !Regex.simpleMatch(exclude, action);
-        }
-        return true;
-    }
-
-    public TransportAddress[] addressesFromString(String address) throws UnknownHostException {
-        return transport.addressesFromString(address);
-    }
-
-    /**
-     * A set of all valid action prefixes.
-    */
-    public static final Set<String> VALID_ACTION_PREFIXES = Collections.unmodifiableSet(
-        new HashSet<>(
-            Arrays.asList(
-                "indices:admin",
-                "indices:monitor",
-                "indices:data/write",
-                "indices:data/read",
-                "indices:internal",
-                "cluster:admin",
-                "cluster:monitor",
-                "cluster:internal",
-                "internal:"
-            )
-        )
-    );
-
-    private void validateActionName(String actionName) {
-        // TODO we should makes this a hard validation and throw an exception but we need a good way to add backwards layer
-        // for it. Maybe start with a deprecation layer
-        if (isValidActionName(actionName) == false) {
-            logger.warn(
-                "invalid action name [" + actionName + "] must start with one of: " + ProtobufTransportService.VALID_ACTION_PREFIXES
-            );
-        }
-    }
-
-    /**
-     * Returns <code>true</code> iff the action name starts with a valid prefix.
-    *
-    * @see #VALID_ACTION_PREFIXES
-    */
-    public static boolean isValidActionName(String actionName) {
-        for (String prefix : VALID_ACTION_PREFIXES) {
-            if (actionName.startsWith(prefix)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    /**
-     * Registers a new request handler
-    *
-    * @param action         The action the request handler is associated with
-    * @param requestReader  a callable to be used construct new instances for streaming
-    * @param executor       The executor the request handling will be executed on
-    * @param handler        The handler itself that implements the request handling
-    */
-    public <Request extends ProtobufTransportRequest> void registerRequestHandler(
-        String action,
-        String executor,
-        ProtobufWriteable.Reader<Request> requestReader,
-        ProtobufTransportRequestHandler<Request> handler
-    ) {
-        validateActionName(action);
-        handler = interceptor.interceptHandler(action, executor, false, handler);
-        ProtobufRequestHandlerRegistry<Request> reg = new ProtobufRequestHandlerRegistry<>(
-            action,
-            requestReader,
-            taskManager,
-            handler,
-            executor,
-            false,
-            true
-        );
-        transport.registerProtobufRequestHandler(reg);
-    }
-
-    /**
-     * Registers a new request handler
-    *
-    * @param action                The action the request handler is associated with
-    * @param requestReader               The request class that will be used to construct new instances for streaming
-    * @param executor              The executor the request handling will be executed on
-    * @param forceExecution        Force execution on the executor queue and never reject it
-    * @param canTripCircuitBreaker Check the request size and raise an exception in case the limit is breached.
-    * @param handler               The handler itself that implements the request handling
-    */
-    public <Request extends ProtobufTransportRequest> void registerRequestHandler(
-        String action,
-        String executor,
-        boolean forceExecution,
-        boolean canTripCircuitBreaker,
-        ProtobufWriteable.Reader<Request> requestReader,
-        ProtobufTransportRequestHandler<Request> handler
-    ) {
-        validateActionName(action);
-        handler = interceptor.interceptHandler(action, executor, forceExecution, handler);
-        ProtobufRequestHandlerRegistry<Request> reg = new ProtobufRequestHandlerRegistry<>(
-            action,
-            requestReader,
-            taskManager,
-            handler,
-            executor,
-            forceExecution,
-            canTripCircuitBreaker
-        );
-        transport.registerProtobufRequestHandler(reg);
-    }
-
-    /**
-     * called by the {@link Transport} implementation when an incoming request arrives but before
-    * any parsing of it has happened (with the exception of the requestId and action)
-    */
-    @Override
-    public void onRequestReceived(long requestId, String action) {
-        if (handleIncomingRequests.get() == false) {
-            throw new IllegalStateException("transport not ready yet to handle incoming requests");
-        }
-        if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
-            tracerLog.trace("[{}][{}] received request", requestId, action);
-        }
-        messageListener.onRequestReceived(requestId, action);
-    }
-
-    /** called by the {@link Transport} implementation once a request has been sent */
-    @Override
-    public void onRequestSent(
-        DiscoveryNode node,
-        long requestId,
-        String action,
-        ProtobufTransportRequest request,
-        TransportRequestOptions options
-    ) {
-        if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
-            tracerLog.trace("[{}][{}] sent to [{}] (timeout: [{}])", requestId, action, node, options.timeout());
-        }
-        messageListener.onRequestSent(node, requestId, action, request, options);
-    }
-
-    @Override
-    public void onResponseReceived(long requestId, Transport.ProtobufResponseContext holder) {
-        if (holder == null) {
-            checkForTimeout(requestId);
-        } else if (tracerLog.isTraceEnabled() && shouldTraceAction(holder.action())) {
-            tracerLog.trace("[{}][{}] received response from [{}]", requestId, holder.action(), holder.connection().getNode());
-        }
-        messageListener.onResponseReceived(requestId, holder);
-    }
-
-    /** called by the {@link Transport} implementation once a response was sent to calling node */
-    @Override
-    public void onResponseSent(long requestId, String action, ProtobufTransportResponse response) {
-        if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
-            tracerLog.trace("[{}][{}] sent response", requestId, action);
-        }
-        messageListener.onResponseSent(requestId, action, response);
-    }
-
-    /** called by the {@link Transport} implementation after an exception was sent as a response to an incoming request */
-    @Override
-    public void onResponseSent(long requestId, String action, Exception e) {
-        if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
-            tracerLog.trace(() -> new ParameterizedMessage("[{}][{}] sent error response", requestId, action), e);
-        }
-        messageListener.onResponseSent(requestId, action, e);
-    }
-
-    public ProtobufRequestHandlerRegistry<? extends ProtobufTransportRequest> getRequestHandler(String action) {
-        return transport.getProtobufRequestHandlers().getHandler(action);
-    }
-
-    private void checkForTimeout(long requestId) {
-        // lets see if its in the timeout holder, but sync on mutex to make sure any ongoing timeout handling has finished
-        final DiscoveryNode sourceNode;
-        final String action;
-        assert responseHandlers.contains(requestId) == false;
-        TimeoutInfoHolder timeoutInfoHolder = timeoutInfoHandlers.remove(requestId);
-        if (timeoutInfoHolder != null) {
-            long time = threadPool.relativeTimeInMillis();
-            logger.warn(
-                "Received response for a request that has timed out, sent [{}ms] ago, timed out [{}ms] ago, "
-                    + "action [{}], node [{}], id [{}]",
-                time - timeoutInfoHolder.sentTime(),
-                time - timeoutInfoHolder.timeoutTime(),
-                timeoutInfoHolder.action(),
-                timeoutInfoHolder.node(),
-                requestId
-            );
-            action = timeoutInfoHolder.action();
-            sourceNode = timeoutInfoHolder.node();
-        } else {
-            logger.warn("ProtobufTransport response handler not found of id [{}]", requestId);
-            action = null;
-            sourceNode = null;
-        }
-        // call tracer out of lock
-        if (tracerLog.isTraceEnabled() == false) {
-            return;
-        }
-        if (action == null) {
-            assert sourceNode == null;
-            tracerLog.trace("[{}] received response but can't resolve it to a request", requestId);
-        } else if (shouldTraceAction(action)) {
-            tracerLog.trace("[{}][{}] received response from [{}]", requestId, action, sourceNode);
-        }
-    }
-
-    @Override
-    public void onConnectionClosed(Transport.ProtobufConnection connection) {
-        try {
-            List<Transport.ProtobufResponseContext<? extends ProtobufTransportResponse>> pruned = responseHandlers.prune(
-                h -> h.connection().getCacheKey().equals(connection.getCacheKey())
-            );
-            // callback that an exception happened, but on a different thread since we don't
-            // want handlers to worry about stack overflows
-            getExecutorService().execute(new Runnable() {
-                @Override
-                public void run() {
-                    for (Transport.ProtobufResponseContext holderToNotify : pruned) {
-                        holderToNotify.handler()
-                            .handleException(new ProtobufNodeDisconnectedException(connection.getNode(), holderToNotify.action()));
-                    }
-                }
-
-                @Override
-                public String toString() {
-                    return "onConnectionClosed(" + connection.getNode() + ")";
-                }
-            });
-        } catch (OpenSearchRejectedExecutionException ex) {
-            logger.debug("Rejected execution on onConnectionClosed", ex);
-        }
-    }
-
-    final class TimeoutHandler implements Runnable {
-
-        private final long requestId;
-        private final long sentTime = threadPool.relativeTimeInMillis();
-        private final String action;
-        private final DiscoveryNode node;
-        volatile Scheduler.Cancellable cancellable;
-
-        TimeoutHandler(long requestId, DiscoveryNode node, String action) {
-            this.requestId = requestId;
-            this.node = node;
-            this.action = action;
-        }
-
-        @Override
-        public void run() {
-            if (responseHandlers.contains(requestId)) {
-                long timeoutTime = threadPool.relativeTimeInMillis();
-                timeoutInfoHandlers.put(requestId, new TimeoutInfoHolder(node, action, sentTime, timeoutTime));
-                // now that we have the information visible via timeoutInfoHandlers, we try to remove the request id
-                final Transport.ProtobufResponseContext<? extends ProtobufTransportResponse> holder = responseHandlers.remove(requestId);
-                if (holder != null) {
-                    assert holder.action().equals(action);
-                    assert holder.connection().getNode().equals(node);
-                    holder.handler()
-                        .handleException(
-                            new ProtobufReceiveTimeoutTransportException(
-                                holder.connection().getNode(),
-                                holder.action(),
-                                "request_id [" + requestId + "] timed out after [" + (timeoutTime - sentTime) + "ms]"
-                            )
-                        );
-                } else {
-                    // response was processed, remove timeout info.
-                    timeoutInfoHandlers.remove(requestId);
-                }
-            }
-        }
-
-        /**
-         * cancels timeout handling. this is a best effort only to avoid running it. remove the requestId from {@link #responseHandlers}
-        * to make sure this doesn't run.
-        */
-        public void cancel() {
-            assert responseHandlers.contains(requestId) == false : "cancel must be called after the requestId ["
-                + requestId
-                + "] has been removed from clientHandlers";
-            if (cancellable != null) {
-                cancellable.cancel();
-            }
-        }
-
-        @Override
-        public String toString() {
-            return "timeout handler for [" + requestId + "][" + action + "]";
-        }
-
-        private void scheduleTimeout(TimeValue timeout) {
-            this.cancellable = threadPool.schedule(this, timeout, ThreadPool.Names.GENERIC);
-        }
-    }
-
-    /**
-     * Holder for timeout information
-    *
-    * @opensearch.internal
-    */
-    static class TimeoutInfoHolder {
-
-        private final DiscoveryNode node;
-        private final String action;
-        private final long sentTime;
-        private final long timeoutTime;
-
-        TimeoutInfoHolder(DiscoveryNode node, String action, long sentTime, long timeoutTime) {
-            this.node = node;
-            this.action = action;
-            this.sentTime = sentTime;
-            this.timeoutTime = timeoutTime;
-        }
-
-        public DiscoveryNode node() {
-            return node;
-        }
-
-        public String action() {
-            return action;
-        }
-
-        public long sentTime() {
-            return sentTime;
-        }
-
-        public long timeoutTime() {
-            return timeoutTime;
-        }
-    }
-
-    /**
-     * This handler wrapper ensures that the response thread executes with the correct thread context. Before any of the handle methods
-    * are invoked we restore the context.
-    */
-    public static final class ContextRestoreResponseHandler<T extends ProtobufTransportResponse>
-        implements
-            ProtobufTransportResponseHandler<T> {
-
-        private final ProtobufTransportResponseHandler<T> delegate;
-        private final Supplier<ThreadContext.StoredContext> contextSupplier;
-        private volatile TimeoutHandler handler;
-
-        public ContextRestoreResponseHandler(
-            Supplier<ThreadContext.StoredContext> contextSupplier,
-            ProtobufTransportResponseHandler<T> delegate
-        ) {
-            this.delegate = delegate;
-            this.contextSupplier = contextSupplier;
-        }
-
-        @Override
-        public T read(CodedInputStream in) throws IOException {
-            return delegate.read(in);
-        }
-
-        @Override
-        public void handleResponse(T response) {
-            if (handler != null) {
-                handler.cancel();
-            }
-            try (ThreadContext.StoredContext ignore = contextSupplier.get()) {
-                delegate.handleResponse(response);
-            }
-        }
-
-        @Override
-        public void handleException(ProtobufTransportException exp) {
-            if (handler != null) {
-                handler.cancel();
-            }
-            try (ThreadContext.StoredContext ignore = contextSupplier.get()) {
-                delegate.handleException(exp);
-            }
-        }
-
-        @Override
-        public String executor() {
-            return delegate.executor();
-        }
-
-        @Override
-        public String toString() {
-            return getClass().getName() + "/" + delegate.toString();
-        }
-
-        void setTimeoutHandler(TimeoutHandler handler) {
-            this.handler = handler;
-        }
-
-    }
-
-    /**
-     * A channel for a direct response
-    *
-    * @opensearch.internal
-    */
-    static class DirectResponseChannel implements ProtobufTransportChannel {
-        final DiscoveryNode localNode;
-        private final String action;
-        private final long requestId;
-        final ProtobufTransportService service;
-        final ThreadPool threadPool;
-
-        DirectResponseChannel(
-            DiscoveryNode localNode,
-            String action,
-            long requestId,
-            ProtobufTransportService service,
-            ThreadPool threadPool
-        ) {
-            this.localNode = localNode;
-            this.action = action;
-            this.requestId = requestId;
-            this.service = service;
-            this.threadPool = threadPool;
-        }
-
-        @Override
-        public String getProfileName() {
-            return DIRECT_RESPONSE_PROFILE;
-        }
-
-        @Override
-        public void sendResponse(ProtobufTransportResponse response) throws IOException {
-            service.onResponseSent(requestId, action, response);
-            final ProtobufTransportResponseHandler handler = service.responseHandlers.onResponseReceived(requestId, service);
-            // ignore if its null, the service logs it
-            if (handler != null) {
-                final String executor = handler.executor();
-                if (ThreadPool.Names.SAME.equals(executor)) {
-                    processResponse(handler, response);
-                } else {
-                    threadPool.executor(executor).execute(new Runnable() {
-                        @Override
-                        public void run() {
-                            processResponse(handler, response);
-                        }
-
-                        @Override
-                        public String toString() {
-                            return "delivery of response to [" + requestId + "][" + action + "]: " + response;
-                        }
-                    });
-                }
-            }
-        }
-
-        @SuppressWarnings("unchecked")
-        protected void processResponse(ProtobufTransportResponseHandler handler, ProtobufTransportResponse response) {
-            try {
-                handler.handleResponse(response);
-            } catch (Exception e) {
-                processException(handler, wrapInRemote(new ResponseHandlerFailureTransportException(e)));
-            }
-        }
-
-        @Override
-        public void sendResponse(Exception exception) throws IOException {
-            service.onResponseSent(requestId, action, exception);
-            final ProtobufTransportResponseHandler handler = service.responseHandlers.onResponseReceived(requestId, service);
-            // ignore if its null, the service logs it
-            if (handler != null) {
-                final ProtobufRemoteTransportException rtx = wrapInRemote(exception);
-                final String executor = handler.executor();
-                if (ThreadPool.Names.SAME.equals(executor)) {
-                    processException(handler, rtx);
-                } else {
-                    threadPool.executor(handler.executor()).execute(new Runnable() {
-                        @Override
-                        public void run() {
-                            processException(handler, rtx);
-                        }
-
-                        @Override
-                        public String toString() {
-                            return "delivery of failure response to [" + requestId + "][" + action + "]: " + exception;
-                        }
-                    });
-                }
-            }
-        }
-
-        protected ProtobufRemoteTransportException wrapInRemote(Exception e) {
-            if (e instanceof ProtobufRemoteTransportException) {
-                return (ProtobufRemoteTransportException) e;
-            }
-            return new ProtobufRemoteTransportException(localNode.getName(), localNode.getProtobufAddress(), action, e);
-        }
-
-        protected void processException(final ProtobufTransportResponseHandler handler, final ProtobufRemoteTransportException rtx) {
-            try {
-                handler.handleException(rtx);
-            } catch (Exception e) {
-                logger.error(
-                    () -> new ParameterizedMessage("failed to handle exception for action [{}], handler [{}]", action, handler),
-                    e
-                );
-            }
-        }
-
-        @Override
-        public String getChannelType() {
-            return "direct";
-        }
-
-        @Override
-        public Version getVersion() {
-            return localNode.getVersion();
-        }
-    }
-
-    /**
-     * Returns the internal thread pool
-    */
-    public ThreadPool getThreadPool() {
-        return threadPool;
-    }
-
-    private boolean isLocalNode(DiscoveryNode discoveryNode) {
-        return Objects.requireNonNull(discoveryNode, "discovery node must not be null").equals(localNode);
-    }
-
-    private static final class DelegatingTransportMessageListener implements ProtobufTransportMessageListener {
-
-        private final List<ProtobufTransportMessageListener> listeners = new CopyOnWriteArrayList<>();
-
-        @Override
-        public void onRequestReceived(long requestId, String action) {
-            for (ProtobufTransportMessageListener listener : listeners) {
-                listener.onRequestReceived(requestId, action);
-            }
-        }
-
-        @Override
-        public void onResponseSent(long requestId, String action, ProtobufTransportResponse response) {
-            for (ProtobufTransportMessageListener listener : listeners) {
-                listener.onResponseSent(requestId, action, response);
-            }
-        }
-
-        @Override
-        public void onResponseSent(long requestId, String action, Exception error) {
-            for (ProtobufTransportMessageListener listener : listeners) {
-                listener.onResponseSent(requestId, action, error);
-            }
-        }
-
-        @Override
-        public void onRequestSent(
-            DiscoveryNode node,
-            long requestId,
-            String action,
-            ProtobufTransportRequest request,
-            TransportRequestOptions finalOptions
-        ) {
-            for (ProtobufTransportMessageListener listener : listeners) {
-                listener.onRequestSent(node, requestId, action, request, finalOptions);
-            }
-        }
-
-        @Override
-        public void onResponseReceived(long requestId, Transport.ProtobufResponseContext holder) {
-            for (ProtobufTransportMessageListener listener : listeners) {
-                listener.onResponseReceived(requestId, holder);
-            }
-        }
-    }
-}
+// /*
+// * 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.
+// */
+
+// package org.opensearch.transport;
+
+// import com.google.protobuf.CodedInputStream;
+// import com.google.protobuf.CodedOutputStream;
+// import org.apache.logging.log4j.LogManager;
+// import org.apache.logging.log4j.Logger;
+// import org.apache.logging.log4j.message.ParameterizedMessage;
+// import org.opensearch.Version;
+// import org.opensearch.action.ActionListener;
+// import org.opensearch.action.ProtobufActionListenerResponseHandler;
+// import org.opensearch.action.support.PlainActionFuture;
+// import org.opensearch.cluster.ClusterName;
+// import org.opensearch.cluster.node.DiscoveryNode;
+// import org.opensearch.common.Nullable;
+// import org.opensearch.common.Strings;
+// import org.opensearch.common.component.AbstractLifecycleComponent;
+// import org.opensearch.common.io.stream.ProtobufStreamInput;
+// import org.opensearch.common.io.stream.ProtobufStreamOutput;
+// import org.opensearch.common.io.stream.ProtobufWriteable;
+// import org.opensearch.common.lease.Releasable;
+// import org.opensearch.common.logging.Loggers;
+// import org.opensearch.common.regex.Regex;
+// import org.opensearch.common.settings.ClusterSettings;
+// import org.opensearch.common.settings.Settings;
+// import org.opensearch.common.transport.BoundTransportAddress;
+// import org.opensearch.common.transport.BoundTransportAddress;
+// import org.opensearch.common.transport.TransportAddress;
+// import org.opensearch.common.unit.TimeValue;
+// import org.opensearch.common.util.concurrent.AbstractRunnable;
+// import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
+// import org.opensearch.common.util.concurrent.ThreadContext;
+// import org.opensearch.common.util.io.IOUtils;
+// import org.opensearch.node.ProtobufNodeClosedException;
+// import org.opensearch.node.ProtobufReportingService;
+// import org.opensearch.tasks.ProtobufTask;
+// import org.opensearch.tasks.TaskManager;
+// import org.opensearch.threadpool.Scheduler;
+// import org.opensearch.threadpool.ThreadPool;
+
+// import java.io.IOException;
+// import java.io.UncheckedIOException;
+// import java.net.UnknownHostException;
+// import java.util.Arrays;
+// import java.util.Collections;
+// import java.util.HashSet;
+// import java.util.LinkedHashMap;
+// import java.util.List;
+// import java.util.Map;
+// import java.util.Objects;
+// import java.util.Set;
+// import java.util.concurrent.CopyOnWriteArrayList;
+// import java.util.concurrent.ExecutorService;
+// import java.util.concurrent.atomic.AtomicBoolean;
+// import java.util.function.Function;
+// import java.util.function.Predicate;
+// import java.util.function.Supplier;
+
+// /**
+//  * The main OpenSearch transport service
+// *
+// * @opensearch.internal
+// */
+// public class ProtobufTransportService extends AbstractLifecycleComponent
+//     implements
+//         ProtobufReportingService<ProtobufTransportInfo>,
+//         ProtobufTransportMessageListener,
+//         TransportConnectionListener {
+//     private static final Logger logger = LogManager.getLogger(ProtobufTransportService.class);
+
+//     public static final String DIRECT_RESPONSE_PROFILE = ".direct";
+//     public static final String HANDSHAKE_ACTION_NAME = "internal:transport/handshake";
+
+//     private final AtomicBoolean handleIncomingRequests = new AtomicBoolean();
+//     private final DelegatingTransportMessageListener messageListener = new DelegatingTransportMessageListener();
+//     protected final Transport transport;
+//     protected final ConnectionManager connectionManager;
+//     protected final ThreadPool threadPool;
+//     protected final ClusterName clusterName;
+//     protected final TaskManager taskManager;
+//     private final ProtobufTransportInterceptor.AsyncSender asyncSender;
+//     private final Function<BoundTransportAddress, DiscoveryNode> localNodeFactory;
+//     private final boolean remoteClusterClient;
+//     private final Transport.ProtobufResponseHandlers responseHandlers;
+//     private final ProtobufTransportInterceptor interceptor;
+
+//     // An LRU (don't really care about concurrency here) that holds the latest timed out requests so if they
+//     // do show up, we can print more descriptive information about them
+//     final Map<Long, TimeoutInfoHolder> timeoutInfoHandlers = Collections.synchronizedMap(
+//         new LinkedHashMap<Long, TimeoutInfoHolder>(100, .75F, true) {
+//             @Override
+//             protected boolean removeEldestEntry(Map.Entry eldest) {
+//                 return size() > 100;
+//             }
+//         }
+//     );
+
+//     public static final ProtobufTransportInterceptor NOOP_TRANSPORT_INTERCEPTOR = new ProtobufTransportInterceptor() {
+//     };
+
+//     // tracer log
+
+//     private final Logger tracerLog;
+
+//     volatile String[] tracerLogInclude;
+//     volatile String[] tracerLogExclude;
+
+//     private final RemoteClusterService remoteClusterService;
+
+//     /** if set will call requests sent to this id to shortcut and executed locally */
+//     volatile DiscoveryNode localNode = null;
+//     private final Transport.Connection localNodeConnection = new Transport.Connection() {
+//         @Override
+//         public DiscoveryNode getNode() {
+//             return localNode;
+//         }
+
+//         @Override
+//         public void sendRequestProtobuf(long requestId, String action, TransportRequest request, TransportRequestOptions options)
+//             throws ProtobufTransportException {
+//             sendLocalRequest(requestId, action, request, options);
+//         }
+
+//         @Override
+//         public void addCloseListener(ActionListener<Void> listener) {}
+
+//         @Override
+//         public boolean isClosed() {
+//             return false;
+//         }
+
+//         @Override
+//         public void close() {}
+
+//         @Override
+//         public void sendRequest(long requestId, String action, TransportRequest request,
+//                 TransportRequestOptions options) throws IOException, TransportException {
+//             // TODO Auto-generated method stub
+//             throw new UnsupportedOperationException("Unimplemented method 'sendRequest'");
+//         }
+//     };
+
+//     /**
+//      * Build the service.
+//     *
+//     * @param clusterSettings if non null, the {@linkplain ProtobufTransportService} will register with the {@link ClusterSettings} for settings
+//     *   *    updates for {@link TransportSettings#TRACE_LOG_EXCLUDE_SETTING} and {@link TransportSettings#TRACE_LOG_INCLUDE_SETTING}.
+//     */
+//     public ProtobufTransportService(
+//         Settings settings,
+//         Transport transport,
+//         ThreadPool threadPool,
+//         ProtobufTransportInterceptor transportInterceptor,
+//         Function<BoundTransportAddress, DiscoveryNode> localNodeFactory,
+//         @Nullable ClusterSettings clusterSettings,
+//         Set<String> taskHeaders
+//     ) {
+//         this(
+//             settings,
+//             transport,
+//             threadPool,
+//             transportInterceptor,
+//             localNodeFactory,
+//             clusterSettings,
+//             taskHeaders,
+//             new ClusterConnectionManager(settings, transport)
+//         );
+//     }
+
+//     public ProtobufTransportService(
+//         Settings settings,
+//         Transport transport,
+//         ThreadPool threadPool,
+//         ProtobufTransportInterceptor transportInterceptor,
+//         Function<BoundTransportAddress, DiscoveryNode> localNodeFactory,
+//         @Nullable ClusterSettings clusterSettings,
+//         Set<String> taskHeaders,
+//         ConnectionManager connectionManager
+//     ) {
+//         this.transport = transport;
+//         transport.setSlowLogThreshold(TransportSettings.SLOW_OPERATION_THRESHOLD_SETTING.get(settings));
+//         this.threadPool = threadPool;
+//         this.localNodeFactory = localNodeFactory;
+//         this.connectionManager = connectionManager;
+//         this.clusterName = ClusterName.CLUSTER_NAME_SETTING.get(settings);
+//         setTracerLogInclude(TransportSettings.TRACE_LOG_INCLUDE_SETTING.get(settings));
+//         setTracerLogExclude(TransportSettings.TRACE_LOG_EXCLUDE_SETTING.get(settings));
+//         tracerLog = Loggers.getLogger(logger, ".tracer");
+//         taskManager = createTaskManager(settings, clusterSettings, threadPool, taskHeaders);
+//         this.interceptor = transportInterceptor;
+//         this.asyncSender = interceptor.interceptSender(this::sendRequestInternal);
+//         this.remoteClusterClient = DiscoveryNode.isRemoteClusterClient(settings);
+//         remoteClusterService = new RemoteClusterService(settings, this);
+//         responseHandlers = transport.getProtobufResponseHandlers();
+//         if (clusterSettings != null) {
+//             clusterSettings.addSettingsUpdateConsumer(TransportSettings.TRACE_LOG_INCLUDE_SETTING, this::setTracerLogInclude);
+//             clusterSettings.addSettingsUpdateConsumer(TransportSettings.TRACE_LOG_EXCLUDE_SETTING, this::setTracerLogExclude);
+//             if (remoteClusterClient) {
+//                 remoteClusterService.listenForUpdates(clusterSettings);
+//             }
+//             clusterSettings.addSettingsUpdateConsumer(TransportSettings.SLOW_OPERATION_THRESHOLD_SETTING, transport::setSlowLogThreshold);
+//         }
+//         registerRequestHandler(
+//             HANDSHAKE_ACTION_NAME,
+//             ThreadPool.Names.SAME,
+//             false,
+//             false,
+//             HandshakeRequest::new,
+//             (request, channel, task) -> channel.sendResponse(new HandshakeResponse(localNode, clusterName, localNode.getVersion()))
+//         );
+//     }
+
+//     public RemoteClusterService getRemoteClusterService() {
+//         return remoteClusterService;
+//     }
+
+//     public DiscoveryNode getLocalNode() {
+//         return localNode;
+//     }
+
+//     public TaskManager getTaskManager() {
+//         return taskManager;
+//     }
+
+//     protected TaskManager createTaskManager(
+//         Settings settings,
+//         ClusterSettings clusterSettings,
+//         ThreadPool threadPool,
+//         Set<String> taskHeaders
+//     ) {
+//         if (clusterSettings != null) {
+//             return TaskManager.createTaskManagerWithClusterSettings(settings, clusterSettings, threadPool, taskHeaders);
+//         } else {
+//             return new TaskManager(settings, threadPool, taskHeaders);
+//         }
+//     }
+
+//     /**
+//      * The executor service for this transport service.
+//     *
+//     * @return the executor service
+//     */
+//     private ExecutorService getExecutorService() {
+//         return threadPool.generic();
+//     }
+
+//     void setTracerLogInclude(List<String> tracerLogInclude) {
+//         this.tracerLogInclude = tracerLogInclude.toArray(Strings.EMPTY_ARRAY);
+//     }
+
+//     void setTracerLogExclude(List<String> tracerLogExclude) {
+//         this.tracerLogExclude = tracerLogExclude.toArray(Strings.EMPTY_ARRAY);
+//     }
+
+//     @Override
+//     protected void doStart() {
+//         transport.setMessageListenerProtobuf(this);
+//         connectionManager.addListener(this);
+//         transport.start();
+//         if (transport.boundAddress() != null && logger.isInfoEnabled()) {
+//             logger.info("{}", transport.boundAddress());
+//             for (Map.Entry<String, BoundTransportAddress> entry : transport.profileBoundAddresses().entrySet()) {
+//                 logger.info("profile [{}]: {}", entry.getKey(), entry.getValue());
+//             }
+//         }
+
+//         localNode = localNodeFactory.apply(transport.boundAddress());
+
+//         if (remoteClusterClient) {
+//             // here we start to connect to the remote clusters
+//             remoteClusterService.initializeRemoteClusters();
+//         }
+//     }
+
+//     public void setLocalNode(DiscoveryNode localNode) {
+//         this.localNode = localNode;
+//     }
+
+//     @Override
+//     protected void doStop() {
+//         try {
+//             IOUtils.close(connectionManager, remoteClusterService, transport::stop);
+//         } catch (IOException e) {
+//             throw new UncheckedIOException(e);
+//         } finally {
+//             // in case the transport is not connected to our local node (thus cleaned on node disconnect)
+//             // make sure to clean any leftover on going handles
+//             for (final Transport.ProtobufResponseContext holderToNotify : responseHandlers.prune(h -> true)) {
+//                 // callback that an exception happened, but on a different thread since we don't
+//                 // want handlers to worry about stack overflows
+//                 getExecutorService().execute(new AbstractRunnable() {
+//                     @Override
+//                     public void onRejection(Exception e) {
+//                         // if we get rejected during node shutdown we don't wanna bubble it up
+//                         logger.debug(
+//                             () -> new ParameterizedMessage(
+//                                 "failed to notify response handler on rejection, action: {}",
+//                                 holderToNotify.action()
+//                             ),
+//                             e
+//                         );
+//                     }
+
+//                     @Override
+//                     public void onFailure(Exception e) {
+//                         logger.warn(
+//                             () -> new ParameterizedMessage(
+//                                 "failed to notify response handler on exception, action: {}",
+//                                 holderToNotify.action()
+//                             ),
+//                             e
+//                         );
+//                     }
+
+//                     @Override
+//                     public void doRun() {
+//                         ProtobufTransportException ex = new ProtobufSendRequestTransportException(
+//                             holderToNotify.connection().getNode(),
+//                             holderToNotify.action(),
+//                             new ProtobufNodeClosedException(localNode)
+//                         );
+//                         holderToNotify.handler().handleException(ex);
+//                     }
+//                 });
+//             }
+//         }
+//     }
+
+//     @Override
+//     protected void doClose() throws IOException {
+//         transport.close();
+//     }
+
+//     /**
+//      * start accepting incoming requests.
+//     * when the transport layer starts up it will block any incoming requests until
+//     * this method is called
+//     */
+//     public final void acceptIncomingRequests() {
+//         handleIncomingRequests.set(true);
+//     }
+
+//     @Override
+//     public ProtobufTransportInfo protobufInfo() {
+//         BoundTransportAddress boundTransportAddress = boundAddress();
+//         if (boundTransportAddress == null) {
+//             return null;
+//         }
+//         return new ProtobufTransportInfo(boundTransportAddress, transport.profileBoundAddresses());
+//     }
+
+//     public ProtobufTransportStats stats() {
+//         return transport.getProtobufStats();
+//     }
+
+//     public boolean isTransportSecure() {
+//         return transport.isSecure();
+//     }
+
+//     public BoundTransportAddress boundAddress() {
+//         return transport.boundAddress();
+//     }
+
+//     public List<String> getDefaultSeedAddresses() {
+//         return transport.getDefaultSeedAddresses();
+//     }
+
+//     /**
+//      * Returns <code>true</code> iff the given node is already connected.
+//     */
+//     public boolean nodeConnected(DiscoveryNode node) {
+//         return isLocalNode(node) || connectionManager.nodeConnected(node);
+//     }
+
+//     /**
+//      * Connect to the specified node with the default connection profile
+//     *
+//     * @param node the node to connect to
+//     */
+//     public void connectToNode(DiscoveryNode node) throws ProtobufConnectTransportException {
+//         connectToNode(node, (ConnectionProfile) null);
+//     }
+
+//     // We are skipping node validation for extensibility as extensionNode and opensearchNode(LocalNode) will have different ephemeral id's
+//     public void connectToExtensionNode(final DiscoveryNode node) {
+//         PlainActionFuture.get(fut -> connectToExtensionNode(node, (ConnectionProfile) null, ActionListener.map(fut, x -> null)));
+//     }
+
+//     /**
+//      * Connect to the specified node with the given connection profile
+//     *
+//     * @param node the node to connect to
+//     * @param connectionProfile the connection profile to use when connecting to this node
+//     */
+//     public void connectToNode(final DiscoveryNode node, ConnectionProfile connectionProfile) {
+//         PlainActionFuture.get(fut -> connectToNode(node, connectionProfile, ActionListener.map(fut, x -> null)));
+//     }
+
+//     public void connectToExtensionNode(final DiscoveryNode node, ConnectionProfile connectionProfile) {
+//         PlainActionFuture.get(fut -> connectToExtensionNode(node, connectionProfile, ActionListener.map(fut, x -> null)));
+//     }
+
+//     /**
+//      * Connect to the specified node with the given connection profile.
+//     * The ActionListener will be called on the calling thread or the generic thread pool.
+//     *
+//     * @param node the node to connect to
+//     * @param listener the action listener to notify
+//     */
+//     public void connectToNode(DiscoveryNode node, ActionListener<Void> listener) throws ProtobufConnectTransportException {
+//         connectToNode(node, null, listener);
+//     }
+
+//     public void connectToExtensionNode(DiscoveryNode node, ActionListener<Void> listener) throws ProtobufConnectTransportException {
+//         connectToExtensionNode(node, null, listener);
+//     }
+
+//     /**
+//      * Connect to the specified node with the given connection profile.
+//     * The ActionListener will be called on the calling thread or the generic thread pool.
+//     *
+//     * @param node the node to connect to
+//     * @param connectionProfile the connection profile to use when connecting to this node
+//     * @param listener the action listener to notify
+//     */
+//     public void connectToNode(final DiscoveryNode node, ConnectionProfile connectionProfile, ActionListener<Void> listener) {
+//         System.out.println("ProtobufTransportService.connectToNode");
+//         if (isLocalNode(node)) {
+//             listener.onResponse(null);
+//             return;
+//         }
+//         connectionManager.connectToNode(node, connectionProfile, connectionValidator(node), listener);
+//     }
+
+//     public void connectToExtensionNode(
+//         final DiscoveryNode node,
+//         ConnectionProfile connectionProfile,
+//         ActionListener<Void> listener
+//     ) {
+//         if (isLocalNode(node)) {
+//             listener.onResponse(null);
+//             return;
+//         }
+//         connectionManager.connectToNode(node, connectionProfile, extensionConnectionValidator(node), listener);
+//     }
+
+//     public ConnectionManager.ConnectionValidator connectionValidator(DiscoveryNode node) {
+//         return (newConnection, actualProfile, listener) -> {
+//             // We don't validate cluster names to allow for CCS connections.
+//             handshake(newConnection, actualProfile.getHandshakeTimeout().millis(), cn -> true, ActionListener.map(listener, resp -> {
+//                 final DiscoveryNode remote = resp.discoveryNode;
+
+//                 if (node.equals(remote) == false) {
+//                     throw new ProtobufConnectTransportException(node, "handshake failed. unexpected remote node " + remote);
+//                 }
+
+//                 return null;
+//             }));
+//         };
+//     }
+
+//     public ConnectionManager.ConnectionValidator extensionConnectionValidator(DiscoveryNode node) {
+//         return (newConnection, actualProfile, listener) -> {
+//             // We don't validate cluster names to allow for CCS connections.
+//             handshake(newConnection, actualProfile.getHandshakeTimeout().millis(), cn -> true, ActionListener.map(listener, resp -> {
+//                 final DiscoveryNode remote = resp.discoveryNode;
+//                 logger.info("Connection validation was skipped");
+//                 return null;
+//             }));
+//         };
+//     }
+
+//     /**
+//      * Establishes and returns a new connection to the given node. The connection is NOT maintained by this service, it's the callers
+//     * responsibility to close the connection once it goes out of scope.
+//     * The ActionListener will be called on the calling thread or the generic thread pool.
+//     * @param node the node to connect to
+//     * @param connectionProfile the connection profile to use
+//     */
+//     public Transport.Connection openConnection(final DiscoveryNode node, ConnectionProfile connectionProfile) {
+//         return PlainActionFuture.get(fut -> openConnection(node, connectionProfile, fut));
+//     }
+
+//     /**
+//      * Establishes a new connection to the given node. The connection is NOT maintained by this service, it's the callers
+//     * responsibility to close the connection once it goes out of scope.
+//     * The ActionListener will be called on the calling thread or the generic thread pool.
+//     * @param node the node to connect to
+//     * @param connectionProfile the connection profile to use
+//     * @param listener the action listener to notify
+//     */
+//     public void openConnection(
+//         final DiscoveryNode node,
+//         ConnectionProfile connectionProfile,
+//         ActionListener<Transport.Connection> listener
+//     ) {
+//         if (isLocalNode(node)) {
+//             listener.onResponse(localNodeConnection);
+//         } else {
+//             connectionManager.openConnection(node, connectionProfile, listener);
+//         }
+//     }
+
+//     /**
+//      * Executes a high-level handshake using the given connection
+//     * and returns the discovery node of the node the connection
+//     * was established with. The handshake will fail if the cluster
+//     * name on the target node mismatches the local cluster name.
+//     * The ActionListener will be called on the calling thread or the generic thread pool.
+//     *
+//     * @param connection       the connection to a specific node
+//     * @param handshakeTimeout handshake timeout
+//     * @param listener         action listener to notify
+//     * @throws ProtobufConnectTransportException if the connection failed
+//     * @throws IllegalStateException if the handshake failed
+//     */
+//     public void handshake(
+//         final Transport.Connection connection,
+//         final long handshakeTimeout,
+//         final ActionListener<DiscoveryNode> listener
+//     ) {
+//         handshake(
+//             connection,
+//             handshakeTimeout,
+//             clusterName.getEqualityPredicate(),
+//             ActionListener.map(listener, HandshakeResponse::getDiscoveryNode)
+//         );
+//     }
+
+//     /**
+//      * Executes a high-level handshake using the given connection
+//     * and returns the discovery node of the node the connection
+//     * was established with. The handshake will fail if the cluster
+//     * name on the target node doesn't match the local cluster name.
+//     * The ActionListener will be called on the calling thread or the generic thread pool.
+//     *
+//     * @param connection       the connection to a specific node
+//     * @param handshakeTimeout handshake timeout
+//     * @param clusterNamePredicate cluster name validation predicate
+//     * @param listener         action listener to notify
+//     * @throws IllegalStateException if the handshake failed
+//     */
+//     public void handshake(
+//         final Transport.Connection connection,
+//         final long handshakeTimeout,
+//         Predicate<ClusterName> clusterNamePredicate,
+//         final ActionListener<HandshakeResponse> listener
+//     ) {
+//         final DiscoveryNode node = connection.getNode();
+//         sendRequest(
+//             connection,
+//             HANDSHAKE_ACTION_NAME,
+//             HandshakeRequest.INSTANCE,
+//             TransportRequestOptions.builder().withTimeout(handshakeTimeout).build(),
+//             new ProtobufActionListenerResponseHandler<>(new ActionListener<HandshakeResponse>() {
+//                 @Override
+//                 public void onResponse(HandshakeResponse response) {
+//                     if (clusterNamePredicate.test(response.clusterName) == false) {
+//                         listener.onFailure(
+//                             new IllegalStateException(
+//                                 "handshake with ["
+//                                     + node
+//                                     + "] failed: remote cluster name ["
+//                                     + response.clusterName.value()
+//                                     + "] does not match "
+//                                     + clusterNamePredicate
+//                             )
+//                         );
+//                     } else if (response.version.isCompatible(localNode.getVersion()) == false) {
+//                         listener.onFailure(
+//                             new IllegalStateException(
+//                                 "handshake with ["
+//                                     + node
+//                                     + "] failed: remote node version ["
+//                                     + response.version
+//                                     + "] is incompatible with local node version ["
+//                                     + localNode.getVersion()
+//                                     + "]"
+//                             )
+//                         );
+//                     } else {
+//                         listener.onResponse(response);
+//                     }
+//                 }
+
+//                 @Override
+//                 public void onFailure(Exception e) {
+//                     listener.onFailure(e);
+//                 }
+//             }, HandshakeResponse::new, ThreadPool.Names.GENERIC)
+//         );
+//     }
+
+//     public ConnectionManager getConnectionManager() {
+//         return connectionManager;
+//     }
+
+//     /**
+//      * Internal Handshake request
+//     *
+//     * @opensearch.internal
+//     */
+//     static class HandshakeRequest extends TransportRequest {
+
+//         public static final HandshakeRequest INSTANCE = new HandshakeRequest();
+
+//         HandshakeRequest(CodedInputStream in) throws IOException {
+//             super(in);
+//         }
+
+//         private HandshakeRequest() {}
+
+//     }
+
+//     /**
+//      * Internal handshake response
+//     *
+//     * @opensearch.internal
+//     */
+//     public static class HandshakeResponse extends TransportResponse {
+//         private final DiscoveryNode discoveryNode;
+//         private final ClusterName clusterName;
+//         private final Version version;
+
+//         public HandshakeResponse(DiscoveryNode discoveryNode, ClusterName clusterName, Version version) {
+//             this.discoveryNode = discoveryNode;
+//             this.version = version;
+//             this.clusterName = clusterName;
+//         }
+
+//         public HandshakeResponse(CodedInputStream in) throws IOException {
+//             super(in);
+//             ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+//             discoveryNode = protobufStreamInput.readOptionalWriteable(DiscoveryNode::new);
+//             clusterName = new ClusterName(in);
+//             version = Version.readVersionProtobuf(in);
+//         }
+
+//         @Override
+//         public void writeTo(CodedOutputStream out) throws IOException {
+//             ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+//             protobufStreamOutput.writeOptionalWriteable(discoveryNode);
+//             clusterName.writeTo(out);
+//             out.writeInt32NoTag(version.id);
+//         }
+
+//         public DiscoveryNode getDiscoveryNode() {
+//             return discoveryNode;
+//         }
+
+//         public ClusterName getClusterName() {
+//             return clusterName;
+//         }
+//     }
+
+//     public void disconnectFromNode(DiscoveryNode node) {
+//         if (isLocalNode(node)) {
+//             return;
+//         }
+//         connectionManager.disconnectFromNode(node);
+//     }
+
+//     public void addMessageListener(ProtobufTransportMessageListener listener) {
+//         messageListener.listeners.add(listener);
+//     }
+
+//     public boolean removeMessageListener(ProtobufTransportMessageListener listener) {
+//         return messageListener.listeners.remove(listener);
+//     }
+
+//     public void addConnectionListener(TransportConnectionListener listener) {
+//         connectionManager.addListener(listener);
+//     }
+
+//     public void removeConnectionListener(TransportConnectionListener listener) {
+//         connectionManager.removeListener(listener);
+//     }
+
+//     public <T extends TransportResponse> TransportFuture<T> submitRequest(
+//         DiscoveryNode node,
+//         String action,
+//         TransportRequest request,
+//         ProtobufTransportResponseHandler<T> handler
+//     ) throws ProtobufTransportException {
+//         return submitRequest(node, action, request, TransportRequestOptions.EMPTY, handler);
+//     }
+
+//     public <T extends TransportResponse> TransportFuture<T> submitRequest(
+//         DiscoveryNode node,
+//         String action,
+//         TransportRequest request,
+//         TransportRequestOptions options,
+//         ProtobufTransportResponseHandler<T> handler
+//     ) throws ProtobufTransportException {
+//         ProtobufPlainTransportFuture<T> futureHandler = new ProtobufPlainTransportFuture<>(handler);
+//         try {
+//             Transport.Connection connection = getConnection(node);
+//             sendRequest(connection, action, request, options, futureHandler);
+//         } catch (ProtobufNodeNotConnectedException ex) {
+//             // the caller might not handle this so we invoke the handler
+//             futureHandler.handleException(ex);
+//         }
+//         return futureHandler;
+//     }
+
+//     public <T extends TransportResponse> void sendRequest(
+//         final DiscoveryNode node,
+//         final String action,
+//         final TransportRequest request,
+//         final ProtobufTransportResponseHandler<T> handler
+//     ) {
+//         final Transport.Connection connection;
+//         try {
+//             connection = getConnection(node);
+//         } catch (final ProtobufNodeNotConnectedException ex) {
+//             // the caller might not handle this so we invoke the handler
+//             handler.handleException(ex);
+//             return;
+//         }
+//         sendRequest(connection, action, request, TransportRequestOptions.EMPTY, handler);
+//     }
+
+//     public final <T extends TransportResponse> void sendRequest(
+//         final DiscoveryNode node,
+//         final String action,
+//         final TransportRequest request,
+//         final TransportRequestOptions options,
+//         ProtobufTransportResponseHandler<T> handler
+//     ) {
+//         final Transport.Connection connection;
+//         try {
+//             connection = getConnection(node);
+//         } catch (final ProtobufNodeNotConnectedException ex) {
+//             // the caller might not handle this so we invoke the handler
+//             handler.handleException(ex);
+//             return;
+//         }
+//         sendRequest(connection, action, request, options, handler);
+//     }
+
+//     /**
+//      * Sends a request on the specified connection. If there is a failure sending the request, the specified handler is invoked.
+//     *
+//     * @param connection the connection to send the request on
+//     * @param action     the name of the action
+//     * @param request    the request
+//     * @param options    the options for this request
+//     * @param handler    the response handler
+//     * @param <T>        the type of the transport response
+//     */
+//     public final <T extends TransportResponse> void sendRequest(
+//         final Transport.Connection connection,
+//         final String action,
+//         final TransportRequest request,
+//         final TransportRequestOptions options,
+//         final ProtobufTransportResponseHandler<T> handler
+//     ) {
+//         try {
+//             logger.debug("Action: " + action);
+//             final ProtobufTransportResponseHandler<T> delegate;
+//             if (request.getParentTask().isSet()) {
+//                 // TODO: capture the connection instead so that we can cancel child tasks on the remote connections.
+//                 final Releasable unregisterChildNode = taskManager.registerProtobufChildNode(
+//                     request.getParentTask().getId(),
+//                     connection.getNode()
+//                 );
+//                 delegate = new ProtobufTransportResponseHandler<T>() {
+//                     @Override
+//                     public void handleResponse(T response) {
+//                         unregisterChildNode.close();
+//                         handler.handleResponse(response);
+//                     }
+
+//                     @Override
+//                     public void handleException(ProtobufTransportException exp) {
+//                         unregisterChildNode.close();
+//                         handler.handleException(exp);
+//                     }
+
+//                     @Override
+//                     public String executor() {
+//                         return handler.executor();
+//                     }
+
+//                     @Override
+//                     public T read(CodedInputStream in) throws IOException {
+//                         return handler.read(in);
+//                     }
+
+//                     @Override
+//                     public String toString() {
+//                         return getClass().getName() + "/[" + action + "]:" + handler.toString();
+//                     }
+//                 };
+//             } else {
+//                 delegate = handler;
+//             }
+//             asyncSender.sendRequest(connection, action, request, options, delegate);
+//         } catch (final Exception ex) {
+//             // the caller might not handle this so we invoke the handler
+//             final ProtobufTransportException te;
+//             if (ex instanceof ProtobufTransportException) {
+//                 te = (ProtobufTransportException) ex;
+//             } else {
+//                 te = new ProtobufTransportException("failure to send", ex);
+//             }
+//             handler.handleException(te);
+//         }
+//     }
+
+//     /**
+//      * Returns either a real transport connection or a local node connection if we are using the local node optimization.
+//     * @throws ProtobufNodeNotConnectedException if the given node is not connected
+//     */
+//     public Transport.Connection getConnection(DiscoveryNode node) {
+//         System.out.println("Protobuf transport service");
+//         System.out.println("Getting connection for node " + node);
+//         if (isLocalNode(node)) {
+//             System.out.println("Is local node");
+//             return localNodeConnection;
+//         } else {
+//             System.out.println("Not local node");
+//             return connectionManager.getConnection(node);
+//         }
+//     }
+
+//     public final <T extends TransportResponse> void sendChildRequest(
+//         final DiscoveryNode node,
+//         final String action,
+//         final TransportRequest request,
+//         final ProtobufTask parentTask,
+//         final TransportRequestOptions options,
+//         final ProtobufTransportResponseHandler<T> handler
+//     ) {
+//         final Transport.Connection connection;
+//         try {
+//             connection = getConnection(node);
+//         } catch (final ProtobufNodeNotConnectedException ex) {
+//             // the caller might not handle this so we invoke the handler
+//             handler.handleException(ex);
+//             return;
+//         }
+//         sendChildRequest(connection, action, request, parentTask, options, handler);
+//     }
+
+//     public <T extends TransportResponse> void sendChildRequest(
+//         final Transport.Connection connection,
+//         final String action,
+//         final TransportRequest request,
+//         final ProtobufTask parentTask,
+//         final ProtobufTransportResponseHandler<T> handler
+//     ) {
+//         sendChildRequest(connection, action, request, parentTask, TransportRequestOptions.EMPTY, handler);
+//     }
+
+//     public <T extends TransportResponse> void sendChildRequest(
+//         final Transport.Connection connection,
+//         final String action,
+//         final TransportRequest request,
+//         final ProtobufTask parentTask,
+//         final TransportRequestOptions options,
+//         final ProtobufTransportResponseHandler<T> handler
+//     ) {
+//         request.setParentTask(localNode.getId(), parentTask.getId());
+//         sendRequest(connection, action, request, options, handler);
+//     }
+
+//     private <T extends TransportResponse> void sendRequestInternal(
+//         final Transport.Connection connection,
+//         final String action,
+//         final TransportRequest request,
+//         final TransportRequestOptions options,
+//         ProtobufTransportResponseHandler<T> handler
+//     ) {
+//         if (connection == null) {
+//             throw new IllegalStateException("can't send request to a null connection");
+//         }
+//         DiscoveryNode node = connection.getNode();
+
+//         Supplier<ThreadContext.StoredContext> storedContextSupplier = threadPool.getThreadContext().newRestorableContext(true);
+//         ContextRestoreResponseHandler<T> responseHandler = new ContextRestoreResponseHandler<>(storedContextSupplier, handler);
+//         // TODO we can probably fold this entire request ID dance into connection.sendReqeust but it will be a bigger refactoring
+//         final long requestId = responseHandlers.add(new Transport.ProtobufResponseContext<>(responseHandler, connection, action));
+//         final TimeoutHandler timeoutHandler;
+//         if (options.timeout() != null) {
+//             timeoutHandler = new TimeoutHandler(requestId, connection.getNode(), action);
+//             responseHandler.setTimeoutHandler(timeoutHandler);
+//         } else {
+//             timeoutHandler = null;
+//         }
+//         try {
+//             if (lifecycle.stoppedOrClosed()) {
+//                 /*
+//                 * If we are not started the exception handling will remove the request holder again and calls the handler to notify the
+//                 * caller. It will only notify if toStop hasn't done the work yet.
+//                 */
+//                 throw new ProtobufNodeClosedException(localNode);
+//             }
+//             if (timeoutHandler != null) {
+//                 assert options.timeout() != null;
+//                 timeoutHandler.scheduleTimeout(options.timeout());
+//             }
+//             connection.sendRequestProtobuf(requestId, action, request, options); // local node optimization happens upstream
+//         } catch (final Exception e) {
+//             // usually happen either because we failed to connect to the node
+//             // or because we failed serializing the message
+//             final Transport.ProtobufResponseContext<? extends TransportResponse> contextToNotify = responseHandlers.remove(
+//                 requestId
+//             );
+//             // If holderToNotify == null then handler has already been taken care of.
+//             if (contextToNotify != null) {
+//                 if (timeoutHandler != null) {
+//                     timeoutHandler.cancel();
+//                 }
+//                 // callback that an exception happened, but on a different thread since we don't
+//                 // want handlers to worry about stack overflows. In the special case of running into a closing node we run on the current
+//                 // thread on a best effort basis though.
+//                 final ProtobufSendRequestTransportException sendRequestException = new ProtobufSendRequestTransportException(
+//                     node,
+//                     action,
+//                     e
+//                 );
+//                 final String executor = lifecycle.stoppedOrClosed() ? ThreadPool.Names.SAME : ThreadPool.Names.GENERIC;
+//                 threadPool.executor(executor).execute(new AbstractRunnable() {
+//                     @Override
+//                     public void onRejection(Exception e) {
+//                         // if we get rejected during node shutdown we don't wanna bubble it up
+//                         logger.debug(
+//                             () -> new ParameterizedMessage(
+//                                 "failed to notify response handler on rejection, action: {}",
+//                                 contextToNotify.action()
+//                             ),
+//                             e
+//                         );
+//                     }
+
+//                     @Override
+//                     public void onFailure(Exception e) {
+//                         logger.warn(
+//                             () -> new ParameterizedMessage(
+//                                 "failed to notify response handler on exception, action: {}",
+//                                 contextToNotify.action()
+//                             ),
+//                             e
+//                         );
+//                     }
+
+//                     @Override
+//                     protected void doRun() throws Exception {
+//                         contextToNotify.handler().handleException(sendRequestException);
+//                     }
+//                 });
+//             } else {
+//                 logger.debug("Exception while sending request, handler likely already notified due to timeout", e);
+//             }
+//         }
+//     }
+
+//     private void sendLocalRequest(
+//         long requestId,
+//         final String action,
+//         final TransportRequest request,
+//         TransportRequestOptions options
+//     ) {
+//         final DirectResponseChannel channel = new DirectResponseChannel(localNode, action, requestId, this, threadPool);
+//         try {
+//             onRequestSent(localNode, requestId, action, request, options);
+//             onRequestReceived(requestId, action);
+//             final ProtobufRequestHandlerRegistry reg = getRequestHandler(action);
+//             if (reg == null) {
+//                 throw new ActionNotFoundTransportException("Action [" + action + "] not found");
+//             }
+//             final String executor = reg.getExecutor();
+//             if (ThreadPool.Names.SAME.equals(executor)) {
+//                 // noinspection unchecked
+//                 reg.processMessageReceived(request, channel);
+//             } else {
+//                 threadPool.executor(executor).execute(new AbstractRunnable() {
+//                     @Override
+//                     protected void doRun() throws Exception {
+//                         // noinspection unchecked
+//                         reg.processMessageReceived(request, channel);
+//                     }
+
+//                     @Override
+//                     public boolean isForceExecution() {
+//                         return reg.isForceExecution();
+//                     }
+
+//                     @Override
+//                     public void onFailure(Exception e) {
+//                         try {
+//                             channel.sendResponse(e);
+//                         } catch (Exception inner) {
+//                             inner.addSuppressed(e);
+//                             logger.warn(
+//                                 () -> new ParameterizedMessage("failed to notify channel of error message for action [{}]", action),
+//                                 inner
+//                             );
+//                         }
+//                     }
+
+//                     @Override
+//                     public String toString() {
+//                         return "processing of [" + requestId + "][" + action + "]: " + request;
+//                     }
+//                 });
+//             }
+
+//         } catch (Exception e) {
+//             try {
+//                 channel.sendResponse(e);
+//             } catch (Exception inner) {
+//                 inner.addSuppressed(e);
+//                 logger.warn(() -> new ParameterizedMessage("failed to notify channel of error message for action [{}]", action), inner);
+//             }
+//         }
+//     }
+
+//     private boolean shouldTraceAction(String action) {
+//         return shouldTraceAction(action, tracerLogInclude, tracerLogExclude);
+//     }
+
+//     public static boolean shouldTraceAction(String action, String[] include, String[] exclude) {
+//         if (include.length > 0) {
+//             if (Regex.simpleMatch(include, action) == false) {
+//                 return false;
+//             }
+//         }
+//         if (exclude.length > 0) {
+//             return !Regex.simpleMatch(exclude, action);
+//         }
+//         return true;
+//     }
+
+//     public TransportAddress[] addressesFromString(String address) throws UnknownHostException {
+//         return transport.addressesFromString(address);
+//     }
+
+//     /**
+//      * A set of all valid action prefixes.
+//     */
+//     public static final Set<String> VALID_ACTION_PREFIXES = Collections.unmodifiableSet(
+//         new HashSet<>(
+//             Arrays.asList(
+//                 "indices:admin",
+//                 "indices:monitor",
+//                 "indices:data/write",
+//                 "indices:data/read",
+//                 "indices:internal",
+//                 "cluster:admin",
+//                 "cluster:monitor",
+//                 "cluster:internal",
+//                 "internal:"
+//             )
+//         )
+//     );
+
+//     private void validateActionName(String actionName) {
+//         // TODO we should makes this a hard validation and throw an exception but we need a good way to add backwards layer
+//         // for it. Maybe start with a deprecation layer
+//         if (isValidActionName(actionName) == false) {
+//             logger.warn(
+//                 "invalid action name [" + actionName + "] must start with one of: " + ProtobufTransportService.VALID_ACTION_PREFIXES
+//             );
+//         }
+//     }
+
+//     /**
+//      * Returns <code>true</code> iff the action name starts with a valid prefix.
+//     *
+//     * @see #VALID_ACTION_PREFIXES
+//     */
+//     public static boolean isValidActionName(String actionName) {
+//         for (String prefix : VALID_ACTION_PREFIXES) {
+//             if (actionName.startsWith(prefix)) {
+//                 return true;
+//             }
+//         }
+//         return false;
+//     }
+
+//     /**
+//      * Registers a new request handler
+//     *
+//     * @param action         The action the request handler is associated with
+//     * @param requestReader  a callable to be used construct new instances for streaming
+//     * @param executor       The executor the request handling will be executed on
+//     * @param handler        The handler itself that implements the request handling
+//     */
+//     public <Request extends TransportRequest> void registerRequestHandler(
+//         String action,
+//         String executor,
+//         ProtobufWriteable.Reader<Request> requestReader,
+//         TransportRequestHandler<Request> handler
+//     ) {
+//         validateActionName(action);
+//         handler = interceptor.interceptHandler(action, executor, false, handler);
+//         ProtobufRequestHandlerRegistry<Request> reg = new ProtobufRequestHandlerRegistry<>(
+//             action,
+//             requestReader,
+//             taskManager,
+//             handler,
+//             executor,
+//             false,
+//             true
+//         );
+//         transport.registerProtobufRequestHandler(reg);
+//     }
+
+//     /**
+//      * Registers a new request handler
+//     *
+//     * @param action                The action the request handler is associated with
+//     * @param requestReader               The request class that will be used to construct new instances for streaming
+//     * @param executor              The executor the request handling will be executed on
+//     * @param forceExecution        Force execution on the executor queue and never reject it
+//     * @param canTripCircuitBreaker Check the request size and raise an exception in case the limit is breached.
+//     * @param handler               The handler itself that implements the request handling
+//     */
+//     public <Request extends TransportRequest> void registerRequestHandler(
+//         String action,
+//         String executor,
+//         boolean forceExecution,
+//         boolean canTripCircuitBreaker,
+//         ProtobufWriteable.Reader<Request> requestReader,
+//         TransportRequestHandler<Request> handler
+//     ) {
+//         validateActionName(action);
+//         handler = interceptor.interceptHandler(action, executor, forceExecution, handler);
+//         ProtobufRequestHandlerRegistry<Request> reg = new ProtobufRequestHandlerRegistry<>(
+//             action,
+//             requestReader,
+//             taskManager,
+//             handler,
+//             executor,
+//             forceExecution,
+//             canTripCircuitBreaker
+//         );
+//         transport.registerProtobufRequestHandler(reg);
+//     }
+
+//     /**
+//      * called by the {@link Transport} implementation when an incoming request arrives but before
+//     * any parsing of it has happened (with the exception of the requestId and action)
+//     */
+//     @Override
+//     public void onRequestReceived(long requestId, String action) {
+//         if (handleIncomingRequests.get() == false) {
+//             throw new IllegalStateException("transport not ready yet to handle incoming requests");
+//         }
+//         if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
+//             tracerLog.trace("[{}][{}] received request", requestId, action);
+//         }
+//         messageListener.onRequestReceived(requestId, action);
+//     }
+
+//     /** called by the {@link Transport} implementation once a request has been sent */
+//     @Override
+//     public void onRequestSent(
+//         DiscoveryNode node,
+//         long requestId,
+//         String action,
+//         TransportRequest request,
+//         TransportRequestOptions options
+//     ) {
+//         if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
+//             tracerLog.trace("[{}][{}] sent to [{}] (timeout: [{}])", requestId, action, node, options.timeout());
+//         }
+//         messageListener.onRequestSent(node, requestId, action, request, options);
+//     }
+
+//     @Override
+//     public void onResponseReceived(long requestId, Transport.ProtobufResponseContext holder) {
+//         if (holder == null) {
+//             checkForTimeout(requestId);
+//         } else if (tracerLog.isTraceEnabled() && shouldTraceAction(holder.action())) {
+//             tracerLog.trace("[{}][{}] received response from [{}]", requestId, holder.action(), holder.connection().getNode());
+//         }
+//         messageListener.onResponseReceived(requestId, holder);
+//     }
+
+//     /** called by the {@link Transport} implementation once a response was sent to calling node */
+//     @Override
+//     public void onResponseSent(long requestId, String action, TransportResponse response) {
+//         if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
+//             tracerLog.trace("[{}][{}] sent response", requestId, action);
+//         }
+//         messageListener.onResponseSent(requestId, action, response);
+//     }
+
+//     /** called by the {@link Transport} implementation after an exception was sent as a response to an incoming request */
+//     @Override
+//     public void onResponseSent(long requestId, String action, Exception e) {
+//         if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
+//             tracerLog.trace(() -> new ParameterizedMessage("[{}][{}] sent error response", requestId, action), e);
+//         }
+//         messageListener.onResponseSent(requestId, action, e);
+//     }
+
+//     public ProtobufRequestHandlerRegistry<? extends TransportRequest> getRequestHandler(String action) {
+//         return transport.getProtobufRequestHandlers().getHandler(action);
+//     }
+
+//     private void checkForTimeout(long requestId) {
+//         // lets see if its in the timeout holder, but sync on mutex to make sure any ongoing timeout handling has finished
+//         final DiscoveryNode sourceNode;
+//         final String action;
+//         assert responseHandlers.contains(requestId) == false;
+//         TimeoutInfoHolder timeoutInfoHolder = timeoutInfoHandlers.remove(requestId);
+//         if (timeoutInfoHolder != null) {
+//             long time = threadPool.relativeTimeInMillis();
+//             logger.warn(
+//                 "Received response for a request that has timed out, sent [{}ms] ago, timed out [{}ms] ago, "
+//                     + "action [{}], node [{}], id [{}]",
+//                 time - timeoutInfoHolder.sentTime(),
+//                 time - timeoutInfoHolder.timeoutTime(),
+//                 timeoutInfoHolder.action(),
+//                 timeoutInfoHolder.node(),
+//                 requestId
+//             );
+//             action = timeoutInfoHolder.action();
+//             sourceNode = timeoutInfoHolder.node();
+//         } else {
+//             logger.warn("ProtobufTransport response handler not found of id [{}]", requestId);
+//             action = null;
+//             sourceNode = null;
+//         }
+//         // call tracer out of lock
+//         if (tracerLog.isTraceEnabled() == false) {
+//             return;
+//         }
+//         if (action == null) {
+//             assert sourceNode == null;
+//             tracerLog.trace("[{}] received response but can't resolve it to a request", requestId);
+//         } else if (shouldTraceAction(action)) {
+//             tracerLog.trace("[{}][{}] received response from [{}]", requestId, action, sourceNode);
+//         }
+//     }
+
+//     @Override
+//     public void onConnectionClosed(Transport.Connection connection) {
+//         try {
+//             List<Transport.ProtobufResponseContext<? extends TransportResponse>> pruned = responseHandlers.prune(
+//                 h -> h.connection().getCacheKey().equals(connection.getCacheKey())
+//             );
+//             // callback that an exception happened, but on a different thread since we don't
+//             // want handlers to worry about stack overflows
+//             getExecutorService().execute(new Runnable() {
+//                 @Override
+//                 public void run() {
+//                     for (Transport.ProtobufResponseContext holderToNotify : pruned) {
+//                         holderToNotify.handler()
+//                             .handleException(new ProtobufNodeDisconnectedException(connection.getNode(), holderToNotify.action()));
+//                     }
+//                 }
+
+//                 @Override
+//                 public String toString() {
+//                     return "onConnectionClosed(" + connection.getNode() + ")";
+//                 }
+//             });
+//         } catch (OpenSearchRejectedExecutionException ex) {
+//             logger.debug("Rejected execution on onConnectionClosed", ex);
+//         }
+//     }
+
+//     final class TimeoutHandler implements Runnable {
+
+//         private final long requestId;
+//         private final long sentTime = threadPool.relativeTimeInMillis();
+//         private final String action;
+//         private final DiscoveryNode node;
+//         volatile Scheduler.Cancellable cancellable;
+
+//         TimeoutHandler(long requestId, DiscoveryNode node, String action) {
+//             this.requestId = requestId;
+//             this.node = node;
+//             this.action = action;
+//         }
+
+//         @Override
+//         public void run() {
+//             if (responseHandlers.contains(requestId)) {
+//                 long timeoutTime = threadPool.relativeTimeInMillis();
+//                 timeoutInfoHandlers.put(requestId, new TimeoutInfoHolder(node, action, sentTime, timeoutTime));
+//                 // now that we have the information visible via timeoutInfoHandlers, we try to remove the request id
+//                 final Transport.ProtobufResponseContext<? extends TransportResponse> holder = responseHandlers.remove(requestId);
+//                 if (holder != null) {
+//                     assert holder.action().equals(action);
+//                     assert holder.connection().getNode().equals(node);
+//                     holder.handler()
+//                         .handleException(
+//                             new ProtobufReceiveTimeoutTransportException(
+//                                 holder.connection().getNode(),
+//                                 holder.action(),
+//                                 "request_id [" + requestId + "] timed out after [" + (timeoutTime - sentTime) + "ms]"
+//                             )
+//                         );
+//                 } else {
+//                     // response was processed, remove timeout info.
+//                     timeoutInfoHandlers.remove(requestId);
+//                 }
+//             }
+//         }
+
+//         /**
+//          * cancels timeout handling. this is a best effort only to avoid running it. remove the requestId from {@link #responseHandlers}
+//         * to make sure this doesn't run.
+//         */
+//         public void cancel() {
+//             assert responseHandlers.contains(requestId) == false : "cancel must be called after the requestId ["
+//                 + requestId
+//                 + "] has been removed from clientHandlers";
+//             if (cancellable != null) {
+//                 cancellable.cancel();
+//             }
+//         }
+
+//         @Override
+//         public String toString() {
+//             return "timeout handler for [" + requestId + "][" + action + "]";
+//         }
+
+//         private void scheduleTimeout(TimeValue timeout) {
+//             this.cancellable = threadPool.schedule(this, timeout, ThreadPool.Names.GENERIC);
+//         }
+//     }
+
+//     /**
+//      * Holder for timeout information
+//     *
+//     * @opensearch.internal
+//     */
+//     static class TimeoutInfoHolder {
+
+//         private final DiscoveryNode node;
+//         private final String action;
+//         private final long sentTime;
+//         private final long timeoutTime;
+
+//         TimeoutInfoHolder(DiscoveryNode node, String action, long sentTime, long timeoutTime) {
+//             this.node = node;
+//             this.action = action;
+//             this.sentTime = sentTime;
+//             this.timeoutTime = timeoutTime;
+//         }
+
+//         public DiscoveryNode node() {
+//             return node;
+//         }
+
+//         public String action() {
+//             return action;
+//         }
+
+//         public long sentTime() {
+//             return sentTime;
+//         }
+
+//         public long timeoutTime() {
+//             return timeoutTime;
+//         }
+//     }
+
+//     /**
+//      * This handler wrapper ensures that the response thread executes with the correct thread context. Before any of the handle methods
+//     * are invoked we restore the context.
+//     */
+//     public static final class ContextRestoreResponseHandler<T extends TransportResponse>
+//         implements
+//             ProtobufTransportResponseHandler<T> {
+
+//         private final ProtobufTransportResponseHandler<T> delegate;
+//         private final Supplier<ThreadContext.StoredContext> contextSupplier;
+//         private volatile TimeoutHandler handler;
+
+//         public ContextRestoreResponseHandler(
+//             Supplier<ThreadContext.StoredContext> contextSupplier,
+//             ProtobufTransportResponseHandler<T> delegate
+//         ) {
+//             this.delegate = delegate;
+//             this.contextSupplier = contextSupplier;
+//         }
+
+//         @Override
+//         public T read(CodedInputStream in) throws IOException {
+//             return delegate.read(in);
+//         }
+
+//         @Override
+//         public void handleResponse(T response) {
+//             if (handler != null) {
+//                 handler.cancel();
+//             }
+//             try (ThreadContext.StoredContext ignore = contextSupplier.get()) {
+//                 delegate.handleResponse(response);
+//             }
+//         }
+
+//         @Override
+//         public void handleException(ProtobufTransportException exp) {
+//             if (handler != null) {
+//                 handler.cancel();
+//             }
+//             try (ThreadContext.StoredContext ignore = contextSupplier.get()) {
+//                 delegate.handleException(exp);
+//             }
+//         }
+
+//         @Override
+//         public String executor() {
+//             return delegate.executor();
+//         }
+
+//         @Override
+//         public String toString() {
+//             return getClass().getName() + "/" + delegate.toString();
+//         }
+
+//         void setTimeoutHandler(TimeoutHandler handler) {
+//             this.handler = handler;
+//         }
+
+//     }
+
+//     /**
+//      * A channel for a direct response
+//     *
+//     * @opensearch.internal
+//     */
+//     static class DirectResponseChannel implements ProtobufTransportChannel {
+//         final DiscoveryNode localNode;
+//         private final String action;
+//         private final long requestId;
+//         final ProtobufTransportService service;
+//         final ThreadPool threadPool;
+
+//         DirectResponseChannel(
+//             DiscoveryNode localNode,
+//             String action,
+//             long requestId,
+//             ProtobufTransportService service,
+//             ThreadPool threadPool
+//         ) {
+//             this.localNode = localNode;
+//             this.action = action;
+//             this.requestId = requestId;
+//             this.service = service;
+//             this.threadPool = threadPool;
+//         }
+
+//         @Override
+//         public String getProfileName() {
+//             return DIRECT_RESPONSE_PROFILE;
+//         }
+
+//         @Override
+//         public void sendResponse(TransportResponse response) throws IOException {
+//             service.onResponseSent(requestId, action, response);
+//             final ProtobufTransportResponseHandler handler = service.responseHandlers.onResponseReceived(requestId, service);
+//             // ignore if its null, the service logs it
+//             if (handler != null) {
+//                 final String executor = handler.executor();
+//                 if (ThreadPool.Names.SAME.equals(executor)) {
+//                     processResponse(handler, response);
+//                 } else {
+//                     threadPool.executor(executor).execute(new Runnable() {
+//                         @Override
+//                         public void run() {
+//                             processResponse(handler, response);
+//                         }
+
+//                         @Override
+//                         public String toString() {
+//                             return "delivery of response to [" + requestId + "][" + action + "]: " + response;
+//                         }
+//                     });
+//                 }
+//             }
+//         }
+
+//         @SuppressWarnings("unchecked")
+//         protected void processResponse(ProtobufTransportResponseHandler handler, TransportResponse response) {
+//             try {
+//                 handler.handleResponse(response);
+//             } catch (Exception e) {
+//                 processException(handler, wrapInRemote(new ResponseHandlerFailureTransportException(e)));
+//             }
+//         }
+
+//         @Override
+//         public void sendResponse(Exception exception) throws IOException {
+//             service.onResponseSent(requestId, action, exception);
+//             final ProtobufTransportResponseHandler handler = service.responseHandlers.onResponseReceived(requestId, service);
+//             // ignore if its null, the service logs it
+//             if (handler != null) {
+//                 final ProtobufRemoteTransportException rtx = wrapInRemote(exception);
+//                 final String executor = handler.executor();
+//                 if (ThreadPool.Names.SAME.equals(executor)) {
+//                     processException(handler, rtx);
+//                 } else {
+//                     threadPool.executor(handler.executor()).execute(new Runnable() {
+//                         @Override
+//                         public void run() {
+//                             processException(handler, rtx);
+//                         }
+
+//                         @Override
+//                         public String toString() {
+//                             return "delivery of failure response to [" + requestId + "][" + action + "]: " + exception;
+//                         }
+//                     });
+//                 }
+//             }
+//         }
+
+//         protected ProtobufRemoteTransportException wrapInRemote(Exception e) {
+//             if (e instanceof ProtobufRemoteTransportException) {
+//                 return (ProtobufRemoteTransportException) e;
+//             }
+//             return new ProtobufRemoteTransportException(localNode.getName(), localNode.getAddress(), action, e);
+//         }
+
+//         protected void processException(final ProtobufTransportResponseHandler handler, final ProtobufRemoteTransportException rtx) {
+//             try {
+//                 handler.handleException(rtx);
+//             } catch (Exception e) {
+//                 logger.error(
+//                     () -> new ParameterizedMessage("failed to handle exception for action [{}], handler [{}]", action, handler),
+//                     e
+//                 );
+//             }
+//         }
+
+//         @Override
+//         public String getChannelType() {
+//             return "direct";
+//         }
+
+//         @Override
+//         public Version getVersion() {
+//             return localNode.getVersion();
+//         }
+//     }
+
+//     /**
+//      * Returns the internal thread pool
+//     */
+//     public ThreadPool getThreadPool() {
+//         return threadPool;
+//     }
+
+//     private boolean isLocalNode(DiscoveryNode discoveryNode) {
+//         return Objects.requireNonNull(discoveryNode, "discovery node must not be null").equals(localNode);
+//     }
+
+//     private static final class DelegatingTransportMessageListener implements ProtobufTransportMessageListener {
+
+//         private final List<ProtobufTransportMessageListener> listeners = new CopyOnWriteArrayList<>();
+
+//         @Override
+//         public void onRequestReceived(long requestId, String action) {
+//             for (ProtobufTransportMessageListener listener : listeners) {
+//                 listener.onRequestReceived(requestId, action);
+//             }
+//         }
+
+//         @Override
+//         public void onResponseSent(long requestId, String action, TransportResponse response) {
+//             for (ProtobufTransportMessageListener listener : listeners) {
+//                 listener.onResponseSent(requestId, action, response);
+//             }
+//         }
+
+//         @Override
+//         public void onResponseSent(long requestId, String action, Exception error) {
+//             for (ProtobufTransportMessageListener listener : listeners) {
+//                 listener.onResponseSent(requestId, action, error);
+//             }
+//         }
+
+//         @Override
+//         public void onRequestSent(
+//             DiscoveryNode node,
+//             long requestId,
+//             String action,
+//             TransportRequest request,
+//             TransportRequestOptions finalOptions
+//         ) {
+//             for (ProtobufTransportMessageListener listener : listeners) {
+//                 listener.onRequestSent(node, requestId, action, request, finalOptions);
+//             }
+//         }
+
+//         @Override
+//         public void onResponseReceived(long requestId, Transport.ProtobufResponseContext holder) {
+//             for (ProtobufTransportMessageListener listener : listeners) {
+//                 listener.onResponseReceived(requestId, holder);
+//             }
+//         }
+//     }
+// }
diff --git a/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java b/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java
index d95c0c647916b..c66b5d5fed21d 100644
--- a/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java
+++ b/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java
@@ -45,6 +45,8 @@
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.threadpool.ThreadPool;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.Closeable;
 import java.io.IOException;
 import java.util.function.Function;
@@ -170,6 +172,18 @@ public void handleException(TransportException exp) {
                         public String executor() {
                             return ThreadPool.Names.SAME;
                         }
+
+                        @Override
+                        public ClusterStateResponse read(CodedInputStream in) throws IOException {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'read'");
+                        }
+
+                        @Override
+                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                        }
                     }
                 );
             }
diff --git a/server/src/main/java/org/opensearch/transport/RemoteClusterService.java b/server/src/main/java/org/opensearch/transport/RemoteClusterService.java
index 5ed96e9d85943..598fb932f93e4 100644
--- a/server/src/main/java/org/opensearch/transport/RemoteClusterService.java
+++ b/server/src/main/java/org/opensearch/transport/RemoteClusterService.java
@@ -152,22 +152,22 @@ public boolean isEnabled() {
     private final TransportService transportService;
     private final Map<String, RemoteClusterConnection> remoteClusters = ConcurrentCollections.newConcurrentMap();
 
-    private final ProtobufTransportService protobufTransportService;
+    private final TransportService TransportService;
     private final Map<String, ProtobufRemoteClusterConnection> remoteClustersProtobuf = ConcurrentCollections.newConcurrentMap();
 
     RemoteClusterService(Settings settings, TransportService transportService) {
         super(settings);
         this.enabled = DiscoveryNode.isRemoteClusterClient(settings);
         this.transportService = transportService;
-        this.protobufTransportService = null;
+        this.TransportService = null;
     }
 
-    RemoteClusterService(Settings settings, ProtobufTransportService transportService) {
-        super(settings);
-        this.enabled = DiscoveryNode.isRemoteClusterClient(settings);
-        this.protobufTransportService = transportService;
-        this.transportService = null;
-    }
+    // RemoteClusterService(Settings settings, TransportService transportService) {
+    //     super(settings);
+    //     this.enabled = DiscoveryNode.isRemoteClusterClient(settings);
+    //     this.TransportService = transportService;
+    //     this.transportService = null;
+    // }
 
     /**
      * Returns <code>true</code> if at least one remote cluster is configured
@@ -231,14 +231,14 @@ public Transport.Connection getConnection(DiscoveryNode node, String cluster) {
         return getRemoteClusterConnection(cluster).getConnection(node);
     }
 
-    /**
-     * Returns a connection to the given node on the given remote cluster
-     *
-     * @throws IllegalArgumentException if the remote cluster is unknown
-     */
-    public Transport.ProtobufConnection getConnectionProtobuf(DiscoveryNode node, String cluster) {
-        return getRemoteClusterConnectionProtobuf(cluster).getConnection(node);
-    }
+    // /**
+    //  * Returns a connection to the given node on the given remote cluster
+    //  *
+    //  * @throws IllegalArgumentException if the remote cluster is unknown
+    //  */
+    // public Transport.ProtobufConnection getConnectionProtobuf(DiscoveryNode node, String cluster) {
+    //     return getRemoteClusterConnectionProtobuf(cluster).getConnection(node);
+    // }
 
     /**
      * Ensures that the given cluster alias is connected. If the cluster is connected this operation
@@ -259,9 +259,9 @@ public Transport.Connection getConnection(String cluster) {
         return getRemoteClusterConnection(cluster).getConnection();
     }
 
-    public Transport.ProtobufConnection getConnectionProtobuf(String cluster) {
-        return getRemoteClusterConnectionProtobuf(cluster).getConnection();
-    }
+    // public Transport.ProtobufConnection getConnectionProtobuf(String cluster) {
+    //     return getRemoteClusterConnectionProtobuf(cluster).getConnection();
+    // }
 
     RemoteClusterConnection getRemoteClusterConnection(String cluster) {
         if (enabled == false) {
@@ -472,15 +472,15 @@ public Client getRemoteClusterClient(ThreadPool threadPool, String clusterAlias)
     * @throws IllegalArgumentException if the given clusterAlias doesn't exist
     */
     public ProtobufClient getRemoteClusterClientProtobuf(ThreadPool threadPool, String clusterAlias) {
-        if (protobufTransportService.getRemoteClusterService().isEnabled() == false) {
+        if (TransportService.getRemoteClusterService().isEnabled() == false) {
             throw new IllegalArgumentException(
                 "this node does not have the " + DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName() + " role"
             );
         }
-        if (protobufTransportService.getRemoteClusterService().getRemoteClusterNames().contains(clusterAlias) == false) {
+        if (TransportService.getRemoteClusterService().getRemoteClusterNames().contains(clusterAlias) == false) {
             throw new NoSuchRemoteClusterException(clusterAlias);
         }
-        return new ProtobufRemoteClusterAwareClient(settings, threadPool, protobufTransportService, clusterAlias);
+        return new ProtobufRemoteClusterAwareClient(settings, threadPool, TransportService, clusterAlias);
     }
 
     Collection<RemoteClusterConnection> getConnections() {
diff --git a/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java b/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java
index 4da23175c4a0e..88d37e101f846 100644
--- a/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java
+++ b/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java
@@ -164,6 +164,7 @@ public void closeNoBlock() {
     }
 
     private synchronized void addConnectedNode(DiscoveryNode addedNode) {
+        System.out.println("RemoteConnectionManager.addConnectedNode");
         ArrayList<DiscoveryNode> newConnections = new ArrayList<>(this.connectedNodes);
         newConnections.add(addedNode);
         this.connectedNodes = Collections.unmodifiableList(newConnections);
@@ -230,5 +231,12 @@ public Version getVersion() {
         public Object getCacheKey() {
             return connection.getCacheKey();
         }
+
+        // @Override
+        // public void sendRequestProtobuf(long requestId, String action, TransportRequest request,
+        //         TransportRequestOptions options) throws IOException, TransportException {
+        //     // TODO Auto-generated method stub
+        //     throw new UnsupportedOperationException("Unimplemented method 'sendRequestProtobuf'");
+        // }
     }
 }
diff --git a/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java
index 5e00704b3baaf..c01cd7d212dc9 100644
--- a/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java
+++ b/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java
@@ -57,6 +57,8 @@
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.threadpool.ThreadPool;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.util.Arrays;
@@ -471,6 +473,18 @@ public void handleException(TransportException exp) {
         public String executor() {
             return ThreadPool.Names.MANAGEMENT;
         }
+
+        @Override
+        public ClusterStateResponse read(CodedInputStream in) throws IOException {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'read'");
+        }
+
+        @Override
+        public void handleExceptionProtobuf(ProtobufTransportException exp) {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+        }
     }
 
     private Predicate<ClusterName> getRemoteClusterNamePredicate() {
diff --git a/server/src/main/java/org/opensearch/transport/TcpTransport.java b/server/src/main/java/org/opensearch/transport/TcpTransport.java
index 07fd66367b8c5..9d853b179910f 100644
--- a/server/src/main/java/org/opensearch/transport/TcpTransport.java
+++ b/server/src/main/java/org/opensearch/transport/TcpTransport.java
@@ -57,8 +57,8 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.transport.BoundTransportAddress;
 import org.opensearch.common.transport.PortsRange;
-import org.opensearch.common.transport.ProtobufBoundTransportAddress;
-import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.common.unit.TimeValue;
@@ -138,7 +138,7 @@ public abstract class TcpTransport extends AbstractLifecycleComponent implements
     private final CircuitBreakerService circuitBreakerService;
 
     private final ConcurrentMap<String, BoundTransportAddress> profileBoundAddresses = newConcurrentMap();
-    private final ConcurrentMap<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses = newConcurrentMap();
+    private final ConcurrentMap<String, BoundTransportAddress> profileProtobufBoundAddresses = newConcurrentMap();
     private final Map<String, List<TcpServerChannel>> serverChannels = newConcurrentMap();
     private final Set<TcpChannel> acceptedChannels = ConcurrentCollections.newConcurrentSet();
 
@@ -146,7 +146,7 @@ public abstract class TcpTransport extends AbstractLifecycleComponent implements
     // connections while no connect operations is going on
     private final ReadWriteLock closeLock = new ReentrantReadWriteLock();
     private volatile BoundTransportAddress boundAddress;
-    private volatile ProtobufBoundTransportAddress protobufBoundAddress;
+    private volatile BoundTransportAddress protobufBoundAddress;
 
     private final TransportHandshaker handshaker;
     private final TransportKeepAlive keepAlive;
@@ -154,7 +154,7 @@ public abstract class TcpTransport extends AbstractLifecycleComponent implements
     private final InboundHandler inboundHandler;
     private final ResponseHandlers responseHandlers = new ResponseHandlers();
     private final RequestHandlers requestHandlers = new RequestHandlers();
-    private final ProtobufResponseHandlers protobufResponseHandlers = new ProtobufResponseHandlers();
+    // private final ProtobufResponseHandlers protobufResponseHandlers = new ProtobufResponseHandlers();
     private final ProtobufRequestHandlers protobufRequestHandlers = new ProtobufRequestHandlers();
 
     private final AtomicLong outboundConnectionCount = new AtomicLong(); // also used as a correlation ID for open/close logs
@@ -323,6 +323,13 @@ public void sendRequest(long requestId, String action, TransportRequest request,
             TcpChannel channel = channel(options.type());
             outboundHandler.sendRequest(node, channel, requestId, action, request, options, getVersion(), compress, false);
         }
+
+        // @Override
+        // public void sendRequestProtobuf(long requestId, String action, TransportRequest request,
+        //         TransportRequestOptions options) throws IOException, TransportException {
+        //     // TODO Auto-generated method stub
+        //     throw new UnsupportedOperationException("Unimplemented method 'sendRequestProtobuf'");
+        // }
     }
 
     // This allows transport implementations to potentially override specific connection profiles. This
@@ -400,15 +407,15 @@ public Map<String, BoundTransportAddress> profileBoundAddresses() {
         return unmodifiableMap(new HashMap<>(profileBoundAddresses));
     }
 
-    @Override
-    public ProtobufBoundTransportAddress boundProtobufAddress() {
-        return this.protobufBoundAddress;
-    }
+    // @Override
+    // public BoundTransportAddress boundProtobufAddress() {
+    //     return this.protobufBoundAddress;
+    // }
 
-    @Override
-    public Map<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses() {
-        return unmodifiableMap(new HashMap<>(profileProtobufBoundAddresses));
-    }
+    // @Override
+    // public Map<String, BoundTransportAddress> profileProtobufBoundAddresses() {
+    //     return unmodifiableMap(new HashMap<>(profileProtobufBoundAddresses));
+    // }
 
     @Override
     public List<String> getDefaultSeedAddresses() {
@@ -448,14 +455,14 @@ protected void bindServer(ProfileSettings profileSettings) {
         }
 
         final BoundTransportAddress boundTransportAddress = createBoundTransportAddress(profileSettings, boundAddresses);
-        final ProtobufBoundTransportAddress protobufBoundTransportAddress = createProtobufBoundTransportAddress(boundTransportAddress);
+        // final BoundTransportAddress protobufBoundTransportAddress = createProtobufBoundTransportAddress(boundTransportAddress);
 
         if (profileSettings.isDefaultProfile) {
             this.boundAddress = boundTransportAddress;
-            this.protobufBoundAddress = protobufBoundTransportAddress;
+            // this.protobufBoundAddress = protobufBoundTransportAddress;
         } else {
             profileBoundAddresses.put(profileSettings.profileName, boundTransportAddress);
-            profileProtobufBoundAddresses.put(profileSettings.profileName, protobufBoundTransportAddress);
+            // profileProtobufBoundAddresses.put(profileSettings.profileName, protobufBoundTransportAddress);
         }
     }
 
@@ -525,42 +532,42 @@ private BoundTransportAddress createBoundTransportAddress(ProfileSettings profil
         return new BoundTransportAddress(transportBoundAddresses, publishAddress);
     }
 
-    private ProtobufBoundTransportAddress createProtobufBoundTransportAddress(BoundTransportAddress boundTransportAddress) {
-        TransportAddress[] transportBoundAddresses = boundTransportAddress.boundAddresses();
-        TransportAddress publishAddress = boundTransportAddress.publishAddress();
-        ProtobufTransportAddress[] transportBoundAddressesProtobuf = new ProtobufTransportAddress[transportBoundAddresses.length];
-        for (int i = 0; i < transportBoundAddresses.length; i++) {
-            transportBoundAddressesProtobuf[i] = new ProtobufTransportAddress(transportBoundAddresses[i].address());
-        }
-        return new ProtobufBoundTransportAddress(transportBoundAddressesProtobuf, new ProtobufTransportAddress(publishAddress.address()));
-        // String[] boundAddressesHostStrings = new String[boundAddresses.size()];
-        // ProtobufTransportAddress[] transportBoundAddresses = new ProtobufTransportAddress[boundAddresses.size()];
-        // for (int i = 0; i < boundAddresses.size(); i++) {
-        // InetSocketAddress boundAddress = boundAddresses.get(i);
-        // boundAddressesHostStrings[i] = boundAddress.getHostString();
-        // transportBoundAddresses[i] = new ProtobufTransportAddress(boundAddress);
-        // }
-
-        // List<String> publishHosts = profileSettings.publishHosts;
-        // if (profileSettings.isDefaultProfile == false && publishHosts.isEmpty()) {
-        // publishHosts = Arrays.asList(boundAddressesHostStrings);
-        // }
-        // if (publishHosts.isEmpty()) {
-        // publishHosts = NetworkService.GLOBAL_NETWORK_PUBLISH_HOST_SETTING.get(settings);
-        // }
-
-        // final InetAddress publishInetAddress;
-        // try {
-        // publishInetAddress = networkService.resolvePublishHostAddresses(publishHosts.toArray(Strings.EMPTY_ARRAY));
-        // } catch (Exception e) {
-        // throw new BindTransportException("Failed to resolve publish address", e);
-        // }
-
-        // final int publishPort = resolvePublishPort(profileSettings, boundAddresses, publishInetAddress);
-        // final ProtobufTransportAddress publishAddress = new ProtobufTransportAddress(new InetSocketAddress(publishInetAddress,
-        // publishPort));
-        // return new ProtobufBoundTransportAddress(transportBoundAddresses, publishAddress);
-    }
+    // private BoundTransportAddress createProtobufBoundTransportAddress(BoundTransportAddress boundTransportAddress) {
+    //     TransportAddress[] transportBoundAddresses = boundTransportAddress.boundAddresses();
+    //     TransportAddress publishAddress = boundTransportAddress.publishAddress();
+    //     TransportAddress[] transportBoundAddressesProtobuf = new TransportAddress[transportBoundAddresses.length];
+    //     for (int i = 0; i < transportBoundAddresses.length; i++) {
+    //         transportBoundAddressesProtobuf[i] = new TransportAddress(transportBoundAddresses[i].address());
+    //     }
+    //     return new BoundTransportAddress(transportBoundAddressesProtobuf, new TransportAddress(publishAddress.address()));
+    //     // String[] boundAddressesHostStrings = new String[boundAddresses.size()];
+    //     // TransportAddress[] transportBoundAddresses = new TransportAddress[boundAddresses.size()];
+    //     // for (int i = 0; i < boundAddresses.size(); i++) {
+    //     // InetSocketAddress boundAddress = boundAddresses.get(i);
+    //     // boundAddressesHostStrings[i] = boundAddress.getHostString();
+    //     // transportBoundAddresses[i] = new TransportAddress(boundAddress);
+    //     // }
+
+    //     // List<String> publishHosts = profileSettings.publishHosts;
+    //     // if (profileSettings.isDefaultProfile == false && publishHosts.isEmpty()) {
+    //     // publishHosts = Arrays.asList(boundAddressesHostStrings);
+    //     // }
+    //     // if (publishHosts.isEmpty()) {
+    //     // publishHosts = NetworkService.GLOBAL_NETWORK_PUBLISH_HOST_SETTING.get(settings);
+    //     // }
+
+    //     // final InetAddress publishInetAddress;
+    //     // try {
+    //     // publishInetAddress = networkService.resolvePublishHostAddresses(publishHosts.toArray(Strings.EMPTY_ARRAY));
+    //     // } catch (Exception e) {
+    //     // throw new BindTransportException("Failed to resolve publish address", e);
+    //     // }
+
+    //     // final int publishPort = resolvePublishPort(profileSettings, boundAddresses, publishInetAddress);
+    //     // final TransportAddress publishAddress = new TransportAddress(new InetSocketAddress(publishInetAddress,
+    //     // publishPort));
+    //     // return new BoundTransportAddress(transportBoundAddresses, publishAddress);
+    // }
 
     // package private for tests
     static int resolvePublishPort(ProfileSettings profileSettings, List<InetSocketAddress> boundAddresses, InetAddress publishInetAddress) {
@@ -1072,23 +1079,23 @@ public final RequestHandlers getRequestHandlers() {
         return requestHandlers;
     }
 
-    @Override
-    public void setMessageListener(ProtobufTransportMessageListener listener) {
-        outboundHandler.setProtobufMessageListener(listener);
-        inboundHandler.setProtobufMessageListener(listener);
-    }
+    // @Override
+    // public void setMessageListenerProtobuf(ProtobufTransportMessageListener listener) {
+    //     outboundHandler.setProtobufMessageListener(listener);
+    //     inboundHandler.setProtobufMessageListener(listener);
+    // }
 
-    @Override
-    public ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'addressesFromStringProtobuf'");
-    }
+    // @Override
+    // public TransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException {
+    //     // TODO Auto-generated method stub
+    //     throw new UnsupportedOperationException("Unimplemented method 'addressesFromStringProtobuf'");
+    // }
 
-    @Override
-    public void openProtobufConnection(DiscoveryNode node, ProtobufConnectionProfile profile, ActionListener<ProtobufConnection> listener) {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'openProtobufConnection'");
-    }
+    // @Override
+    // public void openProtobufConnection(DiscoveryNode node, ProtobufConnectionProfile profile, ActionListener<Connection> listener) {
+    //     // TODO Auto-generated method stub
+    //     throw new UnsupportedOperationException("Unimplemented method 'openProtobufConnection'");
+    // }
 
     @Override
     public ProtobufTransportStats getProtobufStats() {
@@ -1096,10 +1103,10 @@ public ProtobufTransportStats getProtobufStats() {
         throw new UnsupportedOperationException("Unimplemented method 'getProtobufStats'");
     }
 
-    @Override
-    public ProtobufResponseHandlers getProtobufResponseHandlers() {
-        return protobufResponseHandlers;
-    }
+    // @Override
+    // public ProtobufResponseHandlers getProtobufResponseHandlers() {
+    //     return protobufResponseHandlers;
+    // }
 
     @Override
     public ProtobufRequestHandlers getProtobufRequestHandlers() {
diff --git a/server/src/main/java/org/opensearch/transport/Transport.java b/server/src/main/java/org/opensearch/transport/Transport.java
index 09c8cc1334147..eb8d8a7b4e40c 100644
--- a/server/src/main/java/org/opensearch/transport/Transport.java
+++ b/server/src/main/java/org/opensearch/transport/Transport.java
@@ -39,8 +39,8 @@
 import org.opensearch.common.collect.MapBuilder;
 import org.opensearch.common.lifecycle.LifecycleComponent;
 import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.ProtobufBoundTransportAddress;
-import org.opensearch.common.transport.ProtobufTransportAddress;
+// import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+// import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.ConcurrentCollections;
@@ -75,11 +75,11 @@ default <Request extends TransportRequest> void registerRequestHandler(RequestHa
     /**
      * Registers a new request handler
     */
-    default <Request extends ProtobufTransportRequest> void registerProtobufRequestHandler(ProtobufRequestHandlerRegistry<Request> reg) {
+    default <Request extends TransportRequest> void registerProtobufRequestHandler(ProtobufRequestHandlerRegistry<Request> reg) {
         getProtobufRequestHandlers().registerHandler(reg);
     }
 
-    void setMessageListener(ProtobufTransportMessageListener listener);
+    // void setMessageListenerProtobuf(ProtobufTransportMessageListener listener);
 
     default void setSlowLogThreshold(TimeValue slowLogThreshold) {}
 
@@ -103,21 +103,21 @@ default boolean isSecure() {
      */
     TransportAddress[] addressesFromString(String address) throws UnknownHostException;
 
-    /**
-     * The address the transport is bound on.
-    */
-    ProtobufBoundTransportAddress boundProtobufAddress();
+    // /**
+    //  * The address the transport is bound on.
+    // */
+    // ProtobufBoundTransportAddress boundProtobufAddress();
 
-    /**
-     * Further profile bound addresses
-    * @return <code>null</code> iff profiles are unsupported, otherwise a map with name of profile and its bound transport address
-    */
-    Map<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses();
+    // /**
+    //  * Further profile bound addresses
+    // * @return <code>null</code> iff profiles are unsupported, otherwise a map with name of profile and its bound transport address
+    // */
+    // Map<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses();
 
-    /**
-     * Returns an address from its string representation.
-    */
-    ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException;
+    // /**
+    //  * Returns an address from its string representation.
+    // */
+    // ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException;
 
     /**
      * Returns a list of all local addresses for this transport
@@ -130,15 +130,15 @@ default boolean isSecure() {
      */
     void openConnection(DiscoveryNode node, ConnectionProfile profile, ActionListener<Transport.Connection> listener);
 
-    /**
-     * Opens a new connection to the given node. When the connection is fully connected, the listener is called.
-     * The ActionListener will be called on the calling thread or the generic thread pool.
-     */
-    void openProtobufConnection(
-        DiscoveryNode node,
-        ProtobufConnectionProfile profile,
-        ActionListener<Transport.ProtobufConnection> listener
-    );
+    // /**
+    //  * Opens a new connection to the given node. When the connection is fully connected, the listener is called.
+    //  * The ActionListener will be called on the calling thread or the generic thread pool.
+    //  */
+    // void openProtobufConnection(
+    //     DiscoveryNode node,
+    //     ProtobufConnectionProfile profile,
+    //     ActionListener<Transport.Connection> listener
+    // );
 
     TransportStats getStats();
 
@@ -148,7 +148,7 @@ void openProtobufConnection(
 
     ProtobufTransportStats getProtobufStats();
 
-    ProtobufResponseHandlers getProtobufResponseHandlers();
+    // ProtobufResponseHandlers getProtobufResponseHandlers();
 
     ProtobufRequestHandlers getProtobufRequestHandlers();
 
@@ -171,6 +171,17 @@ interface Connection extends Closeable {
          */
         void sendRequest(long requestId, String action, TransportRequest request, TransportRequestOptions options) throws IOException,
             TransportException;
+        
+        // /**
+        //  * Sends the request to the node this connection is associated with
+        // * @param requestId see {@link ResponseHandlers#add(ResponseContext)} for details
+        // * @param action the action to execute
+        // * @param request the request to send
+        // * @param options request options to apply
+        // * @throws NodeNotConnectedException if the given node is not connected
+        // */
+        // void sendRequestProtobuf(long requestId, String action, TransportRequest request, TransportRequestOptions options)
+        //     throws IOException, TransportException;
 
         /**
          * The listener's {@link ActionListener#onResponse(Object)} method will be called when this
@@ -202,55 +213,55 @@ default Object getCacheKey() {
         void close();
     }
 
-    /**
-     * A unidirectional connection to a {@link DiscoveryNode}
-    */
-    interface ProtobufConnection extends Closeable {
-        /**
-         * The node this connection is associated with
-        */
-        DiscoveryNode getNode();
-
-        /**
-         * Sends the request to the node this connection is associated with
-        * @param requestId see {@link ResponseHandlers#add(ResponseContext)} for details
-        * @param action the action to execute
-        * @param request the request to send
-        * @param options request options to apply
-        * @throws NodeNotConnectedException if the given node is not connected
-        */
-        void sendRequest(long requestId, String action, ProtobufTransportRequest request, TransportRequestOptions options)
-            throws IOException, TransportException;
-
-        /**
-         * The listener's {@link ActionListener#onResponse(Object)} method will be called when this
-        * connection is closed. No implementations currently throw an exception during close, so
-        * {@link ActionListener#onFailure(Exception)} will not be called.
-        *
-        * @param listener to be called
-        */
-        void addCloseListener(ActionListener<Void> listener);
-
-        boolean isClosed();
-
-        /**
-         * Returns the version of the node this connection was established with.
-        */
-        default Version getVersion() {
-            return getNode().getVersion();
-        }
-
-        /**
-         * Returns a key that this connection can be cached on. Delegating subclasses must delegate method call to
-        * the original connection.
-        */
-        default Object getCacheKey() {
-            return this;
-        }
-
-        @Override
-        void close();
-    }
+    // /**
+    //  * A unidirectional connection to a {@link DiscoveryNode}
+    // */
+    // interface ProtobufConnection extends Closeable {
+    //     /**
+    //      * The node this connection is associated with
+    //     */
+    //     DiscoveryNode getNode();
+
+    //     /**
+    //      * Sends the request to the node this connection is associated with
+    //     * @param requestId see {@link ResponseHandlers#add(ResponseContext)} for details
+    //     * @param action the action to execute
+    //     * @param request the request to send
+    //     * @param options request options to apply
+    //     * @throws NodeNotConnectedException if the given node is not connected
+    //     */
+    //     void sendRequest(long requestId, String action, TransportRequest request, TransportRequestOptions options)
+    //         throws IOException, TransportException;
+
+    //     /**
+    //      * The listener's {@link ActionListener#onResponse(Object)} method will be called when this
+    //     * connection is closed. No implementations currently throw an exception during close, so
+    //     * {@link ActionListener#onFailure(Exception)} will not be called.
+    //     *
+    //     * @param listener to be called
+    //     */
+    //     void addCloseListener(ActionListener<Void> listener);
+
+    //     boolean isClosed();
+
+    //     /**
+    //      * Returns the version of the node this connection was established with.
+    //     */
+    //     default Version getVersion() {
+    //         return getNode().getVersion();
+    //     }
+
+    //     /**
+    //      * Returns a key that this connection can be cached on. Delegating subclasses must delegate method call to
+    //     * the original connection.
+    //     */
+    //     default Object getCacheKey() {
+    //         return this;
+    //     }
+
+    //     @Override
+    //     void close();
+    // }
 
     /**
      * This class represents a response context that encapsulates the actual response handler, the action and the connection it was
@@ -283,36 +294,36 @@ public String action() {
         }
     }
 
-    /**
-     * This class represents a response context that encapsulates the actual response handler, the action and the connection it was
-    * executed on.
-    */
-    final class ProtobufResponseContext<T extends ProtobufTransportResponse> {
+    // /**
+    //  * This class represents a response context that encapsulates the actual response handler, the action and the connection it was
+    // * executed on.
+    // */
+    // final class ProtobufResponseContext<T extends TransportResponse> {
 
-        private final ProtobufTransportResponseHandler<T> handler;
+    //     private final ProtobufTransportResponseHandler<T> handler;
 
-        private final ProtobufConnection connection;
+    //     private final Connection connection;
 
-        private final String action;
+    //     private final String action;
 
-        ProtobufResponseContext(ProtobufTransportResponseHandler<T> handler, ProtobufConnection connection, String action) {
-            this.handler = handler;
-            this.connection = connection;
-            this.action = action;
-        }
+    //     ProtobufResponseContext(ProtobufTransportResponseHandler<T> handler, Connection connection, String action) {
+    //         this.handler = handler;
+    //         this.connection = connection;
+    //         this.action = action;
+    //     }
 
-        public ProtobufTransportResponseHandler<T> handler() {
-            return handler;
-        }
+    //     public ProtobufTransportResponseHandler<T> handler() {
+    //         return handler;
+    //     }
 
-        public ProtobufConnection connection() {
-            return this.connection;
-        }
+    //     public Connection connection() {
+    //         return this.connection;
+    //     }
 
-        public String action() {
-            return this.action;
-        }
-    }
+    //     public String action() {
+    //         return this.action;
+    //     }
+    // }
 
     /**
      * This class is a registry that allows
@@ -393,86 +404,86 @@ public TransportResponseHandler<? extends TransportResponse> onResponseReceived(
         }
     }
 
-    /**
-     * This class is a registry that allows
-    */
-    final class ProtobufResponseHandlers {
-        private final ConcurrentMapLong<ProtobufResponseContext<? extends ProtobufTransportResponse>> handlers = ConcurrentCollections
-            .newConcurrentMapLongWithAggressiveConcurrency();
-        private final AtomicLong requestIdGenerator = new AtomicLong();
-
-        /**
-         * Returns <code>true</code> if the give request ID has a context associated with it.
-        */
-        public boolean contains(long requestId) {
-            return handlers.containsKey(requestId);
-        }
-
-        /**
-         * Removes and return the {@link ResponseContext} for the given request ID or returns
-        * <code>null</code> if no context is associated with this request ID.
-        */
-        public ProtobufResponseContext<? extends ProtobufTransportResponse> remove(long requestId) {
-            return handlers.remove(requestId);
-        }
-
-        /**
-         * Adds a new response context and associates it with a new request ID.
-        * @return the new request ID
-        * @see ProtobufConnection#sendRequest(long, String, ProtobufTransportRequest, TransportRequestOptions)
-        */
-        public long add(ProtobufResponseContext<? extends ProtobufTransportResponse> holder) {
-            long requestId = newRequestId();
-            ProtobufResponseContext<? extends ProtobufTransportResponse> existing = handlers.put(requestId, holder);
-            assert existing == null : "request ID already in use: " + requestId;
-            return requestId;
-        }
-
-        /**
-         * Returns a new request ID to use when sending a message via {@link ProtobufConnection#sendRequest(long, String,
-        * ProtobufTransportRequest, TransportRequestOptions)}
-        */
-        long newRequestId() {
-            return requestIdGenerator.incrementAndGet();
-        }
-
-        /**
-         * Removes and returns all {@link ResponseContext} instances that match the predicate
-        */
-        public List<ProtobufResponseContext<? extends ProtobufTransportResponse>> prune(
-            Predicate<ProtobufResponseContext<? extends ProtobufTransportResponse>> predicate
-        ) {
-            final List<ProtobufResponseContext<? extends ProtobufTransportResponse>> holders = new ArrayList<>();
-            for (Map.Entry<Long, ProtobufResponseContext<? extends ProtobufTransportResponse>> entry : handlers.entrySet()) {
-                ProtobufResponseContext<? extends ProtobufTransportResponse> holder = entry.getValue();
-                if (predicate.test(holder)) {
-                    ProtobufResponseContext<? extends ProtobufTransportResponse> remove = handlers.remove(entry.getKey());
-                    if (remove != null) {
-                        holders.add(holder);
-                    }
-                }
-            }
-            return holders;
-        }
-
-        /**
-         * called by the {@link Transport} implementation when a response or an exception has been received for a previously
-        * sent request (before any processing or deserialization was done). Returns the appropriate response handler or null if not
-        * found.
-        */
-        public ProtobufTransportResponseHandler<? extends ProtobufTransportResponse> onResponseReceived(
-            final long requestId,
-            final ProtobufTransportMessageListener listener
-        ) {
-            ProtobufResponseContext<? extends ProtobufTransportResponse> context = handlers.remove(requestId);
-            listener.onResponseReceived(requestId, context);
-            if (context == null) {
-                return null;
-            } else {
-                return context.handler();
-            }
-        }
-    }
+    // /**
+    //  * This class is a registry that allows
+    // */
+    // final class ProtobufResponseHandlers {
+    //     private final ConcurrentMapLong<ProtobufResponseContext<? extends TransportResponse>> handlers = ConcurrentCollections
+    //         .newConcurrentMapLongWithAggressiveConcurrency();
+    //     private final AtomicLong requestIdGenerator = new AtomicLong();
+
+    //     /**
+    //      * Returns <code>true</code> if the give request ID has a context associated with it.
+    //     */
+    //     public boolean contains(long requestId) {
+    //         return handlers.containsKey(requestId);
+    //     }
+
+    //     /**
+    //      * Removes and return the {@link ResponseContext} for the given request ID or returns
+    //     * <code>null</code> if no context is associated with this request ID.
+    //     */
+    //     public ProtobufResponseContext<? extends TransportResponse> remove(long requestId) {
+    //         return handlers.remove(requestId);
+    //     }
+
+    //     /**
+    //      * Adds a new response context and associates it with a new request ID.
+    //     * @return the new request ID
+    //     * @see Connection#sendRequestProtobuf(long, String, TransportRequest, TransportRequestOptions)
+    //     */
+    //     public long add(ProtobufResponseContext<? extends TransportResponse> holder) {
+    //         long requestId = newRequestId();
+    //         ProtobufResponseContext<? extends TransportResponse> existing = handlers.put(requestId, holder);
+    //         assert existing == null : "request ID already in use: " + requestId;
+    //         return requestId;
+    //     }
+
+    //     /**
+    //      * Returns a new request ID to use when sending a message via {@link Connection#sendRequestProtobuf(long, String,
+    //     * TransportRequest, TransportRequestOptions)}
+    //     */
+    //     long newRequestId() {
+    //         return requestIdGenerator.incrementAndGet();
+    //     }
+
+    //     /**
+    //      * Removes and returns all {@link ResponseContext} instances that match the predicate
+    //     */
+    //     public List<ProtobufResponseContext<? extends TransportResponse>> prune(
+    //         Predicate<ProtobufResponseContext<? extends TransportResponse>> predicate
+    //     ) {
+    //         final List<ProtobufResponseContext<? extends TransportResponse>> holders = new ArrayList<>();
+    //         for (Map.Entry<Long, ProtobufResponseContext<? extends TransportResponse>> entry : handlers.entrySet()) {
+    //             ProtobufResponseContext<? extends TransportResponse> holder = entry.getValue();
+    //             if (predicate.test(holder)) {
+    //                 ProtobufResponseContext<? extends TransportResponse> remove = handlers.remove(entry.getKey());
+    //                 if (remove != null) {
+    //                     holders.add(holder);
+    //                 }
+    //             }
+    //         }
+    //         return holders;
+    //     }
+
+    //     /**
+    //      * called by the {@link Transport} implementation when a response or an exception has been received for a previously
+    //     * sent request (before any processing or deserialization was done). Returns the appropriate response handler or null if not
+    //     * found.
+    //     */
+    //     public ProtobufTransportResponseHandler<? extends TransportResponse> onResponseReceived(
+    //         final long requestId,
+    //         final ProtobufTransportMessageListener listener
+    //     ) {
+    //         ProtobufResponseContext<? extends TransportResponse> context = handlers.remove(requestId);
+    //         listener.onResponseReceived(requestId, context);
+    //         if (context == null) {
+    //             return null;
+    //         } else {
+    //             return context.handler();
+    //         }
+    //     }
+    // }
 
     /**
      * Request handler implementations
@@ -483,7 +494,7 @@ final class RequestHandlers {
 
         private volatile Map<String, RequestHandlerRegistry<? extends TransportRequest>> requestHandlers = Collections.emptyMap();
 
-        private volatile Map<String, ProtobufRequestHandlerRegistry<? extends ProtobufTransportRequest>> protobufRequestHandlers =
+        private volatile Map<String, ProtobufRequestHandlerRegistry<? extends TransportRequest>> protobufRequestHandlers =
             Collections.emptyMap();
 
         synchronized <Request extends TransportRequest> void registerHandler(RequestHandlerRegistry<Request> reg) {
@@ -512,10 +523,10 @@ public <T extends TransportRequest> RequestHandlerRegistry<T> getHandler(String
     */
     final class ProtobufRequestHandlers {
 
-        private volatile Map<String, ProtobufRequestHandlerRegistry<? extends ProtobufTransportRequest>> requestHandlers = Collections
+        private volatile Map<String, ProtobufRequestHandlerRegistry<? extends TransportRequest>> requestHandlers = Collections
             .emptyMap();
 
-        synchronized <Request extends ProtobufTransportRequest> void registerHandler(ProtobufRequestHandlerRegistry<Request> reg) {
+        synchronized <Request extends TransportRequest> void registerHandler(ProtobufRequestHandlerRegistry<Request> reg) {
             if (requestHandlers.containsKey(reg.getAction())) {
                 throw new IllegalArgumentException("transport handlers for action " + reg.getAction() + " is already registered");
             }
@@ -524,12 +535,12 @@ synchronized <Request extends ProtobufTransportRequest> void registerHandler(Pro
 
         // TODO: Only visible for testing. Perhaps move StubbableTransport from
         // org.opensearch.test.transport to org.opensearch.transport
-        public synchronized <Request extends ProtobufTransportRequest> void forceRegister(ProtobufRequestHandlerRegistry<Request> reg) {
+        public synchronized <Request extends TransportRequest> void forceRegister(ProtobufRequestHandlerRegistry<Request> reg) {
             requestHandlers = MapBuilder.newMapBuilder(requestHandlers).put(reg.getAction(), reg).immutableMap();
         }
 
         @SuppressWarnings("unchecked")
-        public <T extends ProtobufTransportRequest> ProtobufRequestHandlerRegistry<T> getHandler(String action) {
+        public <T extends TransportRequest> ProtobufRequestHandlerRegistry<T> getHandler(String action) {
             return (ProtobufRequestHandlerRegistry<T>) requestHandlers.get(action);
         }
     }
diff --git a/server/src/main/java/org/opensearch/transport/TransportActionProxy.java b/server/src/main/java/org/opensearch/transport/TransportActionProxy.java
index 8ad6010800ad8..8ddbd870e4cab 100644
--- a/server/src/main/java/org/opensearch/transport/TransportActionProxy.java
+++ b/server/src/main/java/org/opensearch/transport/TransportActionProxy.java
@@ -38,6 +38,8 @@
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.util.function.Function;
@@ -129,6 +131,18 @@ public void handleException(TransportException exp) {
         public String executor() {
             return ThreadPool.Names.SAME;
         }
+
+        @Override
+        public T read(CodedInputStream in) throws IOException {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'read'");
+        }
+
+        @Override
+        public void handleExceptionProtobuf(ProtobufTransportException exp) {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+        }
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/transport/TransportHandshaker.java b/server/src/main/java/org/opensearch/transport/TransportHandshaker.java
index 7b64b328469ad..0e6d038be88f9 100644
--- a/server/src/main/java/org/opensearch/transport/TransportHandshaker.java
+++ b/server/src/main/java/org/opensearch/transport/TransportHandshaker.java
@@ -42,6 +42,8 @@
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.threadpool.ThreadPool;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.EOFException;
 import java.io.IOException;
 import java.util.concurrent.ConcurrentHashMap;
@@ -186,6 +188,18 @@ void handleLocalException(TransportException e) {
         public String executor() {
             return ThreadPool.Names.SAME;
         }
+
+        @Override
+        public HandshakeResponse read(CodedInputStream in) throws IOException {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'read'");
+        }
+
+        @Override
+        public void handleExceptionProtobuf(ProtobufTransportException exp) {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+        }
     }
 
     static final class HandshakeRequest extends TransportRequest {
diff --git a/server/src/main/java/org/opensearch/transport/TransportInterceptor.java b/server/src/main/java/org/opensearch/transport/TransportInterceptor.java
index f4b003cae4864..6ea5ed3f4f492 100644
--- a/server/src/main/java/org/opensearch/transport/TransportInterceptor.java
+++ b/server/src/main/java/org/opensearch/transport/TransportInterceptor.java
@@ -56,6 +56,21 @@ default <T extends TransportRequest> TransportRequestHandler<T> interceptHandler
         return actualHandler;
     }
 
+    /**
+     * This is called for each handler that is registered via
+    * {@link TransportService#registerRequestHandler(String, String, boolean, boolean, Reader, TransportRequestHandler)} or
+    * {@link TransportService#registerRequestHandler(String, String, Reader, TransportRequestHandler)}. The returned handler is
+    * used instead of the passed in handler. By default the provided handler is returned.
+    */
+    default <T extends TransportRequest> ProtobufTransportRequestHandler<T> interceptHandlerProtobuf(
+        String action,
+        String executor,
+        boolean forceExecution,
+        ProtobufTransportRequestHandler<T> actualHandler
+    ) {
+        return actualHandler;
+    }
+
     /**
      * This is called up-front providing the actual low level {@link AsyncSender} that performs the low level send request.
      * The returned sender is used to send all requests that come in via
@@ -80,4 +95,29 @@ <T extends TransportResponse> void sendRequest(
             TransportResponseHandler<T> handler
         );
     }
+
+    // /**
+    //  * This is called up-front providing the actual low level {@link AsyncSender} that performs the low level send request.
+    // * The returned sender is used to send all requests that come in via
+    // * {@link TransportService#sendRequestProtobuf(DiscoveryNode, String, TransportRequest, TransportResponseHandler)} or
+    // * {@link TransportService#sendRequestProtobuf(DiscoveryNode, String, TransportRequest, TransportRequestOptions, TransportResponseHandler)}.
+    // * This allows plugins to perform actions on each send request including modifying the request context etc.
+    // */
+    // default AsyncSenderProtobuf interceptSenderProotbuf(AsyncSenderProtobuf sender) {
+    //     return sender;
+    // }
+
+    // /**
+    //  * A simple interface to decorate
+    // * {@link #sendRequest(Transport.Connection, String, TransportRequest, TransportRequestOptions, TransportResponseHandler)}
+    // */
+    // interface AsyncSenderProtobuf {
+    //     <T extends TransportResponse> void sendRequest(
+    //         Transport.Connection connection,
+    //         String action,
+    //         TransportRequest request,
+    //         TransportRequestOptions options,
+    //         TransportResponseHandler<T> handler
+    //     );
+    // }
 }
diff --git a/server/src/main/java/org/opensearch/transport/TransportMessage.java b/server/src/main/java/org/opensearch/transport/TransportMessage.java
index 78216047d530e..e368fd99b1056 100644
--- a/server/src/main/java/org/opensearch/transport/TransportMessage.java
+++ b/server/src/main/java/org/opensearch/transport/TransportMessage.java
@@ -32,16 +32,19 @@
 
 package org.opensearch.transport;
 
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.common.transport.TransportAddress;
 
+import com.google.protobuf.CodedInputStream;
+
 /**
  * Message over the transport interface
  *
  * @opensearch.internal
  */
-public abstract class TransportMessage implements Writeable {
+public abstract class TransportMessage implements Writeable, ProtobufWriteable {
 
     private TransportAddress remoteAddress;
 
@@ -63,4 +66,10 @@ public TransportMessage() {}
      * currently a no-op
      */
     public TransportMessage(StreamInput in) {}
+
+     /**
+     * Constructs a new transport message with the data from the {@link CodedInputStream}. This is
+    * currently a no-op
+    */
+    public TransportMessage(CodedInputStream in) {}
 }
diff --git a/server/src/main/java/org/opensearch/transport/TransportRequest.java b/server/src/main/java/org/opensearch/transport/TransportRequest.java
index 95b038303f530..2214b32da8b29 100644
--- a/server/src/main/java/org/opensearch/transport/TransportRequest.java
+++ b/server/src/main/java/org/opensearch/transport/TransportRequest.java
@@ -34,9 +34,14 @@
 
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.tasks.ProtobufTaskAwareRequest;
+import org.opensearch.tasks.ProtobufTaskId;
 import org.opensearch.tasks.TaskAwareRequest;
 import org.opensearch.tasks.TaskId;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 
 /**
@@ -44,7 +49,7 @@
  *
  * @opensearch.internal
  */
-public abstract class TransportRequest extends TransportMessage implements TaskAwareRequest {
+public abstract class TransportRequest extends TransportMessage implements TaskAwareRequest, ProtobufTaskAwareRequest {
     /**
      * Empty transport request
      *
@@ -58,6 +63,10 @@ public Empty() {}
         public Empty(StreamInput in) throws IOException {
             super(in);
         }
+
+        public Empty(CodedInputStream in) throws IOException {
+            super(in);
+        }
     }
 
     /**
@@ -65,12 +74,21 @@ public Empty(StreamInput in) throws IOException {
      */
     private TaskId parentTaskId = TaskId.EMPTY_TASK_ID;
 
+    /**
+     * Parent of this request. Defaults to {@link TaskId#EMPTY_TASK_ID}, meaning "no parent".
+    */
+    private ProtobufTaskId protobufParentTaskId = ProtobufTaskId.EMPTY_TASK_ID;
+
     public TransportRequest() {}
 
     public TransportRequest(StreamInput in) throws IOException {
         parentTaskId = TaskId.readFromStream(in);
     }
 
+    public TransportRequest(CodedInputStream in) throws IOException {
+        protobufParentTaskId = ProtobufTaskId.readFromStream(in);
+    }
+
     /**
      * Set a reference to task that created this request.
      */
@@ -79,6 +97,14 @@ public void setParentTask(TaskId taskId) {
         this.parentTaskId = taskId;
     }
 
+    /**
+     * Set a reference to task that created this request.
+    */
+    @Override
+    public void setProtobufParentTask(ProtobufTaskId taskId) {
+        this.protobufParentTaskId = taskId;
+    }
+
     /**
      * Get a reference to the task that created this request. Defaults to {@link TaskId#EMPTY_TASK_ID}, meaning "there is no parent".
      */
@@ -87,8 +113,21 @@ public TaskId getParentTask() {
         return parentTaskId;
     }
 
+     /**
+     * Get a reference to the task that created this request. Defaults to {@link TaskId#EMPTY_TASK_ID}, meaning "there is no parent".
+    */
+    @Override
+    public ProtobufTaskId getProtobufParentTask() {
+        return protobufParentTaskId;
+    }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         parentTaskId.writeTo(out);
     }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        protobufParentTaskId.writeTo(out);
+    }
 }
diff --git a/server/src/main/java/org/opensearch/transport/TransportResponse.java b/server/src/main/java/org/opensearch/transport/TransportResponse.java
index 73713fa1447a8..e26d862700076 100644
--- a/server/src/main/java/org/opensearch/transport/TransportResponse.java
+++ b/server/src/main/java/org/opensearch/transport/TransportResponse.java
@@ -35,6 +35,9 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 
 /**
@@ -58,6 +61,21 @@ public TransportResponse(StreamInput in) throws IOException {
         super(in);
     }
 
+    /**
+     * Constructs a new transport response with the data from the {@link StreamInput}. This is
+    * currently a no-op. However, this exists to allow extenders to call <code>super(in)</code>
+    * so that reading can mirror writing where we often call <code>super.writeTo(out)</code>.
+    */
+    public TransportResponse(CodedInputStream in) throws IOException {
+        super(in);
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {}
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {}
+
     /**
      * Empty transport response
      *
@@ -73,5 +91,8 @@ public String toString() {
 
         @Override
         public void writeTo(StreamOutput out) throws IOException {}
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {}
     }
 }
diff --git a/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java
index 674a62fb75b7d..7e21af3d274ba 100644
--- a/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java
+++ b/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java
@@ -32,9 +32,12 @@
 
 package org.opensearch.transport;
 
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.Writeable;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.function.Function;
 
@@ -43,12 +46,14 @@
  *
  * @opensearch.internal
  */
-public interface TransportResponseHandler<T extends TransportResponse> extends Writeable.Reader<T> {
+public interface TransportResponseHandler<T extends TransportResponse> extends Writeable.Reader<T>, ProtobufWriteable.Reader<T> {
 
     void handleResponse(T response);
 
     void handleException(TransportException exp);
 
+    void handleExceptionProtobuf(ProtobufTransportException exp);
+
     String executor();
 
     default <Q extends TransportResponse> TransportResponseHandler<Q> wrap(Function<Q, T> converter, Writeable.Reader<Q> reader) {
@@ -73,6 +78,58 @@ public String executor() {
             public Q read(StreamInput in) throws IOException {
                 return reader.read(in);
             }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
+
+            @Override
+            public Q read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+        };
+    }
+
+    default <Q extends TransportResponse> TransportResponseHandler<Q> wrapProtobuf(
+        Function<Q, T> converter,
+        ProtobufWriteable.Reader<Q> reader
+    ) {
+        final TransportResponseHandler<T> self = this;
+        return new TransportResponseHandler<Q>() {
+            @Override
+            public void handleResponse(Q response) {
+                self.handleResponse(converter.apply(response));
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                self.handleExceptionProtobuf(exp);
+            }
+
+            @Override
+            public String executor() {
+                return self.executor();
+            }
+
+            @Override
+            public Q read(CodedInputStream in) throws IOException {
+                return reader.read(in);
+            }
+
+            @Override
+            public Q read(StreamInput in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleException(TransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleException'");
+            }
         };
     }
 }
diff --git a/server/src/main/java/org/opensearch/transport/TransportService.java b/server/src/main/java/org/opensearch/transport/TransportService.java
index 3b59c99c03d3b..a41057371e82b 100644
--- a/server/src/main/java/org/opensearch/transport/TransportService.java
+++ b/server/src/main/java/org/opensearch/transport/TransportService.java
@@ -39,11 +39,15 @@
 import org.opensearch.Version;
 import org.opensearch.action.ActionListener;
 import org.opensearch.action.ActionListenerResponseHandler;
+import org.opensearch.action.ProtobufActionListenerResponseHandler;
 import org.opensearch.action.support.PlainActionFuture;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.common.io.stream.Streamables;
@@ -62,12 +66,17 @@
 import org.opensearch.core.common.Strings;
 import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
 import org.opensearch.node.NodeClosedException;
+import org.opensearch.node.ProtobufNodeClosedException;
+import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.node.ReportingService;
 import org.opensearch.tasks.Task;
 import org.opensearch.tasks.TaskManager;
 import org.opensearch.threadpool.Scheduler;
 import org.opensearch.threadpool.ThreadPool;
 
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.net.UnknownHostException;
@@ -95,6 +104,7 @@ public class TransportService extends AbstractLifecycleComponent
     implements
         ReportingService<TransportInfo>,
         TransportMessageListener,
+        ProtobufReportingService<ProtobufTransportInfo>,
         TransportConnectionListener {
     private static final Logger logger = LogManager.getLogger(TransportService.class);
 
@@ -109,9 +119,11 @@ public class TransportService extends AbstractLifecycleComponent
     protected final ClusterName clusterName;
     protected final TaskManager taskManager;
     private final TransportInterceptor.AsyncSender asyncSender;
+    // private final TransportInterceptor.AsyncSenderProtobuf asyncSenderProtobuf;
     private final Function<BoundTransportAddress, DiscoveryNode> localNodeFactory;
     private final boolean remoteClusterClient;
     private final Transport.ResponseHandlers responseHandlers;
+    // private final Transport.ProtobufResponseHandlers responseHandlersProtobuf;
     private final TransportInterceptor interceptor;
 
     // An LRU (don't really care about concurrency here) that holds the latest timed out requests so if they
@@ -161,6 +173,14 @@ public boolean isClosed() {
 
         @Override
         public void close() {}
+
+        // @Override
+        // public void sendRequestProtobuf(long requestId, String action, ProtobufTransportRequest request,
+        //         TransportRequestOptions options) throws IOException, TransportException {
+        //     // // TODO Auto-generated method stub
+        //     // throw new UnsupportedOperationException("Unimplemented method 'sendRequestProtobuf'");
+        //     sendLocalRequest(requestId, action, request, options);
+        // }
     };
 
     static {
@@ -225,9 +245,11 @@ public TransportService(
         taskManager = createTaskManager(settings, clusterSettings, threadPool, taskHeaders);
         this.interceptor = transportInterceptor;
         this.asyncSender = interceptor.interceptSender(this::sendRequestInternal);
+        // this.asyncSenderProtobuf = interceptor.interceptSenderProotbuf(this::sendRequestInternal);
         this.remoteClusterClient = DiscoveryNode.isRemoteClusterClient(settings);
         remoteClusterService = new RemoteClusterService(settings, this);
         responseHandlers = transport.getResponseHandlers();
+        // responseHandlersProtobuf = transport.getResponseHandlersProtobuf();
         if (clusterSettings != null) {
             clusterSettings.addSettingsUpdateConsumer(TransportSettings.TRACE_LOG_INCLUDE_SETTING, this::setTracerLogInclude);
             clusterSettings.addSettingsUpdateConsumer(TransportSettings.TRACE_LOG_EXCLUDE_SETTING, this::setTracerLogExclude);
@@ -244,6 +266,15 @@ public TransportService(
             HandshakeRequest::new,
             (request, channel, task) -> channel.sendResponse(new HandshakeResponse(localNode, clusterName, localNode.getVersion()))
         );
+
+        registerRequestHandlerProtobuf(
+            HANDSHAKE_ACTION_NAME,
+            ThreadPool.Names.SAME,
+            false,
+            false,
+            HandshakeRequest::new,
+            (request, channel, task) -> channel.sendResponse(new HandshakeResponse(localNode, clusterName, localNode.getVersion()))
+        );
     }
 
     public RemoteClusterService getRemoteClusterService() {
@@ -291,6 +322,7 @@ void setTracerLogExclude(List<String> tracerLogExclude) {
     @Override
     protected void doStart() {
         transport.setMessageListener(this);
+        // transport.setMessageListenerProtobuf(this);
         connectionManager.addListener(this);
         transport.start();
         if (transport.boundAddress() != null && logger.isInfoEnabled()) {
@@ -359,6 +391,47 @@ public void doRun() {
                     }
                 });
             }
+
+            // // in case the transport is not connected to our local node (thus cleaned on node disconnect)
+            // // make sure to clean any leftover on going handles
+            // for (final Transport.ProtobufResponseContext holderToNotify : responseHandlersProtobuf.prune(h -> true)) {
+            //     // callback that an exception happened, but on a different thread since we don't
+            //     // want handlers to worry about stack overflows
+            //     getExecutorService().execute(new AbstractRunnable() {
+            //         @Override
+            //         public void onRejection(Exception e) {
+            //             // if we get rejected during node shutdown we don't wanna bubble it up
+            //             logger.debug(
+            //                 () -> new ParameterizedMessage(
+            //                     "failed to notify response handler on rejection, action: {}",
+            //                     holderToNotify.action()
+            //                 ),
+            //                 e
+            //             );
+            //         }
+
+            //         @Override
+            //         public void onFailure(Exception e) {
+            //             logger.warn(
+            //                 () -> new ParameterizedMessage(
+            //                     "failed to notify response handler on exception, action: {}",
+            //                     holderToNotify.action()
+            //                 ),
+            //                 e
+            //             );
+            //         }
+
+            //         @Override
+            //         public void doRun() {
+            //             ProtobufTransportException ex = new ProtobufSendRequestTransportException(
+            //                 holderToNotify.connection().getNode(),
+            //                 holderToNotify.action(),
+            //                 new ProtobufNodeClosedException(localNode)
+            //             );
+            //             holderToNotify.handler().handleException(ex);
+            //         }
+            //     });
+            // }
         }
     }
 
@@ -385,10 +458,23 @@ public TransportInfo info() {
         return new TransportInfo(boundTransportAddress, transport.profileBoundAddresses());
     }
 
+    @Override
+    public ProtobufTransportInfo protobufInfo() {
+        BoundTransportAddress boundTransportAddress = boundAddress();
+        if (boundTransportAddress == null) {
+            return null;
+        }
+        return new ProtobufTransportInfo(boundTransportAddress, transport.profileBoundAddresses());
+    }
+
     public TransportStats stats() {
         return transport.getStats();
     }
 
+    public ProtobufTransportStats protobufStats() {
+        return transport.getProtobufStats();
+    }
+
     public boolean isTransportSecure() {
         return transport.isSecure();
     }
@@ -413,7 +499,7 @@ public boolean nodeConnected(DiscoveryNode node) {
      *
      * @param node the node to connect to
      */
-    public void connectToNode(DiscoveryNode node) throws ConnectTransportException {
+    public void connectToNode(DiscoveryNode node) throws ConnectTransportException, ProtobufConnectTransportException {
         connectToNode(node, (ConnectionProfile) null);
     }
 
@@ -465,11 +551,11 @@ public void connectToExtensionNode(final DiscoveryNode node, ConnectionProfile c
      * @param node the node to connect to
      * @param listener the action listener to notify
      */
-    public void connectToNode(DiscoveryNode node, ActionListener<Void> listener) throws ConnectTransportException {
+    public void connectToNode(DiscoveryNode node, ActionListener<Void> listener) throws ConnectTransportException, ProtobufConnectTransportException {
         connectToNode(node, null, listener);
     }
 
-    public void connectToExtensionNode(DiscoveryNode node, ActionListener<Void> listener) throws ConnectTransportException {
+    public void connectToExtensionNode(DiscoveryNode node, ActionListener<Void> listener) throws ConnectTransportException, ProtobufConnectTransportException {
         connectToExtensionNode(node, null, listener);
     }
 
@@ -482,6 +568,7 @@ public void connectToExtensionNode(DiscoveryNode node, ActionListener<Void> list
      * @param listener the action listener to notify
      */
     public void connectToNode(final DiscoveryNode node, ConnectionProfile connectionProfile, ActionListener<Void> listener) {
+        System.out.println("TransportService.connectToNode");
         if (isLocalNode(node)) {
             listener.onResponse(null);
             return;
@@ -691,6 +778,48 @@ public void onFailure(Exception e) {
                 }
             }, HandshakeResponse::new, ThreadPool.Names.GENERIC)
         );
+        // sendRequestProtobuf(
+        //     connection,
+        //     HANDSHAKE_ACTION_NAME,
+        //     HandshakeRequest.INSTANCE,
+        //     TransportRequestOptions.builder().withTimeout(handshakeTimeout).build(),
+        //     new ProtobufActionListenerResponseHandler<>(new ActionListener<HandshakeResponse>() {
+        //         @Override
+        //         public void onResponse(HandshakeResponse response) {
+        //             if (clusterNamePredicate.test(response.clusterName) == false) {
+        //                 listener.onFailure(
+        //                     new IllegalStateException(
+        //                         "handshake with ["
+        //                             + node
+        //                             + "] failed: remote cluster name ["
+        //                             + response.clusterName.value()
+        //                             + "] does not match "
+        //                             + clusterNamePredicate
+        //                     )
+        //                 );
+        //             } else if (response.version.isCompatible(localNode.getVersion()) == false) {
+        //                 listener.onFailure(
+        //                     new IllegalStateException(
+        //                         "handshake with ["
+        //                             + node
+        //                             + "] failed: remote node version ["
+        //                             + response.version
+        //                             + "] is incompatible with local node version ["
+        //                             + localNode.getVersion()
+        //                             + "]"
+        //                     )
+        //                 );
+        //             } else {
+        //                 listener.onResponse(response);
+        //             }
+        //         }
+
+        //         @Override
+        //         public void onFailure(Exception e) {
+        //             listener.onFailure(e);
+        //         }
+        //     }, HandshakeResponse::new, ThreadPool.Names.GENERIC)
+        // );
     }
 
     public ConnectionManager getConnectionManager() {
@@ -710,10 +839,31 @@ static class HandshakeRequest extends TransportRequest {
             super(in);
         }
 
+        HandshakeRequest(CodedInputStream in) throws IOException {
+            super(in);
+        }
+
         private HandshakeRequest() {}
 
     }
 
+    // /**
+    //  * Internal Handshake request
+    // *
+    // * @opensearch.internal
+    // */
+    // static class ProtobufHandshakeRequest extends ProtobufTransportRequest {
+
+    //     public static final ProtobufHandshakeRequest INSTANCE = new ProtobufHandshakeRequest();
+
+    //     ProtobufHandshakeRequest(CodedInputStream in) throws IOException {
+    //         super(in);
+    //     }
+
+    //     private ProtobufHandshakeRequest() {}
+
+    // }
+
     /**
      * Internal handshake response
      *
@@ -737,6 +887,22 @@ public HandshakeResponse(StreamInput in) throws IOException {
             version = in.readVersion();
         }
 
+        public HandshakeResponse(CodedInputStream in) throws IOException {
+            super(in);
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+            discoveryNode = protobufStreamInput.readOptionalWriteable(DiscoveryNode::new);
+            clusterName = new ClusterName(in);
+            version = Version.readVersionProtobuf(in);
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+            protobufStreamOutput.writeOptionalWriteable(discoveryNode);
+            clusterName.writeTo(out);
+            out.writeInt32NoTag(version.id);
+        }
+
         @Override
         public void writeTo(StreamOutput out) throws IOException {
             out.writeOptionalWriteable(discoveryNode);
@@ -753,6 +919,48 @@ public ClusterName getClusterName() {
         }
     }
 
+    // /**
+    //  * Internal handshake response
+    // *
+    // * @opensearch.internal
+    // */
+    // public static class ProtobufHandshakeResponse extends ProtobufTransportResponse {
+    //     private final DiscoveryNode discoveryNode;
+    //     private final ClusterName clusterName;
+    //     private final Version version;
+
+    //     public ProtobufHandshakeResponse(DiscoveryNode discoveryNode, ClusterName clusterName, Version version) {
+    //         this.discoveryNode = discoveryNode;
+    //         this.version = version;
+    //         this.clusterName = clusterName;
+    //     }
+
+    //     public ProtobufHandshakeResponse(CodedInputStream in) throws IOException {
+    //         super(in);
+    //         ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+    //         discoveryNode = protobufStreamInput.readOptionalWriteable(DiscoveryNode::new);
+    //         clusterName = new ClusterName(in);
+    //         version = Version.readVersionProtobuf(in);
+    //     }
+
+    //     @Override
+    //     public void writeTo(CodedOutputStream out) throws IOException {
+    //         ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+    //         protobufStreamOutput.writeOptionalWriteable(discoveryNode);
+    //         clusterName.writeTo(out);
+    //         out.writeInt32NoTag(version.id);
+    //     }
+
+    //     public DiscoveryNode getDiscoveryNode() {
+    //         return discoveryNode;
+    //     }
+
+    //     public ClusterName getClusterName() {
+    //         return clusterName;
+    //     }
+    // }
+
+
     public void disconnectFromNode(DiscoveryNode node) {
         if (isLocalNode(node)) {
             return;
@@ -764,10 +972,18 @@ public void addMessageListener(TransportMessageListener listener) {
         messageListener.listeners.add(listener);
     }
 
+    // public void addMessageListenerProtobuf(ProtobufTransportMessageListener listener) {
+    //     messageListener.listeners.add(listener);
+    // }
+
     public boolean removeMessageListener(TransportMessageListener listener) {
         return messageListener.listeners.remove(listener);
     }
 
+    // public boolean removeMessageListenerProtobuf(ProtobufTransportMessageListener listener) {
+    //     return messageListener.listeners.remove(listener);
+    // }
+
     public void addConnectionListener(TransportConnectionListener listener) {
         connectionManager.addListener(listener);
     }
@@ -827,6 +1043,10 @@ public final <T extends TransportResponse> void sendRequest(
         final TransportRequestOptions options,
         TransportResponseHandler<T> handler
     ) {
+        System.out.println("sendRequest");
+        System.out.println("node: " + node);
+        System.out.println("action: " + action);
+        System.out.println("request: " + request);
         final Transport.Connection connection;
         try {
             connection = getConnection(node);
@@ -856,6 +1076,7 @@ public final <T extends TransportResponse> void sendRequest(
         final TransportResponseHandler<T> handler
     ) {
         try {
+            System.out.println("sendRequest2");
             logger.debug("Action: " + action);
             final TransportResponseHandler<T> delegate;
             if (request.getParentTask().isSet()) {
@@ -888,6 +1109,16 @@ public T read(StreamInput in) throws IOException {
                     public String toString() {
                         return getClass().getName() + "/[" + action + "]:" + handler.toString();
                     }
+
+                    @Override
+                    public T read(CodedInputStream in) throws IOException {
+                        return handler.read(in);
+                    }
+
+                    @Override
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                        handler.handleExceptionProtobuf(exp);
+                    }
                 };
             } else {
                 delegate = handler;
@@ -905,14 +1136,150 @@ public String toString() {
         }
     }
 
+    // public <T extends ProtobufTransportResponse> TransportFuture<T> submitRequestProtobuf(
+    //     DiscoveryNode node,
+    //     String action,
+    //     ProtobufTransportRequest request,
+    //     ProtobufTransportResponseHandler<T> handler
+    // ) throws ProtobufTransportException {
+    //     return submitRequestProtobuf(node, action, request, TransportRequestOptions.EMPTY, handler);
+    // }
+
+    // public <T extends ProtobufTransportResponse> TransportFuture<T> submitRequestProtobuf(
+    //     DiscoveryNode node,
+    //     String action,
+    //     ProtobufTransportRequest request,
+    //     TransportRequestOptions options,
+    //     ProtobufTransportResponseHandler<T> handler
+    // ) throws ProtobufTransportException {
+    //     ProtobufPlainTransportFuture<T> futureHandler = new ProtobufPlainTransportFuture<>(handler);
+    //     try {
+    //         Transport.Connection connection = getConnection(node);
+    //         sendRequestProtobuf(connection, action, request, options, futureHandler);
+    //     } catch (ProtobufNodeNotConnectedException ex) {
+    //         // the caller might not handle this so we invoke the handler
+    //         futureHandler.handleException(ex);
+    //     }
+    //     return futureHandler;
+    // }
+
+    // public <T extends ProtobufTransportResponse> void sendRequestProtobuf(
+    //     final DiscoveryNode node,
+    //     final String action,
+    //     final ProtobufTransportRequest request,
+    //     final ProtobufTransportResponseHandler<T> handler
+    // ) {
+    //     final Transport.Connection connection;
+    //     try {
+    //         connection = getConnection(node);
+    //     } catch (final ProtobufNodeNotConnectedException ex) {
+    //         // the caller might not handle this so we invoke the handler
+    //         handler.handleException(ex);
+    //         return;
+    //     }
+    //     sendRequestProtobuf(connection, action, request, TransportRequestOptions.EMPTY, handler);
+    // }
+
+    // public final <T extends ProtobufTransportResponse> void sendRequestProtobuf(
+    //     final DiscoveryNode node,
+    //     final String action,
+    //     final ProtobufTransportRequest request,
+    //     final TransportRequestOptions options,
+    //     ProtobufTransportResponseHandler<T> handler
+    // ) {
+    //     final Transport.Connection connection;
+    //     try {
+    //         connection = getConnection(node);
+    //     } catch (final ProtobufNodeNotConnectedException ex) {
+    //         // the caller might not handle this so we invoke the handler
+    //         handler.handleException(ex);
+    //         return;
+    //     }
+    //     sendRequestProtobuf(connection, action, request, options, handler);
+    // }
+
+    // /**
+    //  * Sends a request on the specified connection. If there is a failure sending the request, the specified handler is invoked.
+    // *
+    // * @param connection the connection to send the request on
+    // * @param action     the name of the action
+    // * @param request    the request
+    // * @param options    the options for this request
+    // * @param handler    the response handler
+    // * @param <T>        the type of the transport response
+    // */
+    // public final <T extends ProtobufTransportResponse> void sendRequestProtobuf(
+    //     final Transport.Connection connection,
+    //     final String action,
+    //     final ProtobufTransportRequest request,
+    //     final TransportRequestOptions options,
+    //     final ProtobufTransportResponseHandler<T> handler
+    // ) {
+    //     try {
+    //         logger.debug("Action: " + action);
+    //         final ProtobufTransportResponseHandler<T> delegate;
+    //         if (request.getParentTask().isSet()) {
+    //             // TODO: capture the connection instead so that we can cancel child tasks on the remote connections.
+    //             final Releasable unregisterChildNode = taskManager.registerProtobufChildNode(
+    //                 request.getParentTask().getId(),
+    //                 connection.getNode()
+    //             );
+    //             delegate = new ProtobufTransportResponseHandler<T>() {
+    //                 @Override
+    //                 public void handleResponse(T response) {
+    //                     unregisterChildNode.close();
+    //                     handler.handleResponse(response);
+    //                 }
+
+    //                 @Override
+    //                 public void handleException(ProtobufTransportException exp) {
+    //                     unregisterChildNode.close();
+    //                     handler.handleException(exp);
+    //                 }
+
+    //                 @Override
+    //                 public String executor() {
+    //                     return handler.executor();
+    //                 }
+
+    //                 @Override
+    //                 public T read(CodedInputStream in) throws IOException {
+    //                     return handler.read(in);
+    //                 }
+
+    //                 @Override
+    //                 public String toString() {
+    //                     return getClass().getName() + "/[" + action + "]:" + handler.toString();
+    //                 }
+    //             };
+    //         } else {
+    //             delegate = handler;
+    //         }
+    //         asyncSenderProtobuf.sendRequest(connection, action, request, options, delegate);
+    //     } catch (final Exception ex) {
+    //         // the caller might not handle this so we invoke the handler
+    //         final ProtobufTransportException te;
+    //         if (ex instanceof ProtobufTransportException) {
+    //             te = (ProtobufTransportException) ex;
+    //         } else {
+    //             te = new ProtobufTransportException("failure to send", ex);
+    //         }
+    //         handler.handleException(te);
+    //     }
+    // }
+
     /**
      * Returns either a real transport connection or a local node connection if we are using the local node optimization.
      * @throws NodeNotConnectedException if the given node is not connected
      */
     public Transport.Connection getConnection(DiscoveryNode node) {
+        System.out.println("transport service");
+        System.out.println("Getting connection for node " + node);
         if (isLocalNode(node)) {
+            System.out.println("Is local node");
             return localNodeConnection;
         } else {
+            System.out.println("Not local node");
             return connectionManager.getConnection(node);
         }
     }
@@ -1220,6 +1587,66 @@ public <Request extends TransportRequest> void registerRequestHandler(
         transport.registerRequestHandler(reg);
     }
 
+    /**
+    * Registers a new request handler
+    *
+    * @param action         The action the request handler is associated with
+    * @param requestReader  a callable to be used construct new instances for streaming
+    * @param executor       The executor the request handling will be executed on
+    * @param handler        The handler itself that implements the request handling
+    */
+    public <Request extends TransportRequest> void registerRequestHandlerProtobuf(
+        String action,
+        String executor,
+        ProtobufWriteable.Reader<Request> requestReader,
+        ProtobufTransportRequestHandler<Request> handler
+    ) {
+        validateActionName(action);
+        handler = interceptor.interceptHandlerProtobuf(action, executor, false, handler);
+        ProtobufRequestHandlerRegistry<Request> reg = new ProtobufRequestHandlerRegistry<>(
+            action,
+            requestReader,
+            taskManager,
+            handler,
+            executor,
+            false,
+            true
+        );
+        transport.registerProtobufRequestHandler(reg);
+    }
+
+    /**
+     * Registers a new request handler
+    *
+    * @param action                The action the request handler is associated with
+    * @param requestReader               The request class that will be used to construct new instances for streaming
+    * @param executor              The executor the request handling will be executed on
+    * @param forceExecution        Force execution on the executor queue and never reject it
+    * @param canTripCircuitBreaker Check the request size and raise an exception in case the limit is breached.
+    * @param handler               The handler itself that implements the request handling
+    */
+    public <Request extends TransportRequest> void registerRequestHandlerProtobuf(
+        String action,
+        String executor,
+        boolean forceExecution,
+        boolean canTripCircuitBreaker,
+        ProtobufWriteable.Reader<Request> requestReader,
+        ProtobufTransportRequestHandler<Request> handler
+    ) {
+        validateActionName(action);
+        handler = interceptor.interceptHandlerProtobuf(action, executor, forceExecution, handler);
+        ProtobufRequestHandlerRegistry<Request> reg = new ProtobufRequestHandlerRegistry<>(
+            action,
+            requestReader,
+            taskManager,
+            handler,
+            executor,
+            forceExecution,
+            canTripCircuitBreaker
+        );
+        transport.registerProtobufRequestHandler(reg);
+    }
+
     /**
      * called by the {@link Transport} implementation when an incoming request arrives but before
      * any parsing of it has happened (with the exception of the requestId and action)
@@ -1282,6 +1709,10 @@ public RequestHandlerRegistry<? extends TransportRequest> getRequestHandler(Stri
         return transport.getRequestHandlers().getHandler(action);
     }
 
+    public ProtobufRequestHandlerRegistry<? extends TransportRequest> getRequestHandlerProtobuf(String action) {
+        return transport.getProtobufRequestHandlers().getHandler(action);
+    }
+
     private void checkForTimeout(long requestId) {
         // lets see if its in the timeout holder, but sync on mutex to make sure any ongoing timeout handling has finished
         final DiscoveryNode sourceNode;
@@ -1497,6 +1928,21 @@ void setTimeoutHandler(TimeoutHandler handler) {
             this.handler = handler;
         }
 
+        @Override
+        public T read(CodedInputStream in) throws IOException {
+            return delegate.read(in);
+        }
+
+        @Override
+        public void handleExceptionProtobuf(ProtobufTransportException exp) {
+            if (handler != null) {
+                handler.cancel();
+            }
+            try (ThreadContext.StoredContext ignore = contextSupplier.get()) {
+                delegate.handleExceptionProtobuf(exp);
+            }
+        }
+
     }
 
     /**
diff --git a/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java b/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java
index 27832c3c633ec..972f2469250d4 100644
--- a/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java
@@ -49,7 +49,7 @@
 import org.opensearch.common.lifecycle.LifecycleListener;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+import org.opensearch.common.transport.BoundTransportAddress;
 import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.test.OpenSearchTestCase;
@@ -61,7 +61,7 @@
 import org.opensearch.transport.ConnectionProfile;
 import org.opensearch.transport.ProtobufConnectionProfile;
 import org.opensearch.transport.ProtobufTransportMessageListener;
-import org.opensearch.transport.ProtobufTransportRequest;
+import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.ProtobufTransportStats;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportException;
@@ -696,15 +696,15 @@ public RequestHandlers getRequestHandlers() {
         }
 
         @Override
-        public void setMessageListener(ProtobufTransportMessageListener listener) {}
+        public void setMessageListenerProtobuf(ProtobufTransportMessageListener listener) {}
 
         @Override
-        public ProtobufBoundTransportAddress boundProtobufAddress() {
+        public BoundTransportAddress boundProtobufAddress() {
             return null;
         }
 
         @Override
-        public Map<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses() {
+        public Map<String, BoundTransportAddress> profileProtobufBoundAddresses() {
             return null;
         }
 
@@ -732,7 +732,7 @@ public DiscoveryNode getNode() {
                     public void sendRequest(
                         long requestId,
                         String action,
-                        ProtobufTransportRequest request,
+                        TransportRequest request,
                         TransportRequestOptions options
                     ) throws TransportException {}
 
diff --git a/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java b/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java
index 51a9ee248e1ca..d72863baf010d 100644
--- a/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java
@@ -34,8 +34,8 @@
 
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
 import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.ProtobufBoundTransportAddress;
-import org.opensearch.common.transport.ProtobufTransportAddress;
+import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.http.HttpInfo;
 import org.opensearch.http.HttpServerTransport;
@@ -61,17 +61,17 @@ public static class TestPlugin extends Plugin {}
         new TransportAddress[] { DUMMY_TRANSPORT_ADDRESS },
         DUMMY_TRANSPORT_ADDRESS
     );
-    private static final ProtobufTransportAddress DUMMY_PROTOBUF_TRANSPORT_ADDRESS = new ProtobufTransportAddress(
-        ProtobufTransportAddress.META_ADDRESS,
-        0
-    );
-    private static final ProtobufBoundTransportAddress DUMMY_PROTOBUF_BOUND_ADDRESS = new ProtobufBoundTransportAddress(
-        new ProtobufTransportAddress[] { DUMMY_PROTOBUF_TRANSPORT_ADDRESS },
-        DUMMY_PROTOBUF_TRANSPORT_ADDRESS
-    );
+    // private static final TransportAddress DUMMY_PROTOBUF_TRANSPORT_ADDRESS = new TransportAddress(
+    //     TransportAddress.META_ADDRESS,
+    //     0
+    // );
+    // private static final BoundTransportAddress DUMMY_PROTOBUF_BOUND_ADDRESS = new BoundTransportAddress(
+    //     new TransportAddress[] { DUMMY_PROTOBUF_TRANSPORT_ADDRESS },
+    //     DUMMY_PROTOBUF_TRANSPORT_ADDRESS
+    // );
     private static final HttpInfo DUMMY_HTTP_INFO = new HttpInfo(DUMMY_BOUND_ADDRESS, 0);
     private static final HttpStats DUMMY_HTTP_STATS = new HttpStats(0, 0);
-    private static final ProtobufHttpInfo DUMMY_PROTOBUF_HTTP_INFO = new ProtobufHttpInfo(DUMMY_PROTOBUF_BOUND_ADDRESS, 0);
+    private static final ProtobufHttpInfo DUMMY_PROTOBUF_HTTP_INFO = new ProtobufHttpInfo(DUMMY_BOUND_ADDRESS, 0);
     private static final ProtobufHttpStats DUMMY_PROTOBUF_HTTP_STATS = new ProtobufHttpStats(0, 0);
 
     @Override
diff --git a/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java b/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
index 42e9ae078dae8..9adf613a421ee 100644
--- a/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
@@ -37,20 +37,23 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
 import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.ProtobufBoundTransportAddress;
-import org.opensearch.common.transport.ProtobufTransportAddress;
+// import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+// import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.transport.CloseableConnection;
 import org.opensearch.transport.ConnectionProfile;
 import org.opensearch.transport.ProtobufConnectionProfile;
-import org.opensearch.transport.ProtobufTransportMessageListener;
+// import org.opensearch.transport.ProtobufTransportMessageListener;
+import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.ProtobufTransportStats;
 import org.opensearch.transport.Transport;
+import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportMessageListener;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestOptions;
 import org.opensearch.transport.TransportStats;
 
+import java.io.IOException;
 import java.net.UnknownHostException;
 import java.util.Collections;
 import java.util.List;
@@ -105,6 +108,12 @@ public DiscoveryNode getNode() {
             public void sendRequest(long requestId, String action, TransportRequest request, TransportRequestOptions options) {
 
             }
+
+            // @Override
+            // public void sendRequestProtobuf(long requestId, String action, TransportRequest request,
+            //         TransportRequestOptions options) throws IOException, TransportException {
+
+            // }
         });
     }
 
@@ -138,35 +147,35 @@ protected void doClose() {
 
     }
 
-    @Override
-    public void setMessageListener(ProtobufTransportMessageListener listener) {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'setMessageListener'");
-    }
+    // @Override
+    // public void setMessageListenerProtobuf(ProtobufTransportMessageListener listener) {
+    //     // TODO Auto-generated method stub
+    //     throw new UnsupportedOperationException("Unimplemented method 'setMessageListener'");
+    // }
 
-    @Override
-    public ProtobufBoundTransportAddress boundProtobufAddress() {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'boundProtobufAddress'");
-    }
+    // @Override
+    // public ProtobufBoundTransportAddress boundProtobufAddress() {
+    //     // TODO Auto-generated method stub
+    //     throw new UnsupportedOperationException("Unimplemented method 'boundProtobufAddress'");
+    // }
 
-    @Override
-    public Map<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses() {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'profileProtobufBoundAddresses'");
-    }
+    // @Override
+    // public Map<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses() {
+    //     // TODO Auto-generated method stub
+    //     throw new UnsupportedOperationException("Unimplemented method 'profileProtobufBoundAddresses'");
+    // }
 
-    @Override
-    public ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'addressesFromStringProtobuf'");
-    }
+    // @Override
+    // public ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException {
+    //     // TODO Auto-generated method stub
+    //     throw new UnsupportedOperationException("Unimplemented method 'addressesFromStringProtobuf'");
+    // }
 
-    @Override
-    public void openProtobufConnection(DiscoveryNode node, ProtobufConnectionProfile profile, ActionListener<ProtobufConnection> listener) {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'openProtobufConnection'");
-    }
+    // @Override
+    // public void openProtobufConnection(DiscoveryNode node, ProtobufConnectionProfile profile, ActionListener<Connection> listener) {
+    //     // TODO Auto-generated method stub
+    //     throw new UnsupportedOperationException("Unimplemented method 'openProtobufConnection'");
+    // }
 
     @Override
     public ProtobufTransportStats getProtobufStats() {
@@ -174,11 +183,11 @@ public ProtobufTransportStats getProtobufStats() {
         throw new UnsupportedOperationException("Unimplemented method 'getProtobufStats'");
     }
 
-    @Override
-    public ProtobufResponseHandlers getProtobufResponseHandlers() {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'getProtobufResponseHandlers'");
-    }
+    // @Override
+    // public ProtobufResponseHandlers getProtobufResponseHandlers() {
+    //     // TODO Auto-generated method stub
+    //     throw new UnsupportedOperationException("Unimplemented method 'getProtobufResponseHandlers'");
+    // }
 
     @Override
     public ProtobufRequestHandlers getProtobufRequestHandlers() {
diff --git a/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java b/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
index 11ef579a3ac42..f53b63fa0a578 100644
--- a/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
@@ -39,13 +39,14 @@
 import org.opensearch.common.lifecycle.Lifecycle;
 import org.opensearch.common.lifecycle.LifecycleListener;
 import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.ProtobufBoundTransportAddress;
-import org.opensearch.common.transport.ProtobufTransportAddress;
+// import org.opensearch.common.transport.ProtobufBoundTransportAddress;
+// import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.tasks.Task;
 import org.opensearch.transport.ConnectionProfile;
 import org.opensearch.transport.ProtobufConnectionProfile;
-import org.opensearch.transport.ProtobufTransportMessageListener;
+// import org.opensearch.transport.ProtobufTransportMessageListener;
+import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.ProtobufTransportStats;
 import org.opensearch.transport.RequestHandlerRegistry;
 import org.opensearch.transport.Transport;
@@ -285,6 +286,13 @@ public void close() {
         public Transport.Connection getConnection() {
             return connection;
         }
+
+        // @Override
+        // public void sendRequestProtobuf(long requestId, String action, TransportRequest request,
+        //         TransportRequestOptions options) throws IOException, TransportException {
+        //     // TODO Auto-generated method stub
+        //     throw new UnsupportedOperationException("Unimplemented method 'sendRequestProtobuf'");
+        // }
     }
 
     @FunctionalInterface
@@ -317,35 +325,35 @@ void messageReceived(TransportRequestHandler<Request> handler, Request request,
         default void clearCallback() {}
     }
 
-    @Override
-    public void setMessageListener(ProtobufTransportMessageListener listener) {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'setMessageListener'");
-    }
-
-    @Override
-    public ProtobufBoundTransportAddress boundProtobufAddress() {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'boundProtobufAddress'");
-    }
-
-    @Override
-    public Map<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses() {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'profileProtobufBoundAddresses'");
-    }
-
-    @Override
-    public ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'addressesFromStringProtobuf'");
-    }
-
-    @Override
-    public void openProtobufConnection(DiscoveryNode node, ProtobufConnectionProfile profile, ActionListener<ProtobufConnection> listener) {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'openProtobufConnection'");
-    }
+    // @Override
+    // public void setMessageListenerProtobuf(ProtobufTransportMessageListener listener) {
+    //     // TODO Auto-generated method stub
+    //     throw new UnsupportedOperationException("Unimplemented method 'setMessageListener'");
+    // }
+
+    // @Override
+    // public ProtobufBoundTransportAddress boundProtobufAddress() {
+    //     // TODO Auto-generated method stub
+    //     throw new UnsupportedOperationException("Unimplemented method 'boundProtobufAddress'");
+    // }
+
+    // @Override
+    // public Map<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses() {
+    //     // TODO Auto-generated method stub
+    //     throw new UnsupportedOperationException("Unimplemented method 'profileProtobufBoundAddresses'");
+    // }
+
+    // @Override
+    // public ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException {
+    //     // TODO Auto-generated method stub
+    //     throw new UnsupportedOperationException("Unimplemented method 'addressesFromStringProtobuf'");
+    // }
+
+    // @Override
+    // public void openProtobufConnection(DiscoveryNode node, ProtobufConnectionProfile profile, ActionListener<Connection> listener) {
+    //     // TODO Auto-generated method stub
+    //     throw new UnsupportedOperationException("Unimplemented method 'openProtobufConnection'");
+    // }
 
     @Override
     public ProtobufTransportStats getProtobufStats() {
@@ -353,11 +361,11 @@ public ProtobufTransportStats getProtobufStats() {
         throw new UnsupportedOperationException("Unimplemented method 'getProtobufStats'");
     }
 
-    @Override
-    public ProtobufResponseHandlers getProtobufResponseHandlers() {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'getProtobufResponseHandlers'");
-    }
+    // @Override
+    // public ProtobufResponseHandlers getProtobufResponseHandlers() {
+    //     // TODO Auto-generated method stub
+    //     throw new UnsupportedOperationException("Unimplemented method 'getProtobufResponseHandlers'");
+    // }
 
     @Override
     public ProtobufRequestHandlers getProtobufRequestHandlers() {
diff --git a/test/framework/src/main/java/org/opensearch/transport/AbstractSimpleTransportTestCase.java b/test/framework/src/main/java/org/opensearch/transport/AbstractSimpleTransportTestCase.java
index 29619a541722c..1edfe3a350e90 100644
--- a/test/framework/src/main/java/org/opensearch/transport/AbstractSimpleTransportTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/transport/AbstractSimpleTransportTestCase.java
@@ -74,6 +74,10 @@
 import org.opensearch.test.transport.StubbableTransport;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportResponse.Empty;
+
+import com.google.protobuf.CodedInputStream;
+
 import org.junit.After;
 import org.junit.Before;
 
@@ -324,6 +328,18 @@ public void handleException(TransportException exp) {
                     logger.error("Unexpected failure", exp);
                     fail("got exception instead of a response: " + exp.getMessage());
                 }
+
+                @Override
+                public StringMessageResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
 
@@ -360,6 +376,18 @@ public void handleException(TransportException exp) {
                     logger.error("Unexpected failure", exp);
                     fail("got exception instead of a response: " + exp.getMessage());
                 }
+
+                @Override
+                public StringMessageResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
 
@@ -417,6 +445,18 @@ public void handleException(TransportException exp) {
                 logger.error("Unexpected failure", exp);
                 fail("got exception instead of a response: " + exp.getMessage());
             }
+
+            @Override
+            public StringMessageResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         };
         StringMessageRequest ping = new StringMessageRequest("ping");
         threadPool.getThreadContext().putHeader("test.ping.user", "ping_user");
@@ -476,6 +516,18 @@ public void handleException(TransportException exp) {
                 public String executor() {
                     return ThreadPool.Names.GENERIC;
                 }
+
+                @Override
+                public StringMessageResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
         responseLatch.await();
@@ -659,6 +711,18 @@ public void handleException(TransportException exp) {
                         logger.error("Unexpected failure", exp);
                         fail("got exception instead of a response: " + exp.getMessage());
                     }
+
+                    @Override
+                    public Empty read(CodedInputStream in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
+
+                    @Override
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                    }
                 }
             );
 
@@ -721,6 +785,18 @@ public void handleException(TransportException exp) {
                         logger.error("Unexpected failure", exp);
                         fail("got exception instead of a response: " + exp.getMessage());
                     }
+
+                    @Override
+                    public StringMessageResponse read(CodedInputStream in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
+
+                    @Override
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                    }
                 }
             );
 
@@ -768,6 +844,18 @@ public void handleResponse(StringMessageResponse response) {
                 public void handleException(TransportException exp) {
                     assertThat("runtime_exception: bad message !!!", equalTo(exp.getCause().getMessage()));
                 }
+
+                @Override
+                public StringMessageResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
 
@@ -1017,6 +1105,18 @@ public void handleResponse(StringMessageResponse response) {
                 public void handleException(TransportException exp) {
                     assertThat(exp, instanceOf(ReceiveTimeoutTransportException.class));
                 }
+
+                @Override
+                public StringMessageResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
 
@@ -1091,6 +1191,18 @@ public void handleException(TransportException exp) {
                     latch.countDown();
                     assertThat(exp, instanceOf(ReceiveTimeoutTransportException.class));
                 }
+
+                @Override
+                public StringMessageResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
 
@@ -1132,6 +1244,18 @@ public void handleException(TransportException exp) {
                         logger.error("Unexpected failure", exp);
                         fail("got exception instead of a response for " + counter + ": " + exp.getDetailedMessage());
                     }
+
+                    @Override
+                    public StringMessageResponse read(CodedInputStream in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
+
+                    @Override
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                    }
                 }
             );
 
@@ -1176,6 +1300,18 @@ public void handleException(TransportException exp) {}
             public String executor() {
                 return ThreadPool.Names.SAME;
             }
+
+            @Override
+            public StringMessageResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         };
 
         serviceA.registerRequestHandler("internal:test", ThreadPool.Names.SAME, StringMessageRequest::new, handler);
@@ -1471,6 +1607,18 @@ public void handleException(TransportException exp) {
                 public String executor() {
                     return ThreadPool.Names.SAME;
                 }
+
+                @Override
+                public Version0Response read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         ).txGet();
 
@@ -1522,6 +1670,18 @@ public void handleException(TransportException exp) {
                 public String executor() {
                     return ThreadPool.Names.SAME;
                 }
+
+                @Override
+                public Version1Response read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         ).txGet();
 
@@ -1567,6 +1727,18 @@ public void handleException(TransportException exp) {
                 public String executor() {
                     return ThreadPool.Names.SAME;
                 }
+
+                @Override
+                public Version1Response read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         ).txGet();
 
@@ -1609,6 +1781,18 @@ public void handleException(TransportException exp) {
                 public String executor() {
                     return ThreadPool.Names.SAME;
                 }
+
+                @Override
+                public Version0Response read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         ).txGet();
 
@@ -1654,6 +1838,18 @@ public void handleException(TransportException exp) {
                     assertThat(cause, instanceOf(ConnectTransportException.class));
                     assertThat(((ConnectTransportException) cause).node(), equalTo(nodeA));
                 }
+
+                @Override
+                public StringMessageResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
 
@@ -1718,6 +1914,18 @@ public void handleResponse(StringMessageResponse response) {
                 public void handleException(TransportException exp) {
                     assertThat(exp, instanceOf(ReceiveTimeoutTransportException.class));
                 }
+
+                @Override
+                public StringMessageResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
 
@@ -1769,6 +1977,18 @@ public void handleException(TransportException exp) {
             public String executor() {
                 return ThreadPool.Names.SAME;
             }
+
+            @Override
+            public TestResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         });
 
         if (!latch.await(10, TimeUnit.SECONDS)) {
@@ -1817,6 +2037,18 @@ public void handleException(TransportException exp) {
                         public String executor() {
                             return ThreadPool.Names.SAME;
                         }
+
+                        @Override
+                        public TestResponse read(CodedInputStream in) throws IOException {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'read'");
+                        }
+
+                        @Override
+                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                        }
                     }
                 );
 
@@ -1852,6 +2084,18 @@ public void handleException(TransportException exp) {
                         public String executor() {
                             return ThreadPool.Names.SAME;
                         }
+
+                        @Override
+                        public TestResponse read(CodedInputStream in) throws IOException {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'read'");
+                        }
+
+                        @Override
+                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                        }
                     }
                 );
 
@@ -2010,6 +2254,18 @@ public void handleException(TransportException exp) {
                             public String executor() {
                                 return randomBoolean() ? ThreadPool.Names.SAME : ThreadPool.Names.GENERIC;
                             }
+
+                            @Override
+                            public TestResponse read(CodedInputStream in) throws IOException {
+                                // TODO Auto-generated method stub
+                                throw new UnsupportedOperationException("Unimplemented method 'read'");
+                            }
+
+                            @Override
+                            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                                // TODO Auto-generated method stub
+                                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                            }
                         }
                     );
                 } else {
@@ -2072,6 +2328,18 @@ public void handleException(TransportException exp) {
             public String executor() {
                 return randomBoolean() ? ThreadPool.Names.SAME : ThreadPool.Names.GENERIC;
             }
+
+            @Override
+            public TestResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         }
 
         for (int i = 0; i < iters; i++) {
@@ -2407,6 +2675,18 @@ public void handleException(TransportException exp) {
             public String executor() {
                 return randomFrom(executors);
             }
+
+            @Override
+            public TransportResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         };
 
         serviceB.sendRequest(nodeA, "internal:action", new TestRequest(randomFrom("fail", "pass")), transportResponseHandler);
@@ -2457,6 +2737,18 @@ public void handleException(TransportException exp) {
             public String executor() {
                 return randomFrom(executors);
             }
+
+            @Override
+            public TransportResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         };
         ConnectionProfile.Builder builder = new ConnectionProfile.Builder();
         builder.addConnections(
@@ -2527,6 +2819,18 @@ public void handleException(TransportException exp) {
             public String executor() {
                 return ThreadPool.Names.SAME;
             }
+
+            @Override
+            public TransportResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         };
 
         ConnectionProfile.Builder builder = new ConnectionProfile.Builder();
@@ -2601,6 +2905,18 @@ public void handleException(TransportException exp) {
             public String executor() {
                 return ThreadPool.Names.SAME;
             }
+
+            @Override
+            public TransportResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         };
 
         TransportStats stats = serviceC.transport.getStats(); // nothing transmitted / read yet
@@ -2722,6 +3038,18 @@ public void handleException(TransportException exp) {
             public String executor() {
                 return ThreadPool.Names.SAME;
             }
+
+            @Override
+            public TransportResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         };
 
         TransportStats stats = serviceC.transport.getStats(); // nothing transmitted / read yet
@@ -3109,6 +3437,18 @@ public String executor() {
                     public TransportResponse read(final StreamInput in) {
                         return TransportResponse.Empty.INSTANCE;
                     }
+
+                    @Override
+                    public TransportResponse read(CodedInputStream in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
+
+                    @Override
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                    }
                 }
             );
             assertThat(te.get(), not(nullValue()));

From 13c4568d66eeeb50b20cc84c3361b74e71821f63 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Tue, 11 Jul 2023 23:19:08 +0000
Subject: [PATCH 15/37] This fixes the single node calls after the refactoring
 in the previous commit

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../nodes/ProtobufTransportNodesAction.java   |  11 +-
 .../transport/TransportService.java           | 130 ++++++++++++------
 2 files changed, 95 insertions(+), 46 deletions(-)

diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
index 45680d612f24f..c42b1163c51c9 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
@@ -223,9 +223,9 @@ class AsyncAction {
         }
 
         void start() {
-            System.out.println("ProtoTransportNodesAction.AsyncAction.start");
+            // System.out.println("ProtoTransportNodesAction.AsyncAction.start");
             final DiscoveryNode[] nodes = request.concreteNodes();
-            System.out.println("Nodes: " + nodes[0]);
+            // System.out.println("Nodes: " + nodes[0]);
             if (nodes.length == 0) {
                 // nothing to notify
                 threadPool.generic().execute(() -> listener.onResponse(newResponse(request, responses)));
@@ -258,13 +258,13 @@ public NodeResponse read(CodedInputStream in) throws IOException {
 
                             @Override
                             public void handleResponse(NodeResponse response) {
-                                System.out.println("ProtoTransportNodesAction.AsyncAction.start.handleResponse");
+                                // System.out.println("ProtoTransportNodesAction.AsyncAction.start.handleResponse");
                                 onOperation(idx, response);
                             }
 
                             @Override
                             public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                                System.out.println("ProtoTransportNodesAction.AsyncAction.start.handleExceptionProtobuf");
+                                // System.out.println("ProtoTransportNodesAction.AsyncAction.start.handleExceptionProtobuf");
                                 onFailure(idx, node.getId(), exp);
                             }
 
@@ -281,8 +281,7 @@ public NodeResponse read(StreamInput in) throws IOException {
 
                             @Override
                             public void handleException(TransportException exp) {
-                                // TODO Auto-generated method stub
-                                throw new UnsupportedOperationException("Unimplemented method 'handleException'");
+                                onFailure(idx, node.getId(), exp);
                             }
                         }
                     );
diff --git a/server/src/main/java/org/opensearch/transport/TransportService.java b/server/src/main/java/org/opensearch/transport/TransportService.java
index a41057371e82b..31c2b2e4d32ed 100644
--- a/server/src/main/java/org/opensearch/transport/TransportService.java
+++ b/server/src/main/java/org/opensearch/transport/TransportService.java
@@ -568,7 +568,7 @@ public void connectToExtensionNode(DiscoveryNode node, ActionListener<Void> list
      * @param listener the action listener to notify
      */
     public void connectToNode(final DiscoveryNode node, ConnectionProfile connectionProfile, ActionListener<Void> listener) {
-        System.out.println("TransportService.connectToNode");
+        // System.out.println("TransportService.connectToNode");
         if (isLocalNode(node)) {
             listener.onResponse(null);
             return;
@@ -1043,10 +1043,10 @@ public final <T extends TransportResponse> void sendRequest(
         final TransportRequestOptions options,
         TransportResponseHandler<T> handler
     ) {
-        System.out.println("sendRequest");
-        System.out.println("node: " + node);
-        System.out.println("action: " + action);
-        System.out.println("request: " + request);
+        // System.out.println("sendRequest");
+        // System.out.println("node: " + node);
+        // System.out.println("action: " + action);
+        // System.out.println("request: " + request);
         final Transport.Connection connection;
         try {
             connection = getConnection(node);
@@ -1076,7 +1076,7 @@ public final <T extends TransportResponse> void sendRequest(
         final TransportResponseHandler<T> handler
     ) {
         try {
-            System.out.println("sendRequest2");
+            // System.out.println("sendRequest2");
             logger.debug("Action: " + action);
             final TransportResponseHandler<T> delegate;
             if (request.getParentTask().isSet()) {
@@ -1273,13 +1273,13 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
      * @throws NodeNotConnectedException if the given node is not connected
      */
     public Transport.Connection getConnection(DiscoveryNode node) {
-        System.out.println("transport service");
-        System.out.println("Getting connection for node " + node);
+        // System.out.println("transport service");
+        // System.out.println("Getting connection for node " + node);
         if (isLocalNode(node)) {
-            System.out.println("Is local node");
+            // System.out.println("Is local node");
             return localNodeConnection;
         } else {
-            System.out.println("Not local node");
+            // System.out.println("Not local node");
             return connectionManager.getConnection(node);
         }
     }
@@ -1411,49 +1411,99 @@ protected void doRun() throws Exception {
     }
 
     private void sendLocalRequest(long requestId, final String action, final TransportRequest request, TransportRequestOptions options) {
+        // System.out.println("Sending local request");
+        // System.out.println("Request id: " + requestId);
+        // System.out.println("Action: " + action);
+        // System.out.println("Request: " + request);
         final DirectResponseChannel channel = new DirectResponseChannel(localNode, action, requestId, this, threadPool);
         try {
             onRequestSent(localNode, requestId, action, request, options);
             onRequestReceived(requestId, action);
+            // System.out.println("Req canonical: " + request.getClass().getCanonicalName());
             final RequestHandlerRegistry reg = getRequestHandler(action);
+            final ProtobufRequestHandlerRegistry protobufRequestHandlerRegistry = getRequestHandlerProtobuf(action);
+            // if (request.getClass().getCanonicalName().contains("Protobuf")) {
+            //     protobufRequestHandlerRegistry = getRequestHandlerProtobuf(action);
+            // }   
+            // System.out.println("Request handler: " + reg);
+            // System.out.println("Protobuf request handler: " + protobufRequestHandlerRegistry);
             if (reg == null) {
                 throw new ActionNotFoundTransportException("Action [" + action + "] not found");
             }
-            final String executor = reg.getExecutor();
-            if (ThreadPool.Names.SAME.equals(executor)) {
-                // noinspection unchecked
-                reg.processMessageReceived(request, channel);
+            if (request.getClass().getCanonicalName().contains("Protobuf")) {
+                final String executor = protobufRequestHandlerRegistry.getExecutor();
+                if (ThreadPool.Names.SAME.equals(executor)) {
+                    // noinspection unchecked
+                    protobufRequestHandlerRegistry.processMessageReceived(request, channel);
+                } else {
+                    threadPool.executor(executor).execute(new AbstractRunnable() {
+                        @Override
+                        protected void doRun() throws Exception {
+                            // noinspection unchecked
+                            protobufRequestHandlerRegistry.processMessageReceived(request, channel);
+                        }
+
+                        @Override
+                        public boolean isForceExecution() {
+                            return protobufRequestHandlerRegistry.isForceExecution();
+                        }
+
+                        @Override
+                        public void onFailure(Exception e) {
+                            try {
+                                channel.sendResponse(e);
+                            } catch (Exception inner) {
+                                inner.addSuppressed(e);
+                                logger.warn(
+                                    () -> new ParameterizedMessage("failed to notify channel of error message for action [{}]", action),
+                                    inner
+                                );
+                            }
+                        }
+
+                        @Override
+                        public String toString() {
+                            return "processing of [" + requestId + "][" + action + "]: " + request;
+                        }
+                    });
+                }
             } else {
-                threadPool.executor(executor).execute(new AbstractRunnable() {
-                    @Override
-                    protected void doRun() throws Exception {
-                        // noinspection unchecked
-                        reg.processMessageReceived(request, channel);
-                    }
+                final String executor = reg.getExecutor();
+                if (ThreadPool.Names.SAME.equals(executor)) {
+                    // noinspection unchecked
+                    reg.processMessageReceived(request, channel);
+                } else {
+                    threadPool.executor(executor).execute(new AbstractRunnable() {
+                        @Override
+                        protected void doRun() throws Exception {
+                            // noinspection unchecked
+                            reg.processMessageReceived(request, channel);
+                        }
 
-                    @Override
-                    public boolean isForceExecution() {
-                        return reg.isForceExecution();
-                    }
+                        @Override
+                        public boolean isForceExecution() {
+                            return reg.isForceExecution();
+                        }
 
-                    @Override
-                    public void onFailure(Exception e) {
-                        try {
-                            channel.sendResponse(e);
-                        } catch (Exception inner) {
-                            inner.addSuppressed(e);
-                            logger.warn(
-                                () -> new ParameterizedMessage("failed to notify channel of error message for action [{}]", action),
-                                inner
-                            );
+                        @Override
+                        public void onFailure(Exception e) {
+                            try {
+                                channel.sendResponse(e);
+                            } catch (Exception inner) {
+                                inner.addSuppressed(e);
+                                logger.warn(
+                                    () -> new ParameterizedMessage("failed to notify channel of error message for action [{}]", action),
+                                    inner
+                                );
+                            }
                         }
-                    }
 
-                    @Override
-                    public String toString() {
-                        return "processing of [" + requestId + "][" + action + "]: " + request;
-                    }
-                });
+                        @Override
+                        public String toString() {
+                            return "processing of [" + requestId + "][" + action + "]: " + request;
+                        }
+                    });
+                }
             }
 
         } catch (Exception e) {

From b659260fe182a844e01b8050a94819ba69bc8af3 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Fri, 14 Jul 2023 19:38:27 +0000
Subject: [PATCH 16/37] Trying serialization and deserialization across nodes

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../common/bytes/AbstractBytesReference.java  |   9 +
 .../core/common/bytes/BytesArray.java         |   7 +
 .../core/common/bytes/BytesReference.java     |   7 +
 .../netty4/Netty4MessageChannelHandler.java   |   1 +
 .../ProtobufTransportNodesInfoAction.java     |  12 +-
 .../node/info/TransportNodesInfoAction.java   |  12 +-
 .../cluster/state/ClusterStateRequest.java    |  26 +++
 .../cluster/state/ClusterStateResponse.java   |   3 +
 .../state/ProtobufClusterStateAction.java     |   2 +-
 .../state/ProtobufClusterStateRequest.java    |  28 +++
 .../state/ProtobufClusterStateResponse.java   |   8 +-
 ...obufTransportClusterManagerNodeAction.java |  12 +-
 .../TransportClusterManagerNodeAction.java    |  10 +-
 .../support/nodes/TransportNodesAction.java   |   4 +-
 .../support/ProtobufAbstractClient.java       |   6 +-
 .../org/opensearch/cluster/ClusterName.java   |   2 +
 .../org/opensearch/cluster/ClusterState.java  |   4 +-
 .../cluster/coordination/Coordinator.java     |   2 +-
 .../bytes/ReleasableBytesReference.java       |   7 +
 .../common/util/concurrent/ThreadContext.java |  25 +++
 .../main/java/org/opensearch/node/Node.java   |   2 +-
 .../action/cat/ProtobufRestNodesAction.java   |  10 +-
 .../rest/action/cat/RestNodesAction.java      |  10 +-
 .../transport/BytesTransportRequest.java      |  11 +
 .../transport/ClusterConnectionManager.java   |   2 +-
 .../java/org/opensearch/transport/Header.java |  22 ++
 .../transport/InboundAggregator.java          |   1 +
 .../opensearch/transport/InboundDecoder.java  |  36 ++++
 .../opensearch/transport/InboundHandler.java  | 200 +++++++++++++++---
 .../opensearch/transport/InboundMessage.java  |  19 ++
 .../opensearch/transport/InboundPipeline.java |   7 +
 .../opensearch/transport/OutboundHandler.java |  78 ++++++-
 .../opensearch/transport/OutboundMessage.java |   8 +
 .../transport/ProtobufOutboundMessage.java    |  28 ++-
 .../ProtobufRequestHandlerRegistry.java       |   1 +
 .../transport/RemoteConnectionManager.java    |   2 +-
 .../opensearch/transport/TcpTransport.java    |   3 +
 .../transport/TransportService.java           |   2 +
 38 files changed, 545 insertions(+), 84 deletions(-)

diff --git a/libs/core/src/main/java/org/opensearch/core/common/bytes/AbstractBytesReference.java b/libs/core/src/main/java/org/opensearch/core/common/bytes/AbstractBytesReference.java
index e054776d67fdc..3ff94bca580c1 100644
--- a/libs/core/src/main/java/org/opensearch/core/common/bytes/AbstractBytesReference.java
+++ b/libs/core/src/main/java/org/opensearch/core/common/bytes/AbstractBytesReference.java
@@ -37,6 +37,8 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.xcontent.XContentBuilder;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.EOFException;
 import java.io.IOException;
 import java.io.OutputStream;
@@ -73,6 +75,13 @@ public StreamInput streamInput() throws IOException {
         return new BytesReferenceStreamInput();
     }
 
+    @Override
+    public CodedInputStream protobufInput() throws IOException {
+        return CodedInputStream.newInstance(streamInput());
+        // TODO Auto-generated method stub
+        // throw new UnsupportedOperationException("Unimplemented method 'protobufInput'");
+    }
+
     @Override
     public void writeTo(OutputStream os) throws IOException {
         final BytesRefIterator iterator = iterator();
diff --git a/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesArray.java b/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesArray.java
index ae04ddcc19eee..6b8939a59c79b 100644
--- a/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesArray.java
+++ b/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesArray.java
@@ -35,6 +35,8 @@
 import org.apache.lucene.util.BytesRef;
 import org.opensearch.core.common.io.stream.StreamInput;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.Arrays;
@@ -143,4 +145,9 @@ public StreamInput streamInput() {
     public void writeTo(OutputStream os) throws IOException {
         os.write(bytes, offset, length);
     }
+
+    @Override
+    public CodedInputStream protobufInput() throws IOException {
+        return CodedInputStream.newInstance(bytes, offset, length);
+    }
 }
diff --git a/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesReference.java b/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesReference.java
index fc8e62c914e27..3d236a42bc834 100644
--- a/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesReference.java
+++ b/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesReference.java
@@ -41,6 +41,8 @@
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
@@ -183,6 +185,11 @@ static BytesReference fromByteArray(ByteArray byteArray, int length) {
      */
     StreamInput streamInput() throws IOException;
 
+    /**
+     * A stream input of the bytes.
+     */
+    CodedInputStream protobufInput() throws IOException;
+
     /**
      * Writes the bytes directly to the output stream.
      */
diff --git a/modules/transport-netty4/src/main/java/org/opensearch/transport/netty4/Netty4MessageChannelHandler.java b/modules/transport-netty4/src/main/java/org/opensearch/transport/netty4/Netty4MessageChannelHandler.java
index 592ea45016bf3..f2b1249411219 100644
--- a/modules/transport-netty4/src/main/java/org/opensearch/transport/netty4/Netty4MessageChannelHandler.java
+++ b/modules/transport-netty4/src/main/java/org/opensearch/transport/netty4/Netty4MessageChannelHandler.java
@@ -83,6 +83,7 @@ final class Netty4MessageChannelHandler extends ChannelDuplexHandler {
 
     @Override
     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+        System.out.println("Coming in to channel read");
         assert Transports.assertDefaultThreadContext(transport.getThreadPool().getThreadContext());
         assert Transports.assertTransportThread();
         assert msg instanceof ByteBuf : "Expected message type ByteBuf, found: " + msg.getClass();
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
index b82d913f1e821..e5f185d6e2d07 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
@@ -66,22 +66,22 @@ protected ProtobufNodesInfoResponse newResponse(
         List<ProtobufNodeInfo> responses,
         List<ProtobufFailedNodeException> failures
     ) {
-        System.out.println("Inside newResponse");
-        System.out.println("nodesInfoRequest: " + nodesInfoRequest);
-        System.out.println("responses: " + responses);
-        System.out.println("failures: " + failures);
+        // System.out.println("Inside newResponse");
+        // System.out.println("nodesInfoRequest: " + nodesInfoRequest);
+        // System.out.println("responses: " + responses);
+        // System.out.println("failures: " + failures);
         return new ProtobufNodesInfoResponse(new ClusterName(clusterService.getClusterName().value()), responses, failures);
     }
 
     @Override
     protected NodeInfoRequest newNodeRequest(ProtobufNodesInfoRequest request) {
-        System.out.println("Inside newNodeRequest");
+        // System.out.println("Inside newNodeRequest");
         return new NodeInfoRequest(request);
     }
 
     @Override
     protected ProtobufNodeInfo newNodeResponse(CodedInputStream in) throws IOException {
-        System.out.println("Inside newNodeResponse with input stream");
+        // System.out.println("Inside newNodeResponse with input stream");
         return new ProtobufNodeInfo(in);
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
index b73c09b370aea..9223f532d7bde 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
@@ -89,22 +89,22 @@ protected NodesInfoResponse newResponse(
         List<NodeInfo> responses,
         List<FailedNodeException> failures
     ) {
-        System.out.println("Inside newResponse");
-        System.out.println("nodesInfoRequest: " + nodesInfoRequest);
-        System.out.println("responses: " + responses);
-        System.out.println("failures: " + failures);
+        // System.out.println("Inside newResponse");
+        // System.out.println("nodesInfoRequest: " + nodesInfoRequest);
+        // System.out.println("responses: " + responses);
+        // System.out.println("failures: " + failures);
         return new NodesInfoResponse(clusterService.getClusterName(), responses, failures);
     }
 
     @Override
     protected NodeInfoRequest newNodeRequest(NodesInfoRequest request) {
-        System.out.println("Inside newNodeRequest");
+        // System.out.println("Inside newNodeRequest");
         return new NodeInfoRequest(request);
     }
 
     @Override
     protected NodeInfo newNodeResponse(StreamInput in) throws IOException {
-        System.out.println("Inside newNodeResponse with input stream");
+        // System.out.println("Inside newNodeResponse with input stream");
         return new NodeInfo(in);
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateRequest.java
index bc6724d3081d6..d75710fe10b54 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateRequest.java
@@ -75,6 +75,16 @@ public ClusterStateRequest(StreamInput in) throws IOException {
         indicesOptions = IndicesOptions.readIndicesOptions(in);
         waitForTimeout = in.readTimeValue();
         waitForMetadataVersion = in.readOptionalLong();
+        System.out.println("ClusterStateRequest");
+        System.out.println("routingTable: " + routingTable);
+        System.out.println("nodes: " + nodes);
+        System.out.println("metadata: " + metadata);
+        System.out.println("blocks: " + blocks);
+        System.out.println("customs: " + customs);
+        System.out.println("indices: " + indices);
+        System.out.println("indicesOptions: " + indicesOptions);
+        System.out.println("waitForTimeout: " + waitForTimeout);
+        System.out.println("waitForMetadataVersion: " + waitForMetadataVersion);
     }
 
     @Override
@@ -209,4 +219,20 @@ public ClusterStateRequest waitForMetadataVersion(long waitForMetadataVersion) {
         this.waitForMetadataVersion = waitForMetadataVersion;
         return this;
     }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder();
+        builder.append("ClusterStateRequest[");
+        builder.append("routingTable=").append(routingTable());
+        builder.append(",nodes=").append(nodes());
+        builder.append(",metadata=").append(metadata());
+        builder.append(",blocks=").append(blocks());
+        builder.append(",customs=").append(customs());
+        builder.append(",indices=").append(indices());
+        builder.append(",indicesOptions=").append(indicesOptions());
+        builder.append(",waitForTimeout=").append(waitForTimeout());
+        builder.append(",waitForMetadataVersion=").append(waitForMetadataVersion());
+        return builder.append("]").toString();
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateResponse.java
index ce3b020280b16..d196a06dcc5cb 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateResponse.java
@@ -55,7 +55,10 @@ public class ClusterStateResponse extends ActionResponse {
 
     public ClusterStateResponse(StreamInput in) throws IOException {
         super(in);
+        System.out.println("ClusterStateResponse");
+        System.out.println("Stream input: " + in);
         clusterName = new ClusterName(in);
+        System.out.println("Cluster name: " + clusterName);
         clusterState = in.readOptionalWriteable(innerIn -> ClusterState.readFrom(innerIn, null));
         waitForTimedOut = in.readBoolean();
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateAction.java
index 3f3c2a4d80d0e..4f6b619049466 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateAction.java
@@ -18,7 +18,7 @@
 public class ProtobufClusterStateAction extends ProtobufActionType<ProtobufClusterStateResponse> {
 
     public static final ProtobufClusterStateAction INSTANCE = new ProtobufClusterStateAction();
-    public static final String NAME = "cluster:monitor/state";
+    public static final String NAME = "cluster:monitor/stateprotobuf";
 
     private ProtobufClusterStateAction() {
         super(NAME, ProtobufClusterStateResponse::new);
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
index 75c9ab839ba45..dce59990218ae 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
@@ -51,6 +51,8 @@ public ProtobufClusterStateRequest() {}
 
     public ProtobufClusterStateRequest(CodedInputStream in) throws IOException {
         super(in);
+        System.out.println("ProtobufClusterStateRequest constructor");
+        System.out.println("in: " + in);
         ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
         routingTable = in.readBool();
         nodes = in.readBool();
@@ -61,6 +63,16 @@ public ProtobufClusterStateRequest(CodedInputStream in) throws IOException {
         indicesOptions = IndicesOptions.readIndicesOptionsProtobuf(in);
         waitForTimeout = protobufStreamInput.readTimeValue();
         waitForMetadataVersion = protobufStreamInput.readOptionalLong();
+        System.out.println("ClusterStateRequest");
+        System.out.println("routingTable: " + routingTable);
+        System.out.println("nodes: " + nodes);
+        System.out.println("metadata: " + metadata);
+        System.out.println("blocks: " + blocks);
+        System.out.println("customs: " + customs);
+        System.out.println("indices: " + indices);
+        System.out.println("indicesOptions: " + indicesOptions);
+        System.out.println("waitForTimeout: " + waitForTimeout);
+        System.out.println("waitForMetadataVersion: " + waitForMetadataVersion);
     }
 
     @Override
@@ -196,4 +208,20 @@ public ProtobufClusterStateRequest waitForMetadataVersion(long waitForMetadataVe
         this.waitForMetadataVersion = waitForMetadataVersion;
         return this;
     }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder();
+        builder.append("ProtobufClusterStateRequest[");
+        builder.append("routingTable=").append(routingTable());
+        builder.append(",nodes=").append(nodes());
+        builder.append(",metadata=").append(metadata());
+        builder.append(",blocks=").append(blocks());
+        builder.append(",customs=").append(customs());
+        builder.append(",indices=").append(indices());
+        builder.append(",indicesOptions=").append(indicesOptions());
+        builder.append(",waitForTimeout=").append(waitForTimeout());
+        builder.append(",waitForMetadataVersion=").append(waitForMetadataVersion());
+        return builder.append("]").toString();
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
index 119cd41ad4f15..9241404c6f00b 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
@@ -37,8 +37,12 @@ public class ProtobufClusterStateResponse extends ProtobufActionResponse {
 
     public ProtobufClusterStateResponse(CodedInputStream in) throws IOException {
         super(in);
+        System.out.println("Inside ProtobufClusterStateResponse constructor");
+        System.out.println("CodedInputStream in: " + in.readTag());
         ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        clusterName = new ClusterName(in);
+        String cluster_name = in.readString();
+        System.out.println("cluster_name: " + cluster_name);
+        clusterName = new ClusterName(cluster_name);
         clusterState = protobufStreamInput.readOptionalWriteable(innerIn -> ClusterState.readFrom(innerIn, null));
         waitForTimedOut = in.readBool();
     }
@@ -74,7 +78,7 @@ public boolean isWaitForTimedOut() {
 
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
-        System.out.println("Inside writeTo of ProtobufClusterStateResponse");
+        // System.out.println("Inside writeTo of ProtobufClusterStateResponse");
         ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         clusterName.writeTo(out);
         protobufStreamOutput.writeOptionalWriteable(clusterState);
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
index f9bf42f0c887e..02b8f7db082ba 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
@@ -216,13 +216,13 @@ public Exception getTimeoutException(Exception e) {
 
         protected void doStart(ClusterState clusterState) {
             try {
-                System.out.println("ProtobufTransportClusterManagerNodeAction.doStart");
+                // System.out.println("ProtobufTransportClusterManagerNodeAction.doStart");
                 //this needs fixing
                 final DiscoveryNodes nodes = clusterService.state().nodes();
-                System.out.println("nodes: " + nodes);
+                // System.out.println("nodes: " + nodes);
                 // final DiscoveryNodes discoveryNodes = clusterService.state().nodes();
                 if (nodes.isLocalNodeElectedClusterManager() || localExecute(request)) {
-                    System.out.println("ProtobufTransportClusterManagerNodeAction.doStart.isLocalNodeElectedClusterManager");
+                    // System.out.println("ProtobufTransportClusterManagerNodeAction.doStart.isLocalNodeElectedClusterManager");
                     // check for block, if blocked, retry, else, execute locally
                     final ClusterBlockException blockException = checkBlock(request, clusterState);
                     if (blockException != null) {
@@ -261,13 +261,13 @@ protected void doStart(ClusterState clusterState) {
                             .execute(ActionRunnable.wrap(delegate, l -> clusterManagerOperation(task, request, clusterState, l)));
                     }
                 } else {
-                    System.out.println("In else");
+                    // System.out.println("In else");
                     if (nodes.getClusterManagerNode() == null) {
-                        System.out.println("In else if");
+                        // System.out.println("In else if");
                         logger.debug("no known cluster-manager node, scheduling a retry");
                         retryOnMasterChange(clusterState, null);
                     } else {
-                        System.out.println("In else else");
+                        // System.out.println("In else else");
                         DiscoveryNode clusterManagerNode = nodes.getClusterManagerNode();
                         final String actionName = getClusterManagerActionName(clusterManagerNode);
                         transportService.sendRequest(
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
index 5c00957f07d79..5c7edaf450fc5 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
@@ -231,11 +231,11 @@ public Exception getTimeoutException(Exception e) {
 
         protected void doStart(ClusterState clusterState) {
             try {
-                System.out.println("TransportClusterManagerNodeAction.doStart");
+                // System.out.println("TransportClusterManagerNodeAction.doStart");
                 final DiscoveryNodes nodes = clusterState.nodes();
-                System.out.println("nodes: " + nodes);
+                // System.out.println("nodes: " + nodes);
                 if (nodes.isLocalNodeElectedClusterManager() || localExecute(request)) {
-                    System.out.println("TransportClusterManagerNodeAction.doStart.isLocalNodeElectedClusterManager");
+                    // System.out.println("TransportClusterManagerNodeAction.doStart.isLocalNodeElectedClusterManager");
                     // check for block, if blocked, retry, else, execute locally
                     final ClusterBlockException blockException = checkBlock(request, clusterState);
                     if (blockException != null) {
@@ -274,9 +274,9 @@ protected void doStart(ClusterState clusterState) {
                             .execute(ActionRunnable.wrap(delegate, l -> clusterManagerOperation(task, request, clusterState, l)));
                     }
                 } else {
-                    System.out.println("In else");
+                    // System.out.println("In else");
                     if (nodes.getClusterManagerNode() == null) {
-                        System.out.println("In else if");
+                        // System.out.println("In else if");
                         logger.debug("no known cluster-manager node, scheduling a retry");
                         retryOnMasterChange(clusterState, null);
                     } else {
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java b/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
index 002ac45007b4b..01ce93ad14c43 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
@@ -244,9 +244,9 @@ class AsyncAction {
         }
 
         void start() {
-            System.out.println("TransportNodesAction.AsyncAction.start");
+            // System.out.println("TransportNodesAction.AsyncAction.start");
             final DiscoveryNode[] nodes = request.concreteNodes();
-            System.out.println("Nodes: " + nodes[0]);
+            // System.out.println("Nodes: " + nodes[0]);
             if (nodes.length == 0) {
                 // nothing to notify
                 threadPool.generic().execute(() -> listener.onResponse(newResponse(request, responses)));
diff --git a/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java b/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
index 741c8392713c2..f19cf4d076f61 100644
--- a/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
+++ b/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
@@ -143,9 +143,9 @@ public <Request extends ProtobufActionRequest, Response extends ProtobufActionRe
             Request request,
             ActionListener<Response> listener
         ) {
-            System.out.println("Nodes info execute");
-            System.out.println("action: " + action);
-            System.out.println("request: " + request);
+            // System.out.println("Nodes info execute");
+            // System.out.println("action: " + action);
+            // System.out.println("request: " + request);
             client.execute(action, request, listener);
         }
 
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterName.java b/server/src/main/java/org/opensearch/cluster/ClusterName.java
index b74a393bdd658..3a7535303c0cc 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterName.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterName.java
@@ -76,6 +76,8 @@ public ClusterName(CodedInputStream input) throws IOException {
     }
 
     public ClusterName(String value) {
+        System.out.println("Hello from ClusterName.java");
+        System.out.println("value: " + value);
         this.value = value.intern();
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterState.java b/server/src/main/java/org/opensearch/cluster/ClusterState.java
index ea400f7859cf7..03108760b7eee 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterState.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterState.java
@@ -801,7 +801,7 @@ public static ClusterState readFrom(CodedInputStream in, DiscoveryNode localNode
 
     @Override
     public void writeTo(StreamOutput out) throws IOException {
-        System.out.println("writeTo");
+        // System.out.println("writeTo");
         clusterName.writeTo(out);
         out.writeLong(version);
         out.writeString(stateUUID);
@@ -827,7 +827,7 @@ public void writeTo(StreamOutput out) throws IOException {
 
      @Override
     public void writeTo(CodedOutputStream out) throws IOException {
-        System.out.println("writeTo CodedOutputStream");
+        // System.out.println("writeTo CodedOutputStream");
         ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         clusterName.writeTo(out);
         out.writeInt64NoTag(version);
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
index f6cd024359e4e..b0b77a50da072 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
@@ -863,7 +863,7 @@ protected void doStart() {
             //     )
             //     .nodes(DiscoveryNodes.builder().add(getLocalNode()).localNodeId(getLocalNode().getId()))
             //     .build();
-            System.out.println("cluster state initial: " + initialState);
+            // System.out.println("cluster state initial: " + initialState);
             // System.out.println("protobuf cluster state initial: " + protobufInitialState);
             applierState = initialState;
             clusterApplier.setInitialState(initialState);
diff --git a/server/src/main/java/org/opensearch/common/bytes/ReleasableBytesReference.java b/server/src/main/java/org/opensearch/common/bytes/ReleasableBytesReference.java
index e0bc97f282e09..463b7abc0e0c2 100644
--- a/server/src/main/java/org/opensearch/common/bytes/ReleasableBytesReference.java
+++ b/server/src/main/java/org/opensearch/common/bytes/ReleasableBytesReference.java
@@ -40,6 +40,8 @@
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.core.xcontent.XContentBuilder;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.io.OutputStream;
 
@@ -123,6 +125,11 @@ public StreamInput streamInput() throws IOException {
         return delegate.streamInput();
     }
 
+    @Override
+    public CodedInputStream protobufInput() throws IOException {
+        return delegate.protobufInput();
+    }
+
     @Override
     public void writeTo(OutputStream os) throws IOException {
         delegate.writeTo(os);
diff --git a/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java b/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
index f6d1d1d6af0c7..348fb83d60338 100644
--- a/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
+++ b/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
@@ -31,6 +31,7 @@
 
 package org.opensearch.common.util.concurrent;
 
+import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -38,6 +39,7 @@
 import org.opensearch.client.OriginSettingClient;
 import org.opensearch.common.collect.MapBuilder;
 import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
@@ -387,6 +389,29 @@ public static Tuple<Map<String, String>, Map<String, Set<String>>> readHeadersFr
         return new Tuple<>(requestHeaders, responseHeaders);
     }
 
+    public static Tuple<Map<String, String>, Map<String, Set<String>>> readHeadersFromStreamProtobuf(CodedInputStream in) throws IOException {
+        ProtobufStreamInput streamInput = new ProtobufStreamInput(in);
+        final Map<String, String> requestHeaders = streamInput.readMap(CodedInputStream::readString, CodedInputStream::readString);
+        final Map<String, Set<String>> responseHeaders = streamInput.readMap(CodedInputStream::readString, input -> {
+            final int size = in.readInt32();
+            if (size == 0) {
+                return Collections.emptySet();
+            } else if (size == 1) {
+                return Collections.singleton(input.readString());
+            } else {
+                // use a linked hash set to preserve order
+                final LinkedHashSet<String> values = new LinkedHashSet<>(size);
+                for (int i = 0; i < size; i++) {
+                    final String value = input.readString();
+                    final boolean added = values.add(value);
+                    assert added : value;
+                }
+                return values;
+            }
+        });
+        return new Tuple<>(requestHeaders, responseHeaders);
+    }
+
     /**
      * Returns the header for the given key or <code>null</code> if not present
      */
diff --git a/server/src/main/java/org/opensearch/node/Node.java b/server/src/main/java/org/opensearch/node/Node.java
index e6704f118ffff..1ad0962437780 100644
--- a/server/src/main/java/org/opensearch/node/Node.java
+++ b/server/src/main/java/org/opensearch/node/Node.java
@@ -1464,7 +1464,7 @@ public Node start() throws NodeValidationException {
         // configureProtobufNodeAndClusterIdStateListener(clusterService);
 
         ClusterState clusterState1 = clusterService.state();
-        System.out.println("Cluster state: " + clusterState1);
+        // System.out.println("Cluster state: " + clusterState1);
         // ProtobufClusterState protobufClusterState1 = clusterService.protobufState();
         // System.out.println("Protobuf Cluster state: " + protobufClusterState1);
 
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
index 200a419cac257..3922be907d20a 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
@@ -338,11 +338,11 @@ Table buildTable(
         DiscoveryNodes nodes = state.getState().nodes();
         String clusterManagerId = nodes.getClusterManagerNodeId();
         Table table = getTableWithHeader(req);
-        System.out.println("Nodes: " + nodes);
-        System.out.println("clusterManagerId: " + clusterManagerId);
-        System.out.println("state: " + state);
-        System.out.println("nodesInfo: " + nodesInfo);
-        System.out.println("nodesStats: " + nodesStats);
+        // System.out.println("Nodes: " + nodes);
+        // System.out.println("clusterManagerId: " + clusterManagerId);
+        // System.out.println("state: " + state);
+        // System.out.println("nodesInfo: " + nodesInfo);
+        // System.out.println("nodesStats: " + nodesStats);
 
         for (DiscoveryNode node : nodes) {
             ProtobufNodeInfo info = nodesInfo.getNodesMap().get(node.getId());
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
index 2e2d5e8bb24e7..2a7473cb414ad 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
@@ -357,11 +357,11 @@ Table buildTable(
         DiscoveryNodes nodes = state.getState().nodes();
         String clusterManagerId = nodes.getClusterManagerNodeId();
         Table table = getTableWithHeader(req);
-        System.out.println("Nodes: " + nodes);
-        System.out.println("clusterManagerId: " + clusterManagerId);
-        System.out.println("state: " + state);
-        System.out.println("nodesInfo: " + nodesInfo);
-        System.out.println("nodesStats: " + nodesStats);
+        // System.out.println("Nodes: " + nodes);
+        // System.out.println("clusterManagerId: " + clusterManagerId);
+        // System.out.println("state: " + state);
+        // System.out.println("nodesInfo: " + nodesInfo);
+        // System.out.println("nodesStats: " + nodesStats);
         
         for (DiscoveryNode node : nodes) {
             NodeInfo info = nodesInfo.getNodesMap().get(node.getId());
diff --git a/server/src/main/java/org/opensearch/transport/BytesTransportRequest.java b/server/src/main/java/org/opensearch/transport/BytesTransportRequest.java
index 3fd84432639d4..3293d6887b5b4 100644
--- a/server/src/main/java/org/opensearch/transport/BytesTransportRequest.java
+++ b/server/src/main/java/org/opensearch/transport/BytesTransportRequest.java
@@ -37,6 +37,8 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 
 /**
@@ -78,6 +80,15 @@ public void writeThin(StreamOutput out) throws IOException {
         out.writeVInt(bytes.length());
     }
 
+    /**
+     * Writes the data in a "thin" manner, without the actual bytes, assumes
+     * the actual bytes will be appended right after this content.
+     */
+    public void writeThinProtobuf(CodedOutputStream out) throws IOException {
+        super.writeTo(out);
+        out.writeInt32NoTag(bytes.length());
+    }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         super.writeTo(out);
diff --git a/server/src/main/java/org/opensearch/transport/ClusterConnectionManager.java b/server/src/main/java/org/opensearch/transport/ClusterConnectionManager.java
index a392ea78f6c0b..aa973a348811a 100644
--- a/server/src/main/java/org/opensearch/transport/ClusterConnectionManager.java
+++ b/server/src/main/java/org/opensearch/transport/ClusterConnectionManager.java
@@ -122,7 +122,7 @@ public void connectToNode(
         ConnectionValidator connectionValidator,
         ActionListener<Void> listener
     ) throws ConnectTransportException {
-        System.out.println("Connecting to node");
+        // System.out.println("Connecting to node");
         ConnectionProfile resolvedProfile = ConnectionProfile.resolveConnectionProfile(connectionProfile, defaultProfile);
         if (node == null) {
             listener.onFailure(new ConnectTransportException(null, "can't connect to a null node"));
diff --git a/server/src/main/java/org/opensearch/transport/Header.java b/server/src/main/java/org/opensearch/transport/Header.java
index ba4a8cfef5534..a8fac66be21d8 100644
--- a/server/src/main/java/org/opensearch/transport/Header.java
+++ b/server/src/main/java/org/opensearch/transport/Header.java
@@ -34,9 +34,12 @@
 
 import org.opensearch.Version;
 import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.util.concurrent.ThreadContext;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.Collections;
@@ -122,6 +125,7 @@ Tuple<Map<String, String>, Map<String, Set<String>>> getHeaders() {
     }
 
     void finishParsingHeader(StreamInput input) throws IOException {
+        System.out.println("finishParsingHeader");
         this.headers = ThreadContext.readHeadersFromStream(input);
 
         if (isRequest()) {
@@ -137,6 +141,24 @@ void finishParsingHeader(StreamInput input) throws IOException {
         }
     }
 
+    void finishParsingHeaderProtobuf(CodedInputStream input) throws IOException {
+        System.out.println("finishParsingHeaderProtobuf");
+        this.headers = ThreadContext.readHeadersFromStreamProtobuf(input);
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(input);
+
+        if (isRequest()) {
+            final String[] featuresFound = protobufStreamInput.readStringArray();
+            if (featuresFound.length == 0) {
+                features = Collections.emptySet();
+            } else {
+                features = Collections.unmodifiableSet(new TreeSet<>(Arrays.asList(featuresFound)));
+            }
+            this.actionName = input.readString();
+        } else {
+            this.actionName = RESPONSE_NAME;
+        }
+    }
+
     @Override
     public String toString() {
         return "Header{"
diff --git a/server/src/main/java/org/opensearch/transport/InboundAggregator.java b/server/src/main/java/org/opensearch/transport/InboundAggregator.java
index 060ccec3563e2..8ff6e05677de6 100644
--- a/server/src/main/java/org/opensearch/transport/InboundAggregator.java
+++ b/server/src/main/java/org/opensearch/transport/InboundAggregator.java
@@ -114,6 +114,7 @@ public void aggregate(ReleasableBytesReference content) {
     }
 
     public InboundMessage finishAggregation() throws IOException {
+        System.out.println("InboundAggregator.finishAggregation");
         ensureOpen();
         final ReleasableBytesReference releasableContent;
         if (isFirstContent()) {
diff --git a/server/src/main/java/org/opensearch/transport/InboundDecoder.java b/server/src/main/java/org/opensearch/transport/InboundDecoder.java
index 0dd39ed73d787..052cbc79aa139 100644
--- a/server/src/main/java/org/opensearch/transport/InboundDecoder.java
+++ b/server/src/main/java/org/opensearch/transport/InboundDecoder.java
@@ -40,6 +40,8 @@
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.common.lease.Releasable;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.function.Consumer;
 
@@ -80,6 +82,7 @@ public int decode(ReleasableBytesReference reference, Consumer<Object> fragmentC
     public int internalDecode(ReleasableBytesReference reference, Consumer<Object> fragmentConsumer) throws IOException {
         if (isOnHeader()) {
             int messageLength = TcpTransport.readMessageLength(reference);
+            System.out.println("Message length: " + messageLength);
             if (messageLength == -1) {
                 return 0;
             } else if (messageLength == 0) {
@@ -93,6 +96,14 @@ public int internalDecode(ReleasableBytesReference reference, Consumer<Object> f
                     totalNetworkSize = messageLength + TcpHeader.BYTES_REQUIRED_FOR_MESSAGE_SIZE;
 
                     Header header = readHeader(version, messageLength, reference);
+                    System.out.println("InboundDecoder.internalDecode: header = " + header);
+                    System.out.println("InboundDecoder.internalDecode: header.getNetworkMessageSize() = " + header.getNetworkMessageSize());
+                    System.out.println("InboundDecoder.internalDecode: header.getActionName() = " + header.getActionName());
+                    // if (header.getNetworkMessageSize() == 108 && header.getActionName().equals("cluster:monitor/state")) {
+                    //     System.out.println("Coming in the if condition finally");
+                    //     header = readHeaderProtobuf(version, messageLength, reference);
+                    // }
+                    System.out.println("InboundDecoder.internalDecode after protobuf: header = " + header);
                     bytesConsumed += headerBytesToRead;
                     if (header.isCompressed()) {
                         decompressor = new TransportDecompressor(recycler);
@@ -204,6 +215,31 @@ static Header readHeader(Version version, int networkMessageSize, BytesReference
         }
     }
 
+    static Header readHeaderProtobuf(Version version, int networkMessageSize, BytesReference bytesReference) throws IOException {
+        System.out.println("Reading header protobuf");
+        System.out.println("Bytes reference:" + bytesReference.toString());
+        CodedInputStream streamInput = bytesReference.protobufInput();
+
+        streamInput.skipRawBytes(TcpHeader.BYTES_REQUIRED_FOR_MESSAGE_SIZE);
+        long requestId = streamInput.readInt64();
+        System.out.println("Read request id:" + requestId);
+        byte status = streamInput.readRawByte();
+        System.out.println("Read status:" + status);
+        System.out.println("Read version:" + streamInput.readInt32());
+        Version remoteVersion = Version.fromId(streamInput.readInt32());
+        Header header = new Header(networkMessageSize, requestId, status, remoteVersion);
+        final IllegalStateException invalidVersion = ensureVersionCompatibility(remoteVersion, version, header.isHandshake());
+        if (invalidVersion != null) {
+            throw invalidVersion;
+        } else {
+            // Skip since we already have ensured enough data available
+            streamInput.readInt32();
+            header.finishParsingHeaderProtobuf(streamInput);
+        }
+        return header;
+        
+    }
+
     private boolean isOnHeader() {
         return totalNetworkSize == -1;
     }
diff --git a/server/src/main/java/org/opensearch/transport/InboundHandler.java b/server/src/main/java/org/opensearch/transport/InboundHandler.java
index 72fd20bf847a1..075936694873e 100644
--- a/server/src/main/java/org/opensearch/transport/InboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/InboundHandler.java
@@ -40,6 +40,7 @@
 import org.opensearch.core.common.io.stream.ByteBufferStreamInput;
 import org.opensearch.core.common.io.stream.NamedWriteableAwareStreamInput;
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
@@ -47,6 +48,8 @@
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.threadpool.ThreadPool;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.EOFException;
 import java.io.IOException;
 import java.net.InetSocketAddress;
@@ -68,6 +71,7 @@ public class InboundHandler {
     private final TransportKeepAlive keepAlive;
     private final Transport.ResponseHandlers responseHandlers;
     private final Transport.RequestHandlers requestHandlers;
+    private final Transport.ProtobufRequestHandlers protobufRequestHandlers;
 
     private volatile TransportMessageListener messageListener = TransportMessageListener.NOOP_LISTENER;
     // private volatile ProtobufTransportMessageListener protobufMessageListener = ProtobufTransportMessageListener.NOOP_LISTENER;
@@ -81,6 +85,7 @@ public class InboundHandler {
         TransportHandshaker handshaker,
         TransportKeepAlive keepAlive,
         Transport.RequestHandlers requestHandlers,
+        Transport.ProtobufRequestHandlers protobufRequestHandlers,
         Transport.ResponseHandlers responseHandlers
     ) {
         this.threadPool = threadPool;
@@ -89,6 +94,7 @@ public class InboundHandler {
         this.handshaker = handshaker;
         this.keepAlive = keepAlive;
         this.requestHandlers = requestHandlers;
+        this.protobufRequestHandlers = protobufRequestHandlers;
         this.responseHandlers = responseHandlers;
     }
 
@@ -113,6 +119,8 @@ void setSlowLogThreshold(TimeValue slowLogThreshold) {
     }
 
     void inboundMessage(TcpChannel channel, InboundMessage message) throws Exception {
+        System.out.println("InboundHandler.inboundMessage");
+        System.out.println("message: " + message);
         final long startTime = threadPool.relativeTimeInMillis();
         channel.getChannelStats().markAccessed(startTime);
         TransportLogger.logInboundMessage(channel, message);
@@ -127,9 +135,15 @@ void inboundMessage(TcpChannel channel, InboundMessage message) throws Exception
     // Empty stream constant to avoid instantiating a new stream for empty messages.
     private static final StreamInput EMPTY_STREAM_INPUT = new ByteBufferStreamInput(ByteBuffer.wrap(BytesRef.EMPTY_BYTES));
 
+    private static final CodedInputStream EMPTY_CODED_INPUT_STREAM = CodedInputStream.newInstance(BytesRef.EMPTY_BYTES);
+
     private void messageReceived(TcpChannel channel, InboundMessage message, long startTime) throws IOException {
+        System.out.println("InboundHandler.messageReceived");
         final InetSocketAddress remoteAddress = channel.getRemoteAddress();
         final Header header = message.getHeader();
+        System.out.println("header: " + header);
+        System.out.println("message: " + message);
+        System.out.println("remoteAddress: " + remoteAddress);
         assert header.needsToReadVariableHeader() == false;
 
         ThreadContext threadContext = threadPool.getThreadContext();
@@ -142,6 +156,7 @@ private void messageReceived(TcpChannel channel, InboundMessage message, long st
                 System.out.println("Header: " + header);
                 handleRequest(channel, header, message);
             } else {
+                System.out.println("InboundHandler.messageReceived isResponse else");
                 // Responses do not support short circuiting currently
                 assert message.isShortCircuit() == false;
                 final TransportResponseHandler<?> handler;
@@ -158,21 +173,51 @@ private void messageReceived(TcpChannel channel, InboundMessage message, long st
                     } else {
                         handler = theHandler;
                     }
+                    System.out.println("Found the handler: " + handler);
                 }
                 // ignore if its null, the service logs it
                 if (handler != null) {
-                    final StreamInput streamInput;
-                    if (message.getContentLength() > 0 || header.getVersion().equals(Version.CURRENT) == false) {
-                        streamInput = namedWriteableStream(message.openOrGetStreamInput());
-                        assertRemoteVersion(streamInput, header.getVersion());
-                        if (header.isError()) {
-                            handlerResponseError(requestId, streamInput, handler);
+                    System.out.println("Handler for the response is: " + handler);
+                    System.out.println("Handler for the response is: " + handler.toString());
+                    System.out.println("Teh final message is: " + message);
+                    if (handler.toString().contains("Protobuf")) {
+                        System.out.println("Trying protobuf");
+                        System.out.println("finale message inside protobuf is: " + message);
+                        System.out.println("finale message inside protobuf is: " + message.getContentLength());
+                        final CodedInputStream streamInput;
+                        if (message.getContentLength() > 0 || header.getVersion().equals(Version.CURRENT) == false) {
+                            System.out.println("Message content length is greater than 0 or header version is not current");
+                            streamInput = message.openOrGetProtobufCodedInput();
+                            System.out.println("Protobuf input is: " + streamInput);
+                            // assertRemoteVersion(streamInput, header.getVersion());
+                            if (header.isError()) {
+                                handlerResponseErrorProtobuf(requestId, streamInput, handler);
+                            } else {
+                                handleResponseProtobuf(requestId, remoteAddress, streamInput, handler);
+                            }
                         } else {
-                            handleResponse(requestId, remoteAddress, streamInput, handler);
+                            System.out.println("Protobuf else condition");
+                            assert header.isError() == false;
+                            handleResponseProtobuf(requestId, remoteAddress, EMPTY_CODED_INPUT_STREAM, handler);
                         }
                     } else {
-                        assert header.isError() == false;
-                        handleResponse(requestId, remoteAddress, EMPTY_STREAM_INPUT, handler);
+                        final StreamInput streamInput;
+                        System.out.println("Trying stream");
+                        if (message.getContentLength() > 0 || header.getVersion().equals(Version.CURRENT) == false) {
+                            System.out.println("if condition");
+                            streamInput = namedWriteableStream(message.openOrGetStreamInput());
+                            System.out.println("Stream input is: " + streamInput);
+                            assertRemoteVersion(streamInput, header.getVersion());
+                            if (header.isError()) {
+                                handlerResponseError(requestId, streamInput, handler);
+                            } else {
+                                handleResponse(requestId, remoteAddress, streamInput, handler);
+                            }
+                        } else {
+                            System.out.println("else condition");
+                            assert header.isError() == false;
+                            handleResponse(requestId, remoteAddress, EMPTY_STREAM_INPUT, handler);
+                        }
                     }
                 }
             }
@@ -194,7 +239,14 @@ private <T extends TransportRequest> void handleRequest(TcpChannel channel, Head
         final String action = header.getActionName();
         final long requestId = header.getRequestId();
         final Version version = header.getVersion();
+        System.out.println("InboundHandler.handleRequest");
+        System.out.println("Header: " + header);
+        System.out.println("Action: " + action);
+        System.out.println("RequestId: " + requestId);
+        System.out.println("Version: " + version);
+        System.out.println("Message: " + message);
         if (header.isHandshake()) {
+            System.out.println("InboundHandler.handleRequest isHandshake");
             messageListener.onRequestReceived(requestId, action);
             // Cannot short circuit handshakes
             assert message.isShortCircuit() == false;
@@ -229,6 +281,7 @@ private <T extends TransportRequest> void handleRequest(TcpChannel channel, Head
                 }
             }
         } else {
+            System.out.println("InboundHandler.handleRequest else isNotHandshake");
             final TransportChannel transportChannel = new TcpTransportChannel(
                 outboundHandler,
                 channel,
@@ -245,24 +298,50 @@ private <T extends TransportRequest> void handleRequest(TcpChannel channel, Head
                 if (message.isShortCircuit()) {
                     sendErrorResponse(action, transportChannel, message.getException());
                 } else {
-                    final StreamInput stream = namedWriteableStream(message.openOrGetStreamInput());
-                    assertRemoteVersion(stream, header.getVersion());
-                    final RequestHandlerRegistry<T> reg = requestHandlers.getHandler(action);
-                    assert reg != null;
-
-                    final T request = newRequest(requestId, action, stream, reg);
-                    request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
-                    checkStreamIsFullyConsumed(requestId, action, stream);
-
-                    final String executor = reg.getExecutor();
-                    if (ThreadPool.Names.SAME.equals(executor)) {
-                        try {
-                            reg.processMessageReceived(request, transportChannel);
-                        } catch (Exception e) {
-                            sendErrorResponse(reg.getAction(), transportChannel, e);
+                    try {
+                        final StreamInput stream = namedWriteableStream(message.openOrGetStreamInput());
+                        assertRemoteVersion(stream, header.getVersion());
+                        final RequestHandlerRegistry<T> reg = requestHandlers.getHandler(action);
+                        assert reg != null;
+
+                        final T request = newRequest(requestId, action, stream, reg);
+                        request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
+                        checkStreamIsFullyConsumed(requestId, action, stream);
+
+                        System.out.println("Deserialized request: " + request);
+                        final String executor = reg.getExecutor();
+                        if (ThreadPool.Names.SAME.equals(executor)) {
+                            try {
+                                reg.processMessageReceived(request, transportChannel);
+                            } catch (Exception e) {
+                                sendErrorResponse(reg.getAction(), transportChannel, e);
+                            }
+                        } else {
+                            threadPool.executor(executor).execute(new RequestHandler<>(reg, request, transportChannel));
+                        }
+                    } catch (Exception e) {
+                        System.out.println("Coming in here to try protobuf");
+                        final CodedInputStream stream = message.openOrGetProtobufCodedInput();
+                        // final StreamInput stream = namedWriteableStream(message.openOrGetStreamInput());
+                        // assertRemoteVersion(stream, header.getVersion());
+                        final ProtobufRequestHandlerRegistry<T> reg = protobufRequestHandlers.getHandler(action);
+                        assert reg != null;
+
+                        final T request = newRequestProtobuf(requestId, action, stream, reg);
+                        request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
+                        // checkStreamIsFullyConsumed(requestId, action, stream);
+
+                        System.out.println("Deserialized request: " + request);
+                        final String executor = reg.getExecutor();
+                        if (ThreadPool.Names.SAME.equals(executor)) {
+                            try {
+                                reg.processMessageReceived(request, transportChannel);
+                            } catch (Exception exp) {
+                                sendErrorResponse(reg.getAction(), transportChannel, exp);
+                            }
+                        } else {
+                            // threadPool.executor(executor).execute(new RequestHandler<>(reg, request, transportChannel));
                         }
-                    } else {
-                        threadPool.executor(executor).execute(new RequestHandler<>(reg, request, transportChannel));
                     }
                 }
             } catch (Exception e) {
@@ -305,6 +384,28 @@ private <T extends TransportRequest> T newRequest(
         }
     }
 
+    private <T extends TransportRequest> T newRequestProtobuf(
+        final long requestId,
+        final String action,
+        final CodedInputStream stream,
+        final ProtobufRequestHandlerRegistry<T> reg
+    ) throws IOException {
+        try {
+            return reg.newRequest(stream);
+        } catch (final EOFException e) {
+            // Another favor of (de)serialization issues is when stream contains less bytes than
+            // the request handler needs to deserialize the payload.
+            throw new IllegalStateException(
+                "Message fully read (request) but more data is expected for requestId ["
+                    + requestId
+                    + "], action ["
+                    + action
+                    + "]; resetting",
+                e
+            );
+        }
+    }
+
     /**
      * Checks if the stream is fully consumed and throws the exceptions if that is not the case.
      * @param requestId request identifier
@@ -377,6 +478,7 @@ private <T extends TransportResponse> void handleResponse(
         final StreamInput stream,
         final TransportResponseHandler<T> handler
     ) {
+        System.out.println("handleResponse");
         final T response;
         try {
             response = handler.read(stream);
@@ -399,6 +501,37 @@ private <T extends TransportResponse> void handleResponse(
         }
     }
 
+    private <T extends TransportResponse> void handleResponseProtobuf(
+        final long requestId,
+        InetSocketAddress remoteAddress,
+        final CodedInputStream stream,
+        final TransportResponseHandler<T> handler
+    ) throws IOException {
+        System.out.println("handleResponseProtobuf");
+        System.out.println("seeing if the stream has something");
+        System.out.println(stream.readTag());
+        final T response;
+        try {
+            response = handler.read(stream);
+            response.remoteAddress(new TransportAddress(remoteAddress));
+            // checkStreamIsFullyConsumed(requestId, handler, stream, false);
+        } catch (Exception e) {
+            final Exception serializationException = new TransportSerializationException(
+                "Failed to deserialize response from handler [" + handler + "]",
+                e
+            );
+            logger.warn(new ParameterizedMessage("Failed to deserialize response from [{}]", remoteAddress), serializationException);
+            handleException(handler, serializationException);
+            return;
+        }
+        final String executor = handler.executor();
+        if (ThreadPool.Names.SAME.equals(executor)) {
+            doHandleResponse(handler, response);
+        } else {
+            threadPool.executor(executor).execute(() -> doHandleResponse(handler, response));
+        }
+    }
+
     private <T extends TransportResponse> void doHandleResponse(TransportResponseHandler<T> handler, T response) {
         try {
             handler.handleResponse(response);
@@ -421,6 +554,21 @@ private void handlerResponseError(final long requestId, StreamInput stream, fina
         handleException(handler, error);
     }
 
+    private void handlerResponseErrorProtobuf(final long requestId, CodedInputStream stream, final TransportResponseHandler<?> handler) {
+        Exception error;
+        try {
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(stream);
+            error = protobufStreamInput.readException();
+            // checkStreamIsFullyConsumed(requestId, handler, stream, true);
+        } catch (Exception e) {
+            error = new TransportSerializationException(
+                "Failed to deserialize exception response from stream for handler [" + handler + "]",
+                e
+            );
+        }
+        handleException(handler, error);
+    }
+
     private void handleException(final TransportResponseHandler<?> handler, Throwable error) {
         if (!(error instanceof RemoteTransportException)) {
             error = new RemoteTransportException(error.getMessage(), error);
diff --git a/server/src/main/java/org/opensearch/transport/InboundMessage.java b/server/src/main/java/org/opensearch/transport/InboundMessage.java
index e19e5b45025aa..1106393a4cb1c 100644
--- a/server/src/main/java/org/opensearch/transport/InboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/InboundMessage.java
@@ -33,11 +33,14 @@
 package org.opensearch.transport;
 
 import org.opensearch.common.bytes.ReleasableBytesReference;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.lease.Releasables;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 
 /**
@@ -53,6 +56,7 @@ public class InboundMessage implements Releasable {
     private final boolean isPing;
     private Releasable breakerRelease;
     private StreamInput streamInput;
+    private CodedInputStream codedInputStream;
 
     public InboundMessage(Header header, ReleasableBytesReference content, Releasable breakerRelease) {
         this.header = header;
@@ -84,8 +88,10 @@ public Header getHeader() {
 
     public int getContentLength() {
         if (content == null) {
+            System.out.println("InboundMessage.getContentLength content is null");
             return 0;
         } else {
+            System.out.println("InboundMessage.getContentLength content is not null: " + content.length());
             return content.length();
         }
     }
@@ -115,12 +121,25 @@ public Releasable takeBreakerReleaseControl() {
     public StreamInput openOrGetStreamInput() throws IOException {
         assert isPing == false && content != null;
         if (streamInput == null) {
+            System.out.println("InboundMessage.openOrGetStreamInput");
             streamInput = content.streamInput();
             streamInput.setVersion(header.getVersion());
         }
         return streamInput;
     }
 
+    public CodedInputStream openOrGetProtobufCodedInput() throws IOException {
+        assert isPing == false && content != null;
+        if (codedInputStream == null) {
+            System.out.println("InboundMessage.openOrGetProtobufCodedInput");
+            streamInput = content.streamInput();
+            codedInputStream = CodedInputStream.newInstance(streamInput);
+            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(codedInputStream);
+            protobufStreamInput.setVersion(header.getVersion());
+        }
+        return codedInputStream;
+    }
+
     @Override
     public void close() {
         IOUtils.closeWhileHandlingException(streamInput);
diff --git a/server/src/main/java/org/opensearch/transport/InboundPipeline.java b/server/src/main/java/org/opensearch/transport/InboundPipeline.java
index 9103692e358e4..7e5d72d3521c0 100644
--- a/server/src/main/java/org/opensearch/transport/InboundPipeline.java
+++ b/server/src/main/java/org/opensearch/transport/InboundPipeline.java
@@ -108,6 +108,13 @@ public void close() {
     }
 
     public void handleBytes(TcpChannel channel, ReleasableBytesReference reference) throws IOException {
+        System.out.println("Handle bytes in InboundPipeline");
+        System.out.println("Incoming bytes length: " + reference.length());
+        System.out.println("Now the incoming bytes: ");
+        for (int i = 0; i < reference.length(); i++) {
+            System.out.print(reference.get(i) + " ");
+        }
+        System.out.println();
         if (uncaughtException != null) {
             throw new IllegalStateException("Pipeline state corrupted by uncaught exception", uncaughtException);
         }
diff --git a/server/src/main/java/org/opensearch/transport/OutboundHandler.java b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
index 2160f6546c511..1f02eedba9f0f 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
@@ -46,12 +46,16 @@
 import org.opensearch.common.transport.NetworkExceptionHelper;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.util.BigArrays;
+import org.opensearch.common.util.ByteArray;
+import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.lease.Releasables;
 import org.opensearch.threadpool.ThreadPool;
 
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.Set;
 
@@ -125,8 +129,31 @@ void sendRequest(
             isHandshake,
             compressRequest
         );
+        ProtobufOutboundMessage.Request protobufMessage = new ProtobufOutboundMessage.Request(
+            threadPool.getThreadContext(),
+            features,
+            request,
+            version,
+            action,
+            requestId,
+            isHandshake,
+            compressRequest
+        );
+
+        System.out.println("OutboundHandler.sendRequest");
+        System.out.println("node: " + node);
+        System.out.println("channel: " + channel);
+        System.out.println("requestId: " + requestId);
+        System.out.println("action: " + action);
+        System.out.println("request: " + request.toString());
+        System.out.println("canonical: " + request.getClass().getCanonicalName());
+        System.out.println("message: " + message);
         ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onRequestSent(node, requestId, action, request, options));
-        sendMessage(channel, message, listener);
+        // if (request.getClass().getCanonicalName().contains("Protobuf")) {
+        //     sendMessageProtobuf(channel, protobufMessage, listener);
+        // } else {
+            sendMessage(channel, message, listener);
+        // }   
     }
 
     /**
@@ -155,6 +182,10 @@ void sendResponse(
             isHandshake,
             compress
         );
+        System.out.println("OutboundHandler.sendResponse");
+        System.out.println("action: " + action);
+        System.out.println("response: " + response);
+        System.out.println("canonical: " + response.getClass().getCanonicalName());
         ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onResponseSent(requestId, action, response));
         sendMessage(channel, message, listener);
     }
@@ -187,14 +218,29 @@ void sendErrorResponse(
     }
 
     private void sendMessage(TcpChannel channel, OutboundMessage networkMessage, ActionListener<Void> listener) throws IOException {
+        System.out.println("OutboundHandler.sendMessage");
+        System.out.println("OutboundHandler.sendMessage networkMessage = " + networkMessage);
         MessageSerializer serializer = new MessageSerializer(networkMessage, bigArrays);
         SendContext sendContext = new SendContext(channel, serializer, listener, serializer);
         internalSend(channel, sendContext);
     }
 
+    private void sendMessageProtobuf(TcpChannel channel, ProtobufOutboundMessage networkMessage, ActionListener<Void> listener) throws IOException {
+        System.out.println("OutboundHandler.sendMessageProtobuf");
+        System.out.println("OutboundHandler.sendMessageProtobuf networkMessage = " + networkMessage);
+        MessageSerializerProtobuf serializer = new MessageSerializerProtobuf(networkMessage, bigArrays);
+        SendContext sendContext = new SendContext(channel, serializer, listener, serializer);
+        System.out.println("attempting internal send for protobuf ");
+        internalSend(channel, sendContext);
+    }
+
     private void internalSend(TcpChannel channel, SendContext sendContext) throws IOException {
+        System.out.println("In internal send");
+        System.out.println("channel: " + channel);
+        System.out.println("sendContext: " + sendContext);
         channel.getChannelStats().markAccessed(threadPool.relativeTimeInMillis());
         BytesReference reference = sendContext.get();
+        System.out.println("reference: " + reference);
         // stash thread context so that channel event loop is not polluted by thread context
         try (ThreadContext.StoredContext existing = threadPool.getThreadContext().stashContext()) {
             channel.sendMessage(reference, sendContext);
@@ -239,6 +285,36 @@ private MessageSerializer(OutboundMessage message, BigArrays bigArrays) {
 
         @Override
         public BytesReference get() throws IOException {
+            System.out.println("OutboundHandler.MessageSerializer.get");
+            bytesStreamOutput = new ReleasableBytesStreamOutput(bigArrays);
+            return message.serialize(bytesStreamOutput);
+        }
+
+        @Override
+        public void close() {
+            IOUtils.closeWhileHandlingException(bytesStreamOutput);
+        }
+    }
+
+    /**
+     * Internal message serializer
+     *
+     * @opensearch.internal
+     */
+    private static class MessageSerializerProtobuf implements CheckedSupplier<BytesReference, IOException>, Releasable {
+
+        private final ProtobufOutboundMessage message;
+        private final BigArrays bigArrays;
+        private volatile ReleasableBytesStreamOutput bytesStreamOutput;
+
+        private MessageSerializerProtobuf(ProtobufOutboundMessage message, BigArrays bigArrays) {
+            this.message = message;
+            this.bigArrays = bigArrays;
+        }
+
+        @Override
+        public BytesReference get() throws IOException {
+            System.out.println("OutboundHandler.MessageSerializer.get");
             bytesStreamOutput = new ReleasableBytesStreamOutput(bigArrays);
             return message.serialize(bytesStreamOutput);
         }
diff --git a/server/src/main/java/org/opensearch/transport/OutboundMessage.java b/server/src/main/java/org/opensearch/transport/OutboundMessage.java
index d969351425acd..83b6ca40810fd 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundMessage.java
@@ -58,6 +58,7 @@ abstract class OutboundMessage extends NetworkMessage {
     }
 
     BytesReference serialize(BytesStreamOutput bytesStream) throws IOException {
+        System.out.println("Inside OutboundMessage.serialize");
         bytesStream.setVersion(version);
         bytesStream.skip(TcpHeader.headerSize(version));
 
@@ -81,6 +82,13 @@ BytesReference serialize(BytesStreamOutput bytesStream) throws IOException {
         bytesStream.seek(0);
         final int contentSize = reference.length() - TcpHeader.headerSize(version);
         TcpHeader.writeHeader(bytesStream, requestId, status, version, contentSize, variableHeaderLength);
+        System.out.println("Bytes serialized length: " + reference.length());
+        System.out.println("Bytes serialized: " + reference);
+        System.out.println("Now the bytes: ");
+        for (int i = 0; i < reference.length(); i++) {
+            System.out.print(reference.get(i) + " ");
+        }
+        System.out.println();
         return reference;
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java b/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
index a2f5fb571a1f8..3704659f9bd30 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
@@ -12,10 +12,12 @@
 import org.opensearch.Version;
 import org.opensearch.common.bytes.BytesArray;
 import org.opensearch.common.bytes.BytesReference;
+import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.util.concurrent.ThreadContext;
 
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.Set;
@@ -34,17 +36,19 @@ abstract class ProtobufOutboundMessage extends ProtobufNetworkMessage {
         this.message = message;
     }
 
-    BytesReference serialize(CodedOutputStream out, byte[] bytes) throws IOException {
+    BytesReference serialize(BytesStreamOutput bytesStream) throws IOException {
+        System.out.println("Inside ProtobufOutboundMessage.serialize");
+        CodedOutputStream out = CodedOutputStream.newInstance(bytesStream);
         ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         protobufStreamOutput.setVersion(version);
-        // bytesStream.skip(TcpHeader.headerSize(version));
+        int headerLength = TcpHeader.headerSize(version);
 
         // The compressible bytes stream will not close the underlying bytes stream
         BytesReference reference;
         int variableHeaderLength = -1;
-        // final long preHeaderPosition = out.position();
+        // final long preHeaderPosition = out.();
         writeVariableHeader(out);
-        // variableHeaderLength = Math.toIntExact(out.position() - preHeaderPosition);
+        variableHeaderLength = Math.toIntExact(out.getTotalBytesWritten() - headerLength);
 
         if (TransportStatus.isCompress(status)) {
             protobufStreamOutput.setVersion(version);
@@ -55,9 +59,12 @@ BytesReference serialize(CodedOutputStream out, byte[] bytes) throws IOException
         // stream.setFeatures(out.getFeatures());
 
         // if (variableHeaderLength == -1) {
-        // writeVariableHeader(stream);
+        //     writeVariableHeader(out);
         // }
-        reference = writeMessage(out, bytes);
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); 
+        byteArrayOutputStream.writeTo(bytesStream); 
+        
+        reference = writeMessage(out, byteArrayOutputStream.toByteArray());
         // }
 
         // out.seek(0);
@@ -72,12 +79,13 @@ protected void writeVariableHeader(CodedOutputStream stream) throws IOException
 
     protected BytesReference writeMessage(CodedOutputStream stream, byte[] bytes) throws IOException {
         final BytesReference zeroCopyBuffer;
-        if (message instanceof ProtobufBytesTransportRequest) {
-            ProtobufBytesTransportRequest bRequest = (ProtobufBytesTransportRequest) message;
-            bRequest.writeThin(stream);
+        if (message instanceof BytesTransportRequest) {
+            BytesTransportRequest bRequest = (BytesTransportRequest) message;
+            bRequest.writeThinProtobuf(stream);
             zeroCopyBuffer = bRequest.bytes;
         } else if (message instanceof ProtobufRemoteTransportException) {
-            // stream.writeStringNoTag((ProtobufRemoteTransportException) message.toString());
+            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(stream);
+            protobufStreamOutput.writeException((ProtobufRemoteTransportException) message);
             zeroCopyBuffer = BytesArray.EMPTY;
         } else {
             message.writeTo(stream);
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
index 06c6d7886a955..f197e8405db89 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
@@ -61,6 +61,7 @@ public Request newRequest(CodedInputStream in) throws IOException {
     }
 
     public void processMessageReceived(Request request, TransportChannel channel) throws Exception {
+        System.out.println("ProtobufRequestHandlerRegistry.processMessageReceived");
         final ProtobufTask task = taskManager.registerProtobuf(channel.getChannelType(), action, request);
         ThreadContext.StoredContext contextToRestore = taskManager.protobufTaskExecutionStarted(task);
 
diff --git a/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java b/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java
index 88d37e101f846..50abf21f542e8 100644
--- a/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java
+++ b/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java
@@ -164,7 +164,7 @@ public void closeNoBlock() {
     }
 
     private synchronized void addConnectedNode(DiscoveryNode addedNode) {
-        System.out.println("RemoteConnectionManager.addConnectedNode");
+        // System.out.println("RemoteConnectionManager.addConnectedNode");
         ArrayList<DiscoveryNode> newConnections = new ArrayList<>(this.connectedNodes);
         newConnections.add(addedNode);
         this.connectedNodes = Collections.unmodifiableList(newConnections);
diff --git a/server/src/main/java/org/opensearch/transport/TcpTransport.java b/server/src/main/java/org/opensearch/transport/TcpTransport.java
index 9d853b179910f..162f917eabbc5 100644
--- a/server/src/main/java/org/opensearch/transport/TcpTransport.java
+++ b/server/src/main/java/org/opensearch/transport/TcpTransport.java
@@ -215,6 +215,7 @@ public TcpTransport(
             handshaker,
             keepAlive,
             requestHandlers,
+            protobufRequestHandlers,
             responseHandlers
         );
     }
@@ -317,11 +318,13 @@ public DiscoveryNode getNode() {
         @Override
         public void sendRequest(long requestId, String action, TransportRequest request, TransportRequestOptions options)
             throws IOException, TransportException {
+            System.out.println("Sending request from NodeChannels");
             if (isClosing.get()) {
                 throw new NodeNotConnectedException(node, "connection already closed");
             }
             TcpChannel channel = channel(options.type());
             outboundHandler.sendRequest(node, channel, requestId, action, request, options, getVersion(), compress, false);
+            System.out.println("Done with send request");
         }
 
         // @Override
diff --git a/server/src/main/java/org/opensearch/transport/TransportService.java b/server/src/main/java/org/opensearch/transport/TransportService.java
index 31c2b2e4d32ed..b1da4fec40866 100644
--- a/server/src/main/java/org/opensearch/transport/TransportService.java
+++ b/server/src/main/java/org/opensearch/transport/TransportService.java
@@ -1332,6 +1332,7 @@ private <T extends TransportResponse> void sendRequestInternal(
         final TransportRequestOptions options,
         TransportResponseHandler<T> handler
     ) {
+        System.out.println("Sending internal request from transport service");
         if (connection == null) {
             throw new IllegalStateException("can't send request to a null connection");
         }
@@ -1360,6 +1361,7 @@ private <T extends TransportResponse> void sendRequestInternal(
                 assert options.timeout() != null;
                 timeoutHandler.scheduleTimeout(options.timeout());
             }
+            System.out.println("Before sending request to TcpTransport NodeChannels");
             connection.sendRequest(requestId, action, request, options); // local node optimization happens upstream
         } catch (final Exception e) {
             // usually happen either because we failed to connect to the node

From e96f3e0da7acd1d6aa9e03225c3c793c1aa93347 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Mon, 17 Jul 2023 19:57:04 +0000
Subject: [PATCH 17/37] Debugging and fixing compile errors

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../state/ProtobufClusterStateRequest.java    |   1 +
 .../opensearch/transport/InboundHandler.java  |   9 +-
 .../opensearch/transport/OutboundHandler.java |  44 +++-
 .../opensearch/transport/OutboundMessage.java |  36 ++++
 .../transport/ProtobufNetworkMessage.java     |   2 +-
 .../transport/ProtobufOutboundMessage.java    | 201 ++++++++++++------
 ...tAddVotingConfigExclusionsActionTests.java |  16 ++
 ...learVotingConfigExclusionsActionTests.java |  16 ++
 ...ReplicationAllPermitsAcquisitionTests.java |  17 ++
 .../cluster/NodeConnectionsServiceTests.java  | 120 +++++------
 .../coordination/CoordinatorTests.java        |  10 +-
 .../coordination/FollowersCheckerTests.java   |  52 +++++
 .../coordination/LeaderCheckerTests.java      |  16 ++
 .../coordination/PreVoteCollectorTests.java   |  16 ++
 .../cluster/serialization/DiffableTests.java  |  10 +-
 .../opensearch/discovery/PeerFinderTests.java |  16 ++
 .../SegmentReplicationSourceServiceTests.java |  27 +++
 .../transport/InboundHandlerTests.java        |  65 ++++++
 .../transport/OutboundHandlerTests.java       |  68 ++++++
 .../transport/TransportActionProxyTests.java  |  27 +++
 ...ortServiceDeserializationFailureTests.java |  28 +++
 .../DisruptableMockTransportTests.java        |  40 ++++
 .../test/disruption/NetworkDisruptionIT.java  |  15 ++
 23 files changed, 725 insertions(+), 127 deletions(-)

diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
index dce59990218ae..c6271e403c812 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
@@ -37,6 +37,7 @@ public class ProtobufClusterStateRequest extends ProtobufClusterManagerNodeReadR
 
     public static final TimeValue DEFAULT_WAIT_FOR_NODE_TIMEOUT = TimeValue.timeValueMinutes(1);
 
+    // private PRotoClusterSatteRq clusterStateRequest;
     private boolean routingTable = true;
     private boolean nodes = true;
     private boolean metadata = true;
diff --git a/server/src/main/java/org/opensearch/transport/InboundHandler.java b/server/src/main/java/org/opensearch/transport/InboundHandler.java
index 075936694873e..090816285b47f 100644
--- a/server/src/main/java/org/opensearch/transport/InboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/InboundHandler.java
@@ -187,7 +187,8 @@ private void messageReceived(TcpChannel channel, InboundMessage message, long st
                         final CodedInputStream streamInput;
                         if (message.getContentLength() > 0 || header.getVersion().equals(Version.CURRENT) == false) {
                             System.out.println("Message content length is greater than 0 or header version is not current");
-                            streamInput = message.openOrGetProtobufCodedInput();
+                            StreamInput streamInput1 = namedWriteableStream(message.openOrGetStreamInput());
+                            streamInput = CodedInputStream.newInstance(streamInput1);
                             System.out.println("Protobuf input is: " + streamInput);
                             // assertRemoteVersion(streamInput, header.getVersion());
                             if (header.isError()) {
@@ -321,13 +322,15 @@ private <T extends TransportRequest> void handleRequest(TcpChannel channel, Head
                         }
                     } catch (Exception e) {
                         System.out.println("Coming in here to try protobuf");
-                        final CodedInputStream stream = message.openOrGetProtobufCodedInput();
+                        // final CodedInputStream stream = message.openOrGetProtobufCodedInput();
                         // final StreamInput stream = namedWriteableStream(message.openOrGetStreamInput());
                         // assertRemoteVersion(stream, header.getVersion());
+                        final StreamInput stream = namedWriteableStream(message.openOrGetStreamInput());
+                        CodedInputStream codedInputStream = CodedInputStream.newInstance(stream);
                         final ProtobufRequestHandlerRegistry<T> reg = protobufRequestHandlers.getHandler(action);
                         assert reg != null;
 
-                        final T request = newRequestProtobuf(requestId, action, stream, reg);
+                        final T request = newRequestProtobuf(requestId, action, codedInputStream, reg);
                         request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
                         // checkStreamIsFullyConsumed(requestId, action, stream);
 
diff --git a/server/src/main/java/org/opensearch/transport/OutboundHandler.java b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
index 1f02eedba9f0f..4645e61bccdba 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
@@ -149,10 +149,15 @@ void sendRequest(
         System.out.println("canonical: " + request.getClass().getCanonicalName());
         System.out.println("message: " + message);
         ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onRequestSent(node, requestId, action, request, options));
+        if (request.getClass().getCanonicalName().contains("ClusterState") && request.getClass().getCanonicalName().contains("Protobuf")) {
+            sendMessageProtobuf(channel, protobufMessage, listener);
+        } else {
+            sendMessage(channel, message, listener);
+        }
         // if (request.getClass().getCanonicalName().contains("Protobuf")) {
         //     sendMessageProtobuf(channel, protobufMessage, listener);
         // } else {
-            sendMessage(channel, message, listener);
+            // sendMessage(channel, message, listener);
         // }   
     }
 
@@ -225,6 +230,14 @@ private void sendMessage(TcpChannel channel, OutboundMessage networkMessage, Act
         internalSend(channel, sendContext);
     }
 
+    private void sendMessage1(TcpChannel channel, OutboundMessage networkMessage, ActionListener<Void> listener) throws IOException {
+        System.out.println("OutboundHandler.sendMessage");
+        System.out.println("OutboundHandler.sendMessage networkMessage = " + networkMessage);
+        MessageSerializer1 serializer = new MessageSerializer1(networkMessage, bigArrays);
+        SendContext sendContext = new SendContext(channel, serializer, listener, serializer);
+        internalSend(channel, sendContext);
+    }
+
     private void sendMessageProtobuf(TcpChannel channel, ProtobufOutboundMessage networkMessage, ActionListener<Void> listener) throws IOException {
         System.out.println("OutboundHandler.sendMessageProtobuf");
         System.out.println("OutboundHandler.sendMessageProtobuf networkMessage = " + networkMessage);
@@ -296,6 +309,35 @@ public void close() {
         }
     }
 
+    /**
+     * Internal message serializer
+     *
+     * @opensearch.internal
+     */
+    private static class MessageSerializer1 implements CheckedSupplier<BytesReference, IOException>, Releasable {
+
+        private final OutboundMessage message;
+        private final BigArrays bigArrays;
+        private volatile ReleasableBytesStreamOutput bytesStreamOutput;
+
+        private MessageSerializer1(OutboundMessage message, BigArrays bigArrays) {
+            this.message = message;
+            this.bigArrays = bigArrays;
+        }
+
+        @Override
+        public BytesReference get() throws IOException {
+            System.out.println("OutboundHandler.MessageSerializer.get");
+            bytesStreamOutput = new ReleasableBytesStreamOutput(bigArrays);
+            return message.serialize1(bytesStreamOutput);
+        }
+
+        @Override
+        public void close() {
+            IOUtils.closeWhileHandlingException(bytesStreamOutput);
+        }
+    }
+
     /**
      * Internal message serializer
      *
diff --git a/server/src/main/java/org/opensearch/transport/OutboundMessage.java b/server/src/main/java/org/opensearch/transport/OutboundMessage.java
index 83b6ca40810fd..7531d116f5a59 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundMessage.java
@@ -92,6 +92,42 @@ BytesReference serialize(BytesStreamOutput bytesStream) throws IOException {
         return reference;
     }
 
+    BytesReference serialize1(BytesStreamOutput bytesStream) throws IOException {
+        System.out.println("Inside OutboundMessage.serialize");
+        bytesStream.setVersion(version);
+        // bytesStream.skip(TcpHeader.headerSize(version));
+
+        // The compressible bytes stream will not close the underlying bytes stream
+        BytesReference reference;
+        int variableHeaderLength = -1;
+        final long preHeaderPosition = bytesStream.position();
+        writeVariableHeader(bytesStream);
+        variableHeaderLength = Math.toIntExact(bytesStream.position() - preHeaderPosition);
+
+
+        try (CompressibleBytesOutputStream stream = new CompressibleBytesOutputStream(bytesStream, TransportStatus.isCompress(status))) {
+            stream.setVersion(version);
+            stream.setFeatures(bytesStream.getFeatures());
+
+            if (variableHeaderLength == -1) {
+                writeVariableHeader(stream);
+            }
+            reference = writeMessage(stream);
+        }
+
+        bytesStream.seek(0);
+        final int contentSize = reference.length() - TcpHeader.headerSize(version);
+        TcpHeader.writeHeader(bytesStream, requestId, status, version, contentSize, variableHeaderLength);
+        System.out.println("Bytes serialized length: " + reference.length());
+        System.out.println("Bytes serialized: " + reference);
+        System.out.println("Now the bytes: ");
+        for (int i = 0; i < reference.length(); i++) {
+            System.out.print(reference.get(i) + " ");
+        }
+        System.out.println();
+        return reference;
+    }
+
     protected void writeVariableHeader(StreamOutput stream) throws IOException {
         threadContext.writeTo(stream);
     }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufNetworkMessage.java b/server/src/main/java/org/opensearch/transport/ProtobufNetworkMessage.java
index 489e7a42f767f..c79233a4d46dc 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufNetworkMessage.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufNetworkMessage.java
@@ -26,7 +26,7 @@ public abstract class ProtobufNetworkMessage {
     protected final byte status;
 
     ProtobufNetworkMessage(ThreadContext threadContext, Version version, byte status, long requestId) {
-        this.threadContext = (ProtobufWriteable) threadContext.captureAsProtobufWriteable();
+        this.threadContext = threadContext.captureAsProtobufWriteable();
         this.version = version;
         this.requestId = requestId;
         this.status = status;
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java b/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
index 3704659f9bd30..dcaa560efc89d 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
@@ -12,9 +12,11 @@
 import org.opensearch.Version;
 import org.opensearch.common.bytes.BytesArray;
 import org.opensearch.common.bytes.BytesReference;
+import org.opensearch.common.bytes.CompositeBytesReference;
 import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.io.stream.StreamOutput;
 import org.opensearch.common.util.concurrent.ThreadContext;
 
 import java.io.ByteArrayOutputStream;
@@ -27,67 +29,143 @@
 *
 * @opensearch.internal
 */
-abstract class ProtobufOutboundMessage extends ProtobufNetworkMessage {
+abstract class ProtobufOutboundMessage extends NetworkMessage {
 
-    private final ProtobufWriteable message;
+    private final TransportMessage message;
 
-    ProtobufOutboundMessage(ThreadContext threadContext, Version version, byte status, long requestId, ProtobufWriteable message) {
+    ProtobufOutboundMessage(ThreadContext threadContext, Version version, byte status, long requestId, TransportMessage message) {
         super(threadContext, version, status, requestId);
         this.message = message;
     }
 
     BytesReference serialize(BytesStreamOutput bytesStream) throws IOException {
-        System.out.println("Inside ProtobufOutboundMessage.serialize");
-        CodedOutputStream out = CodedOutputStream.newInstance(bytesStream);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.setVersion(version);
-        int headerLength = TcpHeader.headerSize(version);
+        // TcpHeader.writeHeaderProtobuf(outputStream, requestId, status, version, TcpHeader.headerSize(version), TcpHeader.headerSize(version));
+        // writeVariableHeader(outputStream);
+        // message.writeTo(outputStream);
+        // System.out.println("Inside ProtobufOutboundMessage.serialize");
+        // CodedOutputStream codedOutputStream = CodedOutputStream.newInstance(bytesStream);
+        // ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(codedOutputStream);
+        // protobufStreamOutput.setVersion(version);
+        // // bytesStream.setVersion(version);
+        // // bytesStream.skip(TcpHeader.headerSize(version));
+
+        // // The compressible bytes stream will not close the underlying bytes stream
+        // BytesReference reference;
+        // int variableHeaderLength = -1;
+        // final long preHeaderPosition = codedOutputStream.getTotalBytesWritten();
+        // writeVariableHeader(codedOutputStream);
+        // variableHeaderLength = Math.toIntExact(codedOutputStream.getTotalBytesWritten() - preHeaderPosition);
+
+        // protobufStreamOutput.setFeatures(bytesStream.getFeatures());
+        // if (variableHeaderLength == -1) {
+        //         writeVariableHeader(codedOutputStream);
+        // }
+        // reference = writeMessage(codedOutputStream);
+        // // try (CompressibleBytesOutputStream stream = new CompressibleBytesOutputStream(bytesStream, TransportStatus.isCompress(status))) {
+        // //     stream.setVersion(version);
+        // //     stream.setFeatures(bytesStream.getFeatures());
+
+        // //     if (variableHeaderLength == -1) {
+        // //         writeVariableHeader(stream);
+        // //     }
+        // //     reference = writeMessage(stream);
+        // // }
+
+        // // bytesStream.seek(0);
+        // final int contentSize = reference.length() - TcpHeader.headerSize(version);
+        // TcpHeader.writeHeaderProtobuf(codedOutputStream, requestId, status, version, contentSize, variableHeaderLength);
+        // System.out.println("Bytes serialized length: " + reference.length());
+        // System.out.println("Bytes serialized: " + reference);
+        // System.out.println("Now the bytes: ");
+        // for (int i = 0; i < reference.length(); i++) {
+        //     System.out.print(reference.get(i) + " ");
+        // }
+        // System.out.println();
+        // return reference;
+
+        
+        bytesStream.setVersion(version);
+        bytesStream.skip(TcpHeader.headerSize(version));
 
         // The compressible bytes stream will not close the underlying bytes stream
         BytesReference reference;
         int variableHeaderLength = -1;
-        // final long preHeaderPosition = out.();
-        writeVariableHeader(out);
-        variableHeaderLength = Math.toIntExact(out.getTotalBytesWritten() - headerLength);
+        final long preHeaderPosition = bytesStream.position();
+        writeVariableHeader(bytesStream);
+        variableHeaderLength = Math.toIntExact(bytesStream.position() - preHeaderPosition);
 
-        if (TransportStatus.isCompress(status)) {
-            protobufStreamOutput.setVersion(version);
-            protobufStreamOutput.setFeatures(protobufStreamOutput.getFeatures());
-        }
-        // try (CompressibleBytesOutputStream stream = new CompressibleBytesOutputStream(out, TransportStatus.isCompress(status))) {
-        // stream.setVersion(version);
-        // stream.setFeatures(out.getFeatures());
+        try (CompressibleBytesOutputStream stream = new CompressibleBytesOutputStream(bytesStream, TransportStatus.isCompress(status))) {
+            stream.setVersion(version);
+            stream.setFeatures(bytesStream.getFeatures());
 
-        // if (variableHeaderLength == -1) {
-        //     writeVariableHeader(out);
-        // }
-        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); 
-        byteArrayOutputStream.writeTo(bytesStream); 
-        
-        reference = writeMessage(out, byteArrayOutputStream.toByteArray());
-        // }
+            if (variableHeaderLength == -1) {
+                writeVariableHeader(stream);
+            }
+            reference = writeMessage(stream);
+        }
 
-        // out.seek(0);
+        bytesStream.seek(0);
         final int contentSize = reference.length() - TcpHeader.headerSize(version);
-        TcpHeader.writeHeaderProtobuf(out, requestId, status, version, contentSize, variableHeaderLength);
+        TcpHeader.writeHeader(bytesStream, requestId, status, version, contentSize, variableHeaderLength);
+        System.out.println("Bytes serialized length: " + reference.length());
+        System.out.println("Bytes serialized: " + reference);
+        System.out.println("Now the bytes: ");
+        for (int i = 0; i < reference.length(); i++) {
+            System.out.print(reference.get(i) + " ");
+        }
+        System.out.println();
+        // convert output stream to bytes
+        // ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        // baos.write(outputStream);
+        // outputStream.writeTo(baos);
+        // byte[] bytes = baos.toByteArray();
+        // System.out.println("Bytes serialized length: " + bytes.length);
+        // System.out.println("Bytes serialized: " + bytes);
+        // System.out.println("Now the bytes: ");
+
         return reference;
     }
 
-    protected void writeVariableHeader(CodedOutputStream stream) throws IOException {
+    protected void writeVariableHeader(StreamOutput stream) throws IOException {
         threadContext.writeTo(stream);
     }
 
-    protected BytesReference writeMessage(CodedOutputStream stream, byte[] bytes) throws IOException {
+    protected BytesReference writeMessage(CompressibleBytesOutputStream stream) throws IOException {
+        // final BytesReference zeroCopyBuffer;
+        // if (message instanceof BytesTransportRequest) {
+        //     BytesTransportRequest bRequest = (BytesTransportRequest) message;
+        //     bRequest.writeThinProtobuf(stream);
+        //     zeroCopyBuffer = bRequest.bytes;
+        // } else if (message instanceof ProtobufRemoteTransportException) {
+        //     ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(stream);
+        //     protobufStreamOutput.writeException((ProtobufRemoteTransportException) message);
+        //     zeroCopyBuffer = BytesArray.EMPTY;
+        // } else {
+        //     message.writeTo(stream);
+        //     zeroCopyBuffer = BytesArray.EMPTY;
+        // }
+        // // we have to call materializeBytes() here before accessing the bytes. A CompressibleBytesOutputStream
+        // // might be implementing compression. And materializeBytes() ensures that some marker bytes (EOS marker)
+        // // are written. Otherwise we barf on the decompressing end when we read past EOF on purpose in the
+        // // #validateRequest method. this might be a problem in deflate after all but it's important to write
+        // // the marker bytes.
+        // ByteBuffer byteBuffer = ByteBuffer.wrap(bytes);
+        // final BytesReference message = stream
+        // if (zeroCopyBuffer.length() == 0) {
+        //     return message;
+        // } else {
+        //     return CompositeBytesReference.of(message, zeroCopyBuffer);
+        // }
         final BytesReference zeroCopyBuffer;
         if (message instanceof BytesTransportRequest) {
             BytesTransportRequest bRequest = (BytesTransportRequest) message;
-            bRequest.writeThinProtobuf(stream);
+            bRequest.writeThin(stream);
             zeroCopyBuffer = bRequest.bytes;
-        } else if (message instanceof ProtobufRemoteTransportException) {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(stream);
-            protobufStreamOutput.writeException((ProtobufRemoteTransportException) message);
-            zeroCopyBuffer = BytesArray.EMPTY;
+        // } else if (message instanceof RemoteTransportException) {
+        //     stream.writeException((RemoteTransportException) message);
+        //     zeroCopyBuffer = BytesArray.EMPTY;
         } else {
+            // CodedOutputStream outputStream = CodedOutputStream.newInstance(stream);
             message.writeTo(stream);
             zeroCopyBuffer = BytesArray.EMPTY;
         }
@@ -96,14 +174,12 @@ protected BytesReference writeMessage(CodedOutputStream stream, byte[] bytes) th
         // are written. Otherwise we barf on the decompressing end when we read past EOF on purpose in the
         // #validateRequest method. this might be a problem in deflate after all but it's important to write
         // the marker bytes.
-        ByteBuffer byteBuffer = ByteBuffer.wrap(bytes);
-        final BytesReference message = BytesReference.fromByteBuffer(byteBuffer);
-        // if (zeroCopyBuffer.length() == 0) {
-        // return message;
-        // } else {
-        // return CompositeBytesReference.of(message, zeroCopyBuffer);
-        // }
-        return message;
+        final BytesReference message = stream.materializeBytes();
+        if (zeroCopyBuffer.length() == 0) {
+            return message;
+        } else {
+            return CompositeBytesReference.of(message, zeroCopyBuffer);
+        }
     }
 
     /**
@@ -119,7 +195,7 @@ static class Request extends ProtobufOutboundMessage {
         Request(
             ThreadContext threadContext,
             String[] features,
-            ProtobufWriteable message,
+            TransportMessage message,
             Version version,
             String action,
             long requestId,
@@ -132,14 +208,17 @@ static class Request extends ProtobufOutboundMessage {
         }
 
         @Override
-        protected void writeVariableHeader(CodedOutputStream out) throws IOException {
-            super.writeVariableHeader(out);
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            protobufStreamOutput.writeStringArray(features);
-            out.writeStringNoTag(action);
+        protected void writeVariableHeader(StreamOutput stream) throws IOException {
+            // super.writeVariableHeader(out);
+            // ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+            // protobufStreamOutput.writeStringArray(features);
+            // out.writeStringNoTag(action);
+            super.writeVariableHeader(stream);
+            stream.writeStringArray(features);
+            stream.writeString(action);
         }
 
-        private static byte setStatus(boolean compress, boolean isHandshake, ProtobufWriteable message) {
+        private static byte setStatus(boolean compress, boolean isHandshake, TransportMessage message) {
             byte status = 0;
             status = TransportStatus.setRequest(status);
             if (compress && ProtobufOutboundMessage.canCompress(message)) {
@@ -165,7 +244,7 @@ static class Response extends ProtobufOutboundMessage {
         Response(
             ThreadContext threadContext,
             Set<String> features,
-            ProtobufWriteable message,
+            TransportMessage message,
             Version version,
             long requestId,
             boolean isHandshake,
@@ -176,18 +255,20 @@ static class Response extends ProtobufOutboundMessage {
         }
 
         @Override
-        protected void writeVariableHeader(CodedOutputStream out) throws IOException {
-            super.writeVariableHeader(out);
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            protobufStreamOutput.setFeatures(features);
+        protected void writeVariableHeader(StreamOutput stream) throws IOException {
+            // super.writeVariableHeader(out);
+            // ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+            // protobufStreamOutput.setFeatures(features);
+            super.writeVariableHeader(stream);
+            stream.setFeatures(features);
         }
 
-        private static byte setStatus(boolean compress, boolean isHandshake, ProtobufWriteable message) {
+        private static byte setStatus(boolean compress, boolean isHandshake, TransportMessage message) {
             byte status = 0;
             status = TransportStatus.setResponse(status);
-            if (message instanceof RemoteTransportException) {
-                status = TransportStatus.setError(status);
-            }
+            // if (message instanceof RemoteTransportException) {
+            //     status = TransportStatus.setError(status);
+            // }
             if (compress) {
                 status = TransportStatus.setCompress(status);
             }
@@ -199,7 +280,7 @@ private static byte setStatus(boolean compress, boolean isHandshake, ProtobufWri
         }
     }
 
-    private static boolean canCompress(ProtobufWriteable message) {
+    private static boolean canCompress(TransportMessage message) {
         return message instanceof ProtobufBytesTransportRequest == false;
     }
 }
diff --git a/server/src/test/java/org/opensearch/action/admin/cluster/configuration/TransportAddVotingConfigExclusionsActionTests.java b/server/src/test/java/org/opensearch/action/admin/cluster/configuration/TransportAddVotingConfigExclusionsActionTests.java
index 59180539243f5..149e85c50b36c 100644
--- a/server/src/test/java/org/opensearch/action/admin/cluster/configuration/TransportAddVotingConfigExclusionsActionTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/cluster/configuration/TransportAddVotingConfigExclusionsActionTests.java
@@ -60,9 +60,13 @@
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.threadpool.ThreadPool.Names;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
+
+import com.google.protobuf.CodedInputStream;
+
 import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
@@ -683,6 +687,18 @@ public String executor() {
             public AddVotingConfigExclusionsResponse read(StreamInput in) throws IOException {
                 return new AddVotingConfigExclusionsResponse(in);
             }
+
+            @Override
+            public AddVotingConfigExclusionsResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         };
     }
 
diff --git a/server/src/test/java/org/opensearch/action/admin/cluster/configuration/TransportClearVotingConfigExclusionsActionTests.java b/server/src/test/java/org/opensearch/action/admin/cluster/configuration/TransportClearVotingConfigExclusionsActionTests.java
index 4136d1cf31f3a..a4366e8061e0f 100644
--- a/server/src/test/java/org/opensearch/action/admin/cluster/configuration/TransportClearVotingConfigExclusionsActionTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/cluster/configuration/TransportClearVotingConfigExclusionsActionTests.java
@@ -54,9 +54,13 @@
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.threadpool.ThreadPool.Names;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
+
+import com.google.protobuf.CodedInputStream;
+
 import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
@@ -250,6 +254,18 @@ public String executor() {
             public ClearVotingConfigExclusionsResponse read(StreamInput in) throws IOException {
                 return new ClearVotingConfigExclusionsResponse(in);
             }
+
+            @Override
+            public ClearVotingConfigExclusionsResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         };
     }
 }
diff --git a/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationAllPermitsAcquisitionTests.java b/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationAllPermitsAcquisitionTests.java
index f7c26ed8fea03..b65dc2cf3ed77 100644
--- a/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationAllPermitsAcquisitionTests.java
+++ b/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationAllPermitsAcquisitionTests.java
@@ -35,6 +35,7 @@
 import org.opensearch.action.ActionListener;
 import org.opensearch.action.support.ActionFilters;
 import org.opensearch.action.support.PlainActionFuture;
+import org.opensearch.action.support.replication.TransportReplicationAction.ReplicaResponse;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.action.shard.ShardStateAction;
 import org.opensearch.cluster.block.ClusterBlock;
@@ -67,11 +68,15 @@
 import org.opensearch.core.rest.RestStatus;
 import org.opensearch.test.transport.MockTransport;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportMessageListener;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
+
+import com.google.protobuf.CodedInputStream;
+
 import org.junit.After;
 import org.junit.Before;
 
@@ -222,6 +227,18 @@ public void handleException(TransportException exp) {
                         public String executor() {
                             return ThreadPool.Names.SAME;
                         }
+
+                        @Override
+                        public ReplicaResponse read(CodedInputStream in) throws IOException {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'read'");
+                        }
+
+                        @Override
+                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                        }
                     }
                 );
             }
diff --git a/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java b/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java
index 972f2469250d4..2af8f395fcb34 100644
--- a/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java
@@ -60,7 +60,7 @@
 import org.opensearch.transport.ConnectTransportException;
 import org.opensearch.transport.ConnectionProfile;
 import org.opensearch.transport.ProtobufConnectionProfile;
-import org.opensearch.transport.ProtobufTransportMessageListener;
+// import org.opensearch.transport.ProtobufTransportMessageListener;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.ProtobufTransportStats;
 import org.opensearch.transport.Transport;
@@ -599,7 +599,7 @@ public void connectToNode(DiscoveryNode node, ActionListener<Void> listener) thr
     private static final class MockTransport implements Transport {
         private final ResponseHandlers responseHandlers = new ResponseHandlers();
         private final RequestHandlers requestHandlers = new RequestHandlers();
-        private final ProtobufResponseHandlers protobufResponseHandlers = new ProtobufResponseHandlers();
+        // private final ProtobufResponseHandlers protobufResponseHandlers = new ProtobufResponseHandlers();
         private final ProtobufRequestHandlers protobufRequestHandlers = new ProtobufRequestHandlers();
         private volatile boolean randomConnectionExceptions = false;
         private final ThreadPool threadPool;
@@ -695,70 +695,70 @@ public RequestHandlers getRequestHandlers() {
             return requestHandlers;
         }
 
-        @Override
-        public void setMessageListenerProtobuf(ProtobufTransportMessageListener listener) {}
-
-        @Override
-        public BoundTransportAddress boundProtobufAddress() {
-            return null;
-        }
-
-        @Override
-        public Map<String, BoundTransportAddress> profileProtobufBoundAddresses() {
-            return null;
-        }
-
-        @Override
-        public ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException {
-            return new ProtobufTransportAddress[0];
-        }
-
-        @Override
-        public void openProtobufConnection(
-            DiscoveryNode node,
-            ProtobufConnectionProfile profile,
-            ActionListener<ProtobufConnection> listener
-        ) {
-            if (profile == null && randomConnectionExceptions && randomBoolean()) {
-                threadPool.generic().execute(() -> listener.onFailure(new ConnectTransportException(node, "simulated")));
-            } else {
-                threadPool.generic().execute(() -> listener.onResponse(new ProtobufConnection() {
-                    @Override
-                    public DiscoveryNode getNode() {
-                        return node;
-                    }
-
-                    @Override
-                    public void sendRequest(
-                        long requestId,
-                        String action,
-                        TransportRequest request,
-                        TransportRequestOptions options
-                    ) throws TransportException {}
-
-                    @Override
-                    public void addCloseListener(ActionListener<Void> listener) {}
-
-                    @Override
-                    public void close() {}
-
-                    @Override
-                    public boolean isClosed() {
-                        return false;
-                    }
-                }));
-            }
-        }
+        // @Override
+        // public void setMessageListenerProtobuf(ProtobufTransportMessageListener listener) {}
+
+        // @Override
+        // public BoundTransportAddress boundProtobufAddress() {
+        //     return null;
+        // }
+
+        // @Override
+        // public Map<String, BoundTransportAddress> profileProtobufBoundAddresses() {
+        //     return null;
+        // }
+
+        // @Override
+        // public ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException {
+        //     return new ProtobufTransportAddress[0];
+        // }
+
+        // @Override
+        // public void openProtobufConnection(
+        //     DiscoveryNode node,
+        //     ProtobufConnectionProfile profile,
+        //     ActionListener<ProtobufConnection> listener
+        // ) {
+        //     if (profile == null && randomConnectionExceptions && randomBoolean()) {
+        //         threadPool.generic().execute(() -> listener.onFailure(new ConnectTransportException(node, "simulated")));
+        //     } else {
+        //         threadPool.generic().execute(() -> listener.onResponse(new ProtobufConnection() {
+        //             @Override
+        //             public DiscoveryNode getNode() {
+        //                 return node;
+        //             }
+
+        //             @Override
+        //             public void sendRequest(
+        //                 long requestId,
+        //                 String action,
+        //                 TransportRequest request,
+        //                 TransportRequestOptions options
+        //             ) throws TransportException {}
+
+        //             @Override
+        //             public void addCloseListener(ActionListener<Void> listener) {}
+
+        //             @Override
+        //             public void close() {}
+
+        //             @Override
+        //             public boolean isClosed() {
+        //                 return false;
+        //             }
+        //         }));
+        //     }
+        // }
 
         @Override
         public ProtobufTransportStats getProtobufStats() {
             throw new UnsupportedOperationException();
         }
 
-        @Override
-        public ProtobufResponseHandlers getProtobufResponseHandlers() {
-            return protobufResponseHandlers;
-        }
+        // @Override
+        // public ProtobufResponseHandlers getProtobufResponseHandlers() {
+        //     return protobufResponseHandlers;
+        // }
 
         @Override
         public ProtobufRequestHandlers getProtobufRequestHandlers() {
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/CoordinatorTests.java b/server/src/test/java/org/opensearch/cluster/coordination/CoordinatorTests.java
index 8c9095cd78914..0ee0e71a85b10 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/CoordinatorTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/CoordinatorTests.java
@@ -58,6 +58,8 @@
 import org.opensearch.monitor.StatusInfo;
 import org.opensearch.test.MockLogAppender;
 
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.HashSet;
@@ -1443,7 +1445,7 @@ public void testSingleNodeDiscoveryStabilisesEvenWhenDisrupted() {
         }
     }
 
-    private static class BrokenCustom extends AbstractDiffable<ClusterState.Custom> implements ClusterState.Custom {
+    private static class BrokenCustom extends AbstractDiffable<ClusterState.Custom, ClusterState> implements ClusterState.Custom {
 
         static final String EXCEPTION_MESSAGE = "simulated";
 
@@ -1467,6 +1469,12 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
             return builder;
         }
 
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
+        }
+
     }
 
     public void testClusterRecoversAfterExceptionDuringSerialization() {
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/FollowersCheckerTests.java b/server/src/test/java/org/opensearch/cluster/coordination/FollowersCheckerTests.java
index be211a16cdd72..42b914307153f 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/FollowersCheckerTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/FollowersCheckerTests.java
@@ -51,6 +51,7 @@
 import org.opensearch.test.transport.MockTransport;
 import org.opensearch.threadpool.ThreadPool.Names;
 import org.opensearch.transport.ConnectTransportException;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportResponse;
@@ -58,6 +59,9 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
@@ -520,6 +524,18 @@ public void handleException(TransportException exp) {
                 public String executor() {
                     return Names.SAME;
                 }
+
+                @Override
+                public Empty read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
         deterministicTaskQueue.runAllTasks();
@@ -606,6 +622,18 @@ public void handleException(TransportException exp) {
                     public String executor() {
                         return Names.SAME;
                     }
+
+                    @Override
+                    public Empty read(CodedInputStream in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
+
+                    @Override
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                    }
                 }
             );
             deterministicTaskQueue.runAllTasks();
@@ -678,6 +706,18 @@ public void handleException(TransportException exp) {
                     public String executor() {
                         return Names.SAME;
                     }
+
+                    @Override
+                    public Empty read(CodedInputStream in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
+
+                    @Override
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                    }
                 }
             );
             deterministicTaskQueue.runAllTasks();
@@ -779,5 +819,17 @@ public TransportResponse.Empty read(StreamInput in) {
             return TransportResponse.Empty.INSTANCE;
         }
 
+        @Override
+        public Empty read(CodedInputStream in) throws IOException {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'read'");
+        }
+
+        @Override
+        public void handleExceptionProtobuf(ProtobufTransportException exp) {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+        }
+
     }
 }
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/LeaderCheckerTests.java b/server/src/test/java/org/opensearch/cluster/coordination/LeaderCheckerTests.java
index ac6d885229f9e..46cf8d67a78f1 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/LeaderCheckerTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/LeaderCheckerTests.java
@@ -48,6 +48,7 @@
 import org.opensearch.test.transport.MockTransport;
 import org.opensearch.threadpool.ThreadPool.Names;
 import org.opensearch.transport.ConnectTransportException;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportResponse;
@@ -55,6 +56,9 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
+import java.io.IOException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReference;
@@ -538,6 +542,18 @@ public String executor() {
         public TransportResponse.Empty read(StreamInput in) {
             return TransportResponse.Empty.INSTANCE;
         }
+
+        @Override
+        public Empty read(CodedInputStream in) throws IOException {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'read'");
+        }
+
+        @Override
+        public void handleExceptionProtobuf(ProtobufTransportException exp) {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+        }
     }
 
     public void testLeaderCheckRequestEqualsHashcodeSerialization() {
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/PreVoteCollectorTests.java b/server/src/test/java/org/opensearch/cluster/coordination/PreVoteCollectorTests.java
index 97bd683cab9eb..5d362c9de7cb4 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/PreVoteCollectorTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/PreVoteCollectorTests.java
@@ -43,11 +43,15 @@
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.transport.MockTransport;
 import org.opensearch.transport.ConnectTransportException;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.RemoteTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
+
+import com.google.protobuf.CodedInputStream;
+
 import org.junit.Before;
 
 import java.io.IOException;
@@ -349,6 +353,18 @@ public void handleException(TransportException exp) {
                 public String executor() {
                     return SAME;
                 }
+
+                @Override
+                public PreVoteResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
 
diff --git a/server/src/test/java/org/opensearch/cluster/serialization/DiffableTests.java b/server/src/test/java/org/opensearch/cluster/serialization/DiffableTests.java
index ac2470e940916..19e2566abb38f 100644
--- a/server/src/test/java/org/opensearch/cluster/serialization/DiffableTests.java
+++ b/server/src/test/java/org/opensearch/cluster/serialization/DiffableTests.java
@@ -42,6 +42,8 @@
 import org.opensearch.common.util.set.Sets;
 import org.opensearch.test.OpenSearchTestCase;
 
+import com.google.protobuf.CodedOutputStream;
+
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -297,7 +299,7 @@ public String read(StreamInput in, K key) throws IOException {
         };
     }
 
-    public static class TestDiffable extends AbstractDiffable<TestDiffable> {
+    public static class TestDiffable extends AbstractDiffable<TestDiffable, TestDiffable> {
 
         private final String value;
 
@@ -337,6 +339,12 @@ public boolean equals(Object o) {
         public int hashCode() {
             return value != null ? value.hashCode() : 0;
         }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
+        }
     }
 
 }
diff --git a/server/src/test/java/org/opensearch/discovery/PeerFinderTests.java b/server/src/test/java/org/opensearch/discovery/PeerFinderTests.java
index 91eec3d2edfaf..876d23c35bc2b 100644
--- a/server/src/test/java/org/opensearch/discovery/PeerFinderTests.java
+++ b/server/src/test/java/org/opensearch/discovery/PeerFinderTests.java
@@ -51,9 +51,13 @@
 import org.opensearch.threadpool.ThreadPool.Names;
 import org.opensearch.transport.ClusterConnectionManager;
 import org.opensearch.transport.ConnectionManager;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
+
+import com.google.protobuf.CodedInputStream;
+
 import org.junit.After;
 import org.junit.Before;
 
@@ -545,6 +549,18 @@ public void handleException(TransportException exp) {
                 public String executor() {
                     return Names.SAME;
                 }
+
+                @Override
+                public PeersResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
 
diff --git a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationSourceServiceTests.java b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationSourceServiceTests.java
index bee1bedc892d8..460ba1e02be70 100644
--- a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationSourceServiceTests.java
+++ b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationSourceServiceTests.java
@@ -33,11 +33,14 @@
 import org.opensearch.test.transport.CapturingTransport;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
@@ -218,6 +221,18 @@ public String executor() {
                 public CheckpointInfoResponse read(StreamInput in) throws IOException {
                     return new CheckpointInfoResponse(in);
                 }
+
+                @Override
+                public CheckpointInfoResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
     }
@@ -247,6 +262,18 @@ public String executor() {
                 public GetSegmentFilesResponse read(StreamInput in) throws IOException {
                     return new GetSegmentFilesResponse(in);
                 }
+
+                @Override
+                public GetSegmentFilesResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
     }
diff --git a/server/src/test/java/org/opensearch/transport/InboundHandlerTests.java b/server/src/test/java/org/opensearch/transport/InboundHandlerTests.java
index d4959472bd08a..07ab2246dfd89 100644
--- a/server/src/test/java/org/opensearch/transport/InboundHandlerTests.java
+++ b/server/src/test/java/org/opensearch/transport/InboundHandlerTests.java
@@ -55,6 +55,9 @@
 import org.opensearch.test.VersionUtils;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
+
+import com.google.protobuf.CodedInputStream;
+
 import org.junit.After;
 import org.junit.Before;
 
@@ -81,6 +84,7 @@ public class InboundHandlerTests extends OpenSearchTestCase {
     private TaskManager taskManager;
     private Transport.ResponseHandlers responseHandlers;
     private Transport.RequestHandlers requestHandlers;
+    private Transport.ProtobufRequestHandlers protobufRequestHandlers;
     private InboundHandler handler;
     private OutboundHandler outboundHandler;
     private FakeTcpChannel channel;
@@ -117,6 +121,7 @@ public void sendMessage(BytesReference reference, org.opensearch.action.ActionLi
             handshaker,
             keepAlive,
             requestHandlers,
+            protobufRequestHandlers,
             responseHandlers
         );
     }
@@ -177,6 +182,18 @@ public String executor() {
             public TestResponse read(StreamInput in) throws IOException {
                 return new TestResponse(in);
             }
+
+            @Override
+            public TestResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         }, null, action));
         RequestHandlerRegistry<TestRequest> registry = new RequestHandlerRegistry<>(
             action,
@@ -364,6 +381,18 @@ public String executor() {
             public TestResponse read(StreamInput in) throws IOException {
                 return new TestResponse(in);
             }
+
+            @Override
+            public TestResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         }, null, action));
 
         RequestHandlerRegistry<TestRequest> registry = new RequestHandlerRegistry<>(
@@ -436,6 +465,18 @@ public String executor() {
             public TestResponse read(StreamInput in) throws IOException {
                 return new TestResponse(in);
             }
+
+            @Override
+            public TestResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         }, null, action));
 
         RequestHandlerRegistry<TestRequest> registry = new RequestHandlerRegistry<>(
@@ -509,6 +550,18 @@ public String executor() {
             public TestResponse read(StreamInput in) throws IOException {
                 return new TestResponse(in);
             }
+
+            @Override
+            public TestResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         }, null, action));
         RequestHandlerRegistry<TestRequest> registry = new RequestHandlerRegistry<>(
             action,
@@ -597,6 +650,18 @@ public String executor() {
             public TestResponse read(StreamInput in) throws IOException {
                 return new TestResponse(in);
             }
+
+            @Override
+            public TestResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         }, null, action));
         RequestHandlerRegistry<TestRequest> registry = new RequestHandlerRegistry<>(
             action,
diff --git a/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java b/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
index fe8be400b03c9..8b652880b54db 100644
--- a/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
+++ b/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
@@ -49,6 +49,7 @@
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.common.util.io.Streams;
+import org.opensearch.example.proto.ExampleRequestProto.ExampleRequest;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
@@ -312,4 +313,71 @@ public void onResponseSent(long requestId, String action, Exception error) {
 
         assertEquals("header_value", header.getHeaders().v1().get("header"));
     }
+
+    public void testSendRequestProtobuf() throws IOException {
+        ThreadContext threadContext = threadPool.getThreadContext();
+        Version version = randomFrom(Version.CURRENT, Version.CURRENT.minimumCompatibilityVersion());
+        String action = "example";
+        long requestId = randomLongBetween(0, 300);
+        boolean isHandshake = false;
+        boolean compress = false;
+        String value = "message";
+        threadContext.putHeader("header", "header_value");
+        ExampleRequest request = ExampleRequest.newBuilder().setHeader("header_value").setMessage(value).build();
+
+        AtomicReference<DiscoveryNode> nodeRef = new AtomicReference<>();
+        AtomicLong requestIdRef = new AtomicLong();
+        AtomicReference<String> actionRef = new AtomicReference<>();
+        AtomicReference<TransportRequest> requestRef = new AtomicReference<>();
+        handler.setMessageListener(new TransportMessageListener() {
+            @Override
+            public void onRequestSent(
+                DiscoveryNode node,
+                long requestId,
+                String action,
+                TransportRequest request,
+                TransportRequestOptions options
+            ) {
+                nodeRef.set(node);
+                requestIdRef.set(requestId);
+                actionRef.set(action);
+                requestRef.set(request);
+            }
+        });
+        handler.sendRequest(node, channel, requestId, action, request, options, version, compress, isHandshake);
+
+        BytesReference reference = channel.getMessageCaptor().get();
+        ActionListener<Void> sendListener = channel.getListenerCaptor().get();
+        if (randomBoolean()) {
+            sendListener.onResponse(null);
+        } else {
+            sendListener.onFailure(new IOException("failed"));
+        }
+        assertEquals(node, nodeRef.get());
+        assertEquals(requestId, requestIdRef.get());
+        assertEquals(action, actionRef.get());
+        assertEquals(request, requestRef.get());
+
+        pipeline.handleBytes(channel, new ReleasableBytesReference(reference, () -> {}));
+        final Tuple<Header, BytesReference> tuple = message.get();
+        final Header header = tuple.v1();
+        final TestRequest message = new TestRequest(tuple.v2().streamInput());
+        assertEquals(version, header.getVersion());
+        assertEquals(requestId, header.getRequestId());
+        assertTrue(header.isRequest());
+        assertFalse(header.isResponse());
+        if (isHandshake) {
+            assertTrue(header.isHandshake());
+        } else {
+            assertFalse(header.isHandshake());
+        }
+        if (compress) {
+            assertTrue(header.isCompressed());
+        } else {
+            assertFalse(header.isCompressed());
+        }
+
+        assertEquals(value, message.value);
+        assertEquals("header_value", header.getHeaders().v1().get("header"));
+    }
 }
diff --git a/server/src/test/java/org/opensearch/transport/TransportActionProxyTests.java b/server/src/test/java/org/opensearch/transport/TransportActionProxyTests.java
index d1d46d5be13c0..8aa8a6b1f03e8 100644
--- a/server/src/test/java/org/opensearch/transport/TransportActionProxyTests.java
+++ b/server/src/test/java/org/opensearch/transport/TransportActionProxyTests.java
@@ -43,6 +43,9 @@
 import org.opensearch.test.transport.MockTransportService;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
+
+import com.google.protobuf.CodedInputStream;
+
 import org.junit.Before;
 
 import java.io.IOException;
@@ -147,6 +150,18 @@ public void handleException(TransportException exp) {
                 public String executor() {
                     return ThreadPool.Names.SAME;
                 }
+
+                @Override
+                public SimpleTestResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
         latch.await();
@@ -207,6 +222,18 @@ public void handleException(TransportException exp) {
                 public String executor() {
                     return ThreadPool.Names.SAME;
                 }
+
+                @Override
+                public SimpleTestResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
         latch.await();
diff --git a/server/src/test/java/org/opensearch/transport/TransportServiceDeserializationFailureTests.java b/server/src/test/java/org/opensearch/transport/TransportServiceDeserializationFailureTests.java
index 01d6a4d331477..10664113539a2 100644
--- a/server/src/test/java/org/opensearch/transport/TransportServiceDeserializationFailureTests.java
+++ b/server/src/test/java/org/opensearch/transport/TransportServiceDeserializationFailureTests.java
@@ -45,7 +45,11 @@
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.transport.MockTransport;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportResponse.Empty;
 
+import com.google.protobuf.CodedInputStream;
+
+import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
 
@@ -131,6 +135,18 @@ public TransportResponse.Empty read(StreamInput in) {
                     public String toString() {
                         return "test handler without parent";
                     }
+
+                    @Override
+                    public Empty read(CodedInputStream in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
+
+                    @Override
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                    }
                 }
             );
 
@@ -187,6 +203,18 @@ public TransportResponse.Empty read(StreamInput in) {
                     public String toString() {
                         return "test handler with parent";
                     }
+
+                    @Override
+                    public Empty read(CodedInputStream in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
+
+                    @Override
+                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                    }
                 }
             );
 
diff --git a/test/framework/src/test/java/org/opensearch/test/disruption/DisruptableMockTransportTests.java b/test/framework/src/test/java/org/opensearch/test/disruption/DisruptableMockTransportTests.java
index 9bddaf013aef4..2455e5ce9c23c 100644
--- a/test/framework/src/test/java/org/opensearch/test/disruption/DisruptableMockTransportTests.java
+++ b/test/framework/src/test/java/org/opensearch/test/disruption/DisruptableMockTransportTests.java
@@ -45,6 +45,7 @@
 import org.opensearch.test.disruption.DisruptableMockTransport.ConnectionStatus;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ConnectTransportException;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
@@ -53,6 +54,9 @@
 import org.opensearch.transport.TransportResponse.Empty;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
+
+import com.google.protobuf.CodedInputStream;
+
 import org.junit.Before;
 
 import java.io.IOException;
@@ -230,6 +234,18 @@ public void handleException(TransportException exp) {
             public String executor() {
                 return ThreadPool.Names.SAME;
             }
+
+            @Override
+            public TransportResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         };
     }
 
@@ -254,6 +270,18 @@ public void handleException(TransportException exp) {
             public String executor() {
                 return ThreadPool.Names.SAME;
             }
+
+            @Override
+            public TransportResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         };
     }
 
@@ -278,6 +306,18 @@ public void handleException(TransportException exp) {
             public String executor() {
                 return ThreadPool.Names.SAME;
             }
+
+            @Override
+            public TransportResponse read(CodedInputStream in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
+
+            @Override
+            public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+            }
         };
     }
 
diff --git a/test/framework/src/test/java/org/opensearch/test/disruption/NetworkDisruptionIT.java b/test/framework/src/test/java/org/opensearch/test/disruption/NetworkDisruptionIT.java
index a5112bc958954..22ba5cdbcf691 100644
--- a/test/framework/src/test/java/org/opensearch/test/disruption/NetworkDisruptionIT.java
+++ b/test/framework/src/test/java/org/opensearch/test/disruption/NetworkDisruptionIT.java
@@ -45,11 +45,14 @@
 import org.opensearch.test.disruption.NetworkDisruption.TwoPartitions;
 import org.opensearch.test.transport.MockTransportService;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
+import com.google.protobuf.CodedInputStream;
+
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.Collection;
@@ -214,6 +217,18 @@ public String executor() {
                 public TransportResponse read(StreamInput in) throws IOException {
                     return ClusterHealthResponse.readResponseFrom(in);
                 }
+
+                @Override
+                public TransportResponse read(CodedInputStream in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
+
+                @Override
+                public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
+                }
             }
         );
     }

From 496cdbb04063a6ad30c97e9f6708f433fd9158f3 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Wed, 19 Jul 2023 05:11:22 +0000
Subject: [PATCH 18/37] Trying proto message serde across nodes with tests and
 example request

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../netty4/Netty4MessageChannelHandler.java   |   3 +-
 .../transport/nio/TcpReadWriteHandler.java    |   3 +-
 .../common/io/stream/TryWriteable.java        |  78 +++
 .../example/proto/ExampleProtoRequest.java    |  78 +++
 .../opensearch/transport/InboundHandler.java  |  50 ++
 .../opensearch/transport/InboundPipeline.java |  93 ++-
 .../opensearch/transport/OutboundHandler.java | 150 ++++-
 .../transport/ProtobufOutboundMessage.java    | 580 ++++++++++--------
 .../opensearch/transport/TcpTransport.java    |  10 +
 .../proto/examples/ExampleRequestProto.proto  |  20 +
 .../proto/examples/OutboundMessageProto.proto |  41 ++
 .../transport/InboundPipelineTests.java       |   9 +-
 .../transport/OutboundHandlerTests.java       |  70 ++-
 .../transport/nio/MockNioTransport.java       |   3 +-
 14 files changed, 844 insertions(+), 344 deletions(-)
 create mode 100644 server/src/main/java/org/opensearch/common/io/stream/TryWriteable.java
 create mode 100644 server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java
 create mode 100644 server/src/main/proto/examples/ExampleRequestProto.proto
 create mode 100644 server/src/main/proto/examples/OutboundMessageProto.proto

diff --git a/modules/transport-netty4/src/main/java/org/opensearch/transport/netty4/Netty4MessageChannelHandler.java b/modules/transport-netty4/src/main/java/org/opensearch/transport/netty4/Netty4MessageChannelHandler.java
index f2b1249411219..f7acab52641e3 100644
--- a/modules/transport-netty4/src/main/java/org/opensearch/transport/netty4/Netty4MessageChannelHandler.java
+++ b/modules/transport-netty4/src/main/java/org/opensearch/transport/netty4/Netty4MessageChannelHandler.java
@@ -77,7 +77,8 @@ final class Netty4MessageChannelHandler extends ChannelDuplexHandler {
             threadPool::relativeTimeInMillis,
             transport.getInflightBreaker(),
             requestHandlers::getHandler,
-            transport::inboundMessage
+            transport::inboundMessage,
+            transport::inboundMessageProtobuf
         );
     }
 
diff --git a/plugins/transport-nio/src/main/java/org/opensearch/transport/nio/TcpReadWriteHandler.java b/plugins/transport-nio/src/main/java/org/opensearch/transport/nio/TcpReadWriteHandler.java
index ee96e9d85c03b..2fafd2aa7b19c 100644
--- a/plugins/transport-nio/src/main/java/org/opensearch/transport/nio/TcpReadWriteHandler.java
+++ b/plugins/transport-nio/src/main/java/org/opensearch/transport/nio/TcpReadWriteHandler.java
@@ -68,7 +68,8 @@ public TcpReadWriteHandler(NioTcpChannel channel, PageCacheRecycler recycler, Tc
             threadPool::relativeTimeInMillis,
             breaker,
             requestHandlers::getHandler,
-            transport::inboundMessage
+            transport::inboundMessage,
+            transport::inboundMessageProtobuf
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/common/io/stream/TryWriteable.java b/server/src/main/java/org/opensearch/common/io/stream/TryWriteable.java
new file mode 100644
index 0000000000000..4815bf04e73e8
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/io/stream/TryWriteable.java
@@ -0,0 +1,78 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.common.io.stream;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
+/**
+ * Implementers can be written to write to output and read from input using Protobuf.
+*
+* @opensearch.internal
+*/
+public interface TryWriteable {
+
+    /**
+     * Write this into the stream output.
+    */
+    public void writeTo(OutputStream out) throws IOException;
+
+    /**
+     * Reference to a method that can write some object to a {@link OutputStream}.
+     * Most classes should implement {@link TryWriteable} and the {@link TryWriteable#writeTo(OutputStream)} method should <em>use</em>
+     * {@link OutputStream} methods directly or this indirectly:
+     * <pre><code>
+     * public void writeTo(CodedOutputStream out) throws IOException {
+     *     out.writeVInt(someValue);
+     * }
+     * </code></pre>
+     */
+    @FunctionalInterface
+    interface Writer<V> {
+
+        /**
+         * Write {@code V}-type {@code value} to the {@code out}put stream.
+        *
+        * @param out Output to write the {@code value} too
+        * @param value The value to add
+        */
+        void write(OutputStream out, V value) throws IOException;
+
+    }
+
+    /**
+     * Reference to a method that can read some object from a stream. By convention this is a constructor that takes
+     * {@linkplain byte[]} as an argument for most classes and a static method for things like enums.
+     * <pre><code>
+     * public MyClass(final CodedInputStream in) throws IOException {
+     *     this.someValue = in.readVInt();
+     * }
+     * </code></pre>
+     */
+    @FunctionalInterface
+    interface Reader<V> {
+
+        /**
+         * Read {@code V}-type value from a stream.
+        *
+        * @param in Input to read the value from
+        */
+        V read(byte[] in) throws IOException;
+
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java b/server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java
new file mode 100644
index 0000000000000..f9ea7c75351a6
--- /dev/null
+++ b/server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java
@@ -0,0 +1,78 @@
+/*
+* 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.
+*/
+
+/*
+* Modifications Copyright OpenSearch Contributors. See
+* GitHub history for details.
+*/
+
+package org.opensearch.example.proto;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.InvalidProtocolBufferException;
+
+import org.opensearch.common.io.stream.TryWriteable;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.example.proto.ExampleRequestProto.ExampleRequest;
+import org.opensearch.transport.TransportRequest;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ * Transport request for obtaining cluster state
+*
+* @opensearch.internal
+*/
+public class ExampleProtoRequest extends TransportRequest implements TryWriteable {
+
+    private ExampleRequest request;
+
+    public ExampleProtoRequest(int id, String message) {
+        this.request = ExampleRequest.newBuilder().setId(id).setMessage(message).build();
+    }
+
+    public ExampleProtoRequest(CodedInputStream in) throws IOException {
+        super(in);
+        System.out.println("ExampleProtoRequest constructor");
+        System.out.println("in: " + in);
+        this.request = ExampleRequest.parseFrom(in);
+    }
+
+    public ExampleProtoRequest(byte[] data) throws InvalidProtocolBufferException {
+        this.request = ExampleRequest.parseFrom(data);
+    }
+
+    @Override
+    public void writeTo(OutputStream out) throws IOException {
+        // super.writeTo(out);
+        out.write(this.request.toByteArray());
+    }
+
+    //add getters and setters
+    public int id() {
+        return request.getId();
+    }
+
+    public String message() {
+        return request.getMessage();
+    }
+
+    public ExampleRequest request() {
+        return request;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder();
+        builder.append("ExampleRequest[");
+        builder.append("header=").append(id());
+        builder.append(",message=").append(message());
+        return builder.append("]").toString();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/InboundHandler.java b/server/src/main/java/org/opensearch/transport/InboundHandler.java
index 090816285b47f..fb7f83e487eb6 100644
--- a/server/src/main/java/org/opensearch/transport/InboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/InboundHandler.java
@@ -37,6 +37,9 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.apache.lucene.util.BytesRef;
 import org.opensearch.Version;
+import org.opensearch.common.bytes.BytesReference;
+import org.opensearch.common.bytes.ReleasableBytesReference;
+import org.opensearch.common.collect.Tuple;
 import org.opensearch.core.common.io.stream.ByteBufferStreamInput;
 import org.opensearch.core.common.io.stream.NamedWriteableAwareStreamInput;
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
@@ -49,11 +52,14 @@
 import org.opensearch.threadpool.ThreadPool;
 
 import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.InvalidProtocolBufferException;
 
 import java.io.EOFException;
 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.nio.ByteBuffer;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * Handler for inbound data
@@ -132,11 +138,55 @@ void inboundMessage(TcpChannel channel, InboundMessage message) throws Exception
         }
     }
 
+    void inboundMessageProtobuf(TcpChannel channel, BytesReference message) throws InvalidProtocolBufferException {
+        System.out.println("InboundHandler.inboundMessageProtobuf");
+        System.out.println("message: " + message);
+        final long startTime = threadPool.relativeTimeInMillis();
+        channel.getChannelStats().markAccessed(startTime);
+        ProtobufOutboundMessage protobufOutboundMessage = new ProtobufOutboundMessage(BytesReference.toBytes(message)); 
+        messageReceivedProtobuf(channel, protobufOutboundMessage, startTime);
+    }
+
     // Empty stream constant to avoid instantiating a new stream for empty messages.
     private static final StreamInput EMPTY_STREAM_INPUT = new ByteBufferStreamInput(ByteBuffer.wrap(BytesRef.EMPTY_BYTES));
 
     private static final CodedInputStream EMPTY_CODED_INPUT_STREAM = CodedInputStream.newInstance(BytesRef.EMPTY_BYTES);
 
+    private void messageReceivedProtobuf(TcpChannel channel, ProtobufOutboundMessage message, long startTime) {
+        System.out.println("InboundHandler.messageReceivedProtobuf");
+        final InetSocketAddress remoteAddress = channel.getRemoteAddress();
+        final org.opensearch.example.proto.OutboundMessageProto.OutboundMsg.Header header = message.getHeader();
+        System.out.println("header: " + header);
+        System.out.println("message: " + message);
+        System.out.println("remoteAddress: " + remoteAddress);
+
+        ThreadContext threadContext = threadPool.getThreadContext();
+        try (ThreadContext.StoredContext existing = threadContext.stashContext()) {
+            // Place the context with the headers from the message
+            final Tuple<Map<String, String>, Map<String, Set<String>>> headers = new Tuple<Map<String,String>,Map<String,Set<String>>>(message.getRequestHeaders(), message.getResponseHandlers());
+            threadContext.setHeaders(headers);
+            threadContext.putTransient("_remote_address", remoteAddress);
+            if (TransportStatus.isRequest(header.getStatus().byteAt(0))) {
+                System.out.println("InboundHandler.messageReceivedProtobuf isRequest");
+                System.out.println("Header: " + header);
+                System.out.println("message: " + message);
+            } else {
+                System.out.println("InboundHandler.messageReceivedProtobuf isResponse");
+            }
+        } finally {
+            final long took = threadPool.relativeTimeInMillis() - startTime;
+            final long logThreshold = slowLogThresholdMs;
+            if (logThreshold > 0 && took > logThreshold) {
+                logger.warn(
+                    "handling inbound transport message [{}] took [{}ms] which is above the warn threshold of [{}ms]",
+                    message,
+                    took,
+                    logThreshold
+                );
+            }
+        }
+    }
+
     private void messageReceived(TcpChannel channel, InboundMessage message, long startTime) throws IOException {
         System.out.println("InboundHandler.messageReceived");
         final InetSocketAddress remoteAddress = channel.getRemoteAddress();
diff --git a/server/src/main/java/org/opensearch/transport/InboundPipeline.java b/server/src/main/java/org/opensearch/transport/InboundPipeline.java
index 7e5d72d3521c0..c770d8a8b8208 100644
--- a/server/src/main/java/org/opensearch/transport/InboundPipeline.java
+++ b/server/src/main/java/org/opensearch/transport/InboundPipeline.java
@@ -34,6 +34,7 @@
 
 import org.opensearch.Version;
 import org.opensearch.core.common.breaker.CircuitBreaker;
+import org.opensearch.common.bytes.BytesReference;
 import org.opensearch.core.common.bytes.CompositeBytesReference;
 import org.opensearch.common.bytes.ReleasableBytesReference;
 import org.opensearch.common.util.PageCacheRecycler;
@@ -43,6 +44,7 @@
 import java.io.IOException;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.function.BiConsumer;
 import java.util.function.Function;
 import java.util.function.LongSupplier;
@@ -63,6 +65,7 @@ public class InboundPipeline implements Releasable {
     private final InboundDecoder decoder;
     private final InboundAggregator aggregator;
     private final BiConsumer<TcpChannel, InboundMessage> messageHandler;
+    private final BiConsumer<TcpChannel, BytesReference> messageHandlerProtobuf;
     private Exception uncaughtException;
     private final ArrayDeque<ReleasableBytesReference> pending = new ArrayDeque<>(2);
     private boolean isClosed = false;
@@ -74,14 +77,16 @@ public InboundPipeline(
         LongSupplier relativeTimeInMillis,
         Supplier<CircuitBreaker> circuitBreaker,
         Function<String, RequestHandlerRegistry<TransportRequest>> registryFunction,
-        BiConsumer<TcpChannel, InboundMessage> messageHandler
+        BiConsumer<TcpChannel, InboundMessage> messageHandler,
+        BiConsumer<TcpChannel, BytesReference> messageHandlerProtobuf
     ) {
         this(
             statsTracker,
             relativeTimeInMillis,
             new InboundDecoder(version, recycler),
             new InboundAggregator(circuitBreaker, registryFunction),
-            messageHandler
+            messageHandler,
+            messageHandlerProtobuf
         );
     }
 
@@ -90,13 +95,15 @@ public InboundPipeline(
         LongSupplier relativeTimeInMillis,
         InboundDecoder decoder,
         InboundAggregator aggregator,
-        BiConsumer<TcpChannel, InboundMessage> messageHandler
+        BiConsumer<TcpChannel, InboundMessage> messageHandler,
+        BiConsumer<TcpChannel, BytesReference> messageHandlerProtobuf
     ) {
         this.relativeTimeInMillis = relativeTimeInMillis;
         this.statsTracker = statsTracker;
         this.decoder = decoder;
         this.aggregator = aggregator;
         this.messageHandler = messageHandler;
+        this.messageHandlerProtobuf = messageHandlerProtobuf;
     }
 
     @Override
@@ -127,41 +134,60 @@ public void handleBytes(TcpChannel channel, ReleasableBytesReference reference)
     }
 
     public void doHandleBytes(TcpChannel channel, ReleasableBytesReference reference) throws IOException {
-        channel.getChannelStats().markAccessed(relativeTimeInMillis.getAsLong());
-        statsTracker.markBytesRead(reference.length());
-        pending.add(reference.retain());
-
-        final ArrayList<Object> fragments = fragmentList.get();
-        boolean continueHandling = true;
-
-        while (continueHandling && isClosed == false) {
-            boolean continueDecoding = true;
-            while (continueDecoding && pending.isEmpty() == false) {
-                try (ReleasableBytesReference toDecode = getPendingBytes()) {
-                    final int bytesDecoded = decoder.decode(toDecode, fragments::add);
-                    if (bytesDecoded != 0) {
-                        releasePendingBytes(bytesDecoded);
-                        if (fragments.isEmpty() == false && endOfMessage(fragments.get(fragments.size() - 1))) {
+        try {
+            byte[] incomingBytes = BytesReference.toBytes(reference);
+            System.out.println("Size of incoming bytes: " + incomingBytes.length);
+            ProtobufOutboundMessage protobufOutboundMessage = new ProtobufOutboundMessage(incomingBytes);
+            if (protobufOutboundMessage.isProtobuf()) {
+                for (int i = 0; i < incomingBytes.length; i++) {
+                    System.out.println("Byte " + i + " is: " + incomingBytes[i]);
+                }
+                System.out.println("Last byte is 1");
+                forwardFragmentsProtobuf(channel, reference);
+                // byte[] newBytes = Arrays.copyOfRange(incomingBytes, 0, incomingBytes.length-1);
+                // reference = new ReleasableBytesReference(newBytes);
+
+                // ProtobufOutboundMessage protobufOutboundMessage = new ProtobufOutboundMessage(incomingBytes);
+                // System.out.println("Received protobuf message is: " + protobufOutboundMessage);
+            }
+        } catch (Exception e) {
+        
+            channel.getChannelStats().markAccessed(relativeTimeInMillis.getAsLong());
+            statsTracker.markBytesRead(reference.length());
+            pending.add(reference.retain());
+
+            final ArrayList<Object> fragments = fragmentList.get();
+            boolean continueHandling = true;
+
+            while (continueHandling && isClosed == false) {
+                boolean continueDecoding = true;
+                while (continueDecoding && pending.isEmpty() == false) {
+                    try (ReleasableBytesReference toDecode = getPendingBytes()) {
+                        final int bytesDecoded = decoder.decode(toDecode, fragments::add);
+                        if (bytesDecoded != 0) {
+                            releasePendingBytes(bytesDecoded);
+                            if (fragments.isEmpty() == false && endOfMessage(fragments.get(fragments.size() - 1))) {
+                                continueDecoding = false;
+                            }
+                        } else {
                             continueDecoding = false;
                         }
-                    } else {
-                        continueDecoding = false;
                     }
                 }
-            }
 
-            if (fragments.isEmpty()) {
-                continueHandling = false;
-            } else {
-                try {
-                    forwardFragments(channel, fragments);
-                } finally {
-                    for (Object fragment : fragments) {
-                        if (fragment instanceof ReleasableBytesReference) {
-                            ((ReleasableBytesReference) fragment).close();
+                if (fragments.isEmpty()) {
+                    continueHandling = false;
+                } else {
+                    try {
+                        forwardFragments(channel, fragments);
+                    } finally {
+                        for (Object fragment : fragments) {
+                            if (fragment instanceof ReleasableBytesReference) {
+                                ((ReleasableBytesReference) fragment).close();
+                            }
                         }
+                        fragments.clear();
                     }
-                    fragments.clear();
                 }
             }
         }
@@ -189,6 +215,11 @@ private void forwardFragments(TcpChannel channel, ArrayList<Object> fragments) t
         }
     }
 
+    private void forwardFragmentsProtobuf(TcpChannel channel, ReleasableBytesReference reference) throws IOException {
+        // ProtobufOutboundMessage message = new ProtobufOutboundMessage(BytesReference.toBytes(reference));
+        messageHandlerProtobuf.accept(channel, reference);
+    }
+
     private boolean endOfMessage(Object fragment) {
         return fragment == InboundDecoder.PING || fragment == InboundDecoder.END_CONTENT || fragment instanceof Exception;
     }
diff --git a/server/src/main/java/org/opensearch/transport/OutboundHandler.java b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
index 4645e61bccdba..90e6908382968 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
@@ -41,6 +41,7 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.CheckedSupplier;
 import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.common.io.stream.ReleasableBytesStreamOutput;
 import org.opensearch.common.network.CloseableChannel;
 import org.opensearch.common.transport.NetworkExceptionHelper;
@@ -50,6 +51,9 @@
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.example.proto.ExampleProtoRequest;
+import org.opensearch.example.proto.ExampleRequestProto.ExampleRequest;
+import org.opensearch.example.proto.OutboundMessageProto.OutboundMsg;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.lease.Releasables;
 import org.opensearch.threadpool.ThreadPool;
@@ -57,6 +61,7 @@
 import com.google.protobuf.CodedOutputStream;
 
 import java.io.IOException;
+import java.nio.ByteBuffer;
 import java.util.Set;
 
 /**
@@ -129,16 +134,16 @@ void sendRequest(
             isHandshake,
             compressRequest
         );
-        ProtobufOutboundMessage.Request protobufMessage = new ProtobufOutboundMessage.Request(
-            threadPool.getThreadContext(),
-            features,
-            request,
-            version,
-            action,
-            requestId,
-            isHandshake,
-            compressRequest
-        );
+        // ProtobufOutboundMessage.Request protobufMessage = new ProtobufOutboundMessage.Request(
+        //     threadPool.getThreadContext(),
+        //     features,
+        //     request,
+        //     version,
+        //     action,
+        //     requestId,
+        //     isHandshake,
+        //     compressRequest
+        // );
 
         System.out.println("OutboundHandler.sendRequest");
         System.out.println("node: " + node);
@@ -150,7 +155,8 @@ void sendRequest(
         System.out.println("message: " + message);
         ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onRequestSent(node, requestId, action, request, options));
         if (request.getClass().getCanonicalName().contains("ClusterState") && request.getClass().getCanonicalName().contains("Protobuf")) {
-            sendMessageProtobuf(channel, protobufMessage, listener);
+            ExampleProtoRequest exampleProtoRequest = new ExampleProtoRequest(1, "message");
+            sendProtobufRequest(node, channel, requestId, action, exampleProtoRequest, options, channelVersion, compressRequest, isHandshake);
         } else {
             sendMessage(channel, message, listener);
         }
@@ -161,6 +167,38 @@ void sendRequest(
         // }   
     }
 
+    void sendProtobufRequest(
+        final DiscoveryNode node,
+        final TcpChannel channel,
+        final long requestId,
+        final String action,
+        final ExampleProtoRequest request,
+        final TransportRequestOptions options,
+        final Version channelVersion,
+        final boolean compressRequest,
+        final boolean isHandshake
+    ) throws IOException, TransportException {
+        Version version = Version.min(this.version, channelVersion);
+
+        System.out.println("OutboundHandler.sendProtobufRequest");
+        System.out.println("node: " + node);
+        System.out.println("channel: " + channel);
+        System.out.println("requestId: " + requestId);
+        System.out.println("action: " + action);
+        System.out.println("request: " + request.toString());
+        System.out.println("canonical: " + request.getClass().getCanonicalName());
+        ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onRequestSent(node, requestId, action, request, options));
+        byte[] bytes = new byte[1];
+        bytes[0] = 0;
+        ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), request.request(), features, action);
+        sendProtobufMessage(channel, protobufMessage, listener);
+        // if (request.getClass().getCanonicalName().contains("Protobuf")) {
+        //     sendMessageProtobuf(channel, protobufMessage, listener);
+        // } else {
+            // sendMessage(channel, message, listener);
+        // }   
+    }
+
     /**
      * Sends the response to the given channel. This method should be used to send {@link TransportResponse}
      * objects back to the caller.
@@ -230,6 +268,14 @@ private void sendMessage(TcpChannel channel, OutboundMessage networkMessage, Act
         internalSend(channel, sendContext);
     }
 
+    private void sendProtobufMessage(TcpChannel channel, ProtobufOutboundMessage message, ActionListener<Void> listener) throws IOException {
+        System.out.println("OutboundHandler.sendProtobufMessage");
+        System.out.println("OutboundHandler.sendProtobufMessage networkMessage = " + message);
+        TryMessageSerializer serializer = new TryMessageSerializer(message, bigArrays);
+        SendContext sendContext = new SendContext(channel, serializer, listener, serializer);
+        internalSend(channel, sendContext);
+    }
+
     private void sendMessage1(TcpChannel channel, OutboundMessage networkMessage, ActionListener<Void> listener) throws IOException {
         System.out.println("OutboundHandler.sendMessage");
         System.out.println("OutboundHandler.sendMessage networkMessage = " + networkMessage);
@@ -238,14 +284,14 @@ private void sendMessage1(TcpChannel channel, OutboundMessage networkMessage, Ac
         internalSend(channel, sendContext);
     }
 
-    private void sendMessageProtobuf(TcpChannel channel, ProtobufOutboundMessage networkMessage, ActionListener<Void> listener) throws IOException {
-        System.out.println("OutboundHandler.sendMessageProtobuf");
-        System.out.println("OutboundHandler.sendMessageProtobuf networkMessage = " + networkMessage);
-        MessageSerializerProtobuf serializer = new MessageSerializerProtobuf(networkMessage, bigArrays);
-        SendContext sendContext = new SendContext(channel, serializer, listener, serializer);
-        System.out.println("attempting internal send for protobuf ");
-        internalSend(channel, sendContext);
-    }
+    // private void sendMessageProtobuf(TcpChannel channel, ProtobufOutboundMessage networkMessage, ActionListener<Void> listener) throws IOException {
+    //     System.out.println("OutboundHandler.sendMessageProtobuf");
+    //     System.out.println("OutboundHandler.sendMessageProtobuf networkMessage = " + networkMessage);
+    //     MessageSerializerProtobuf serializer = new MessageSerializerProtobuf(networkMessage, bigArrays);
+    //     SendContext sendContext = new SendContext(channel, serializer, listener, serializer);
+    //     System.out.println("attempting internal send for protobuf ");
+    //     internalSend(channel, sendContext);
+    // }
 
     private void internalSend(TcpChannel channel, SendContext sendContext) throws IOException {
         System.out.println("In internal send");
@@ -309,27 +355,36 @@ public void close() {
         }
     }
 
-    /**
-     * Internal message serializer
-     *
-     * @opensearch.internal
-     */
-    private static class MessageSerializer1 implements CheckedSupplier<BytesReference, IOException>, Releasable {
+    private static class TryMessageSerializer implements CheckedSupplier<BytesReference, IOException>, Releasable {
 
-        private final OutboundMessage message;
+        private final ProtobufOutboundMessage message;
         private final BigArrays bigArrays;
         private volatile ReleasableBytesStreamOutput bytesStreamOutput;
 
-        private MessageSerializer1(OutboundMessage message, BigArrays bigArrays) {
+        private TryMessageSerializer(ProtobufOutboundMessage message, BigArrays bigArrays) {
             this.message = message;
             this.bigArrays = bigArrays;
         }
 
         @Override
         public BytesReference get() throws IOException {
-            System.out.println("OutboundHandler.MessageSerializer.get");
+            System.out.println("OutboundHandler.TryMessageSerializer.get");
             bytesStreamOutput = new ReleasableBytesStreamOutput(bigArrays);
-            return message.serialize1(bytesStreamOutput);
+            BytesReference reference = serialize(bytesStreamOutput); 
+            System.out.println("Bytes serialized length: " + reference.length());
+            System.out.println("Bytes serialized: " + reference);
+            System.out.println("Now the bytes: ");
+            for (int i = 0; i < reference.length(); i++) {
+                System.out.print(reference.get(i) + " ");
+            }
+            System.out.println();
+            return reference;
+        }
+
+        private BytesReference serialize(BytesStreamOutput bytesStream) throws IOException {
+            ByteBuffer byteBuffers = ByteBuffer.wrap(message.getMessage().toByteArray()); 
+            message.getMessage().writeTo(bytesStream);
+            return BytesReference.fromByteBuffer(byteBuffers);
         }
 
         @Override
@@ -343,13 +398,13 @@ public void close() {
      *
      * @opensearch.internal
      */
-    private static class MessageSerializerProtobuf implements CheckedSupplier<BytesReference, IOException>, Releasable {
+    private static class MessageSerializer1 implements CheckedSupplier<BytesReference, IOException>, Releasable {
 
-        private final ProtobufOutboundMessage message;
+        private final OutboundMessage message;
         private final BigArrays bigArrays;
         private volatile ReleasableBytesStreamOutput bytesStreamOutput;
 
-        private MessageSerializerProtobuf(ProtobufOutboundMessage message, BigArrays bigArrays) {
+        private MessageSerializer1(OutboundMessage message, BigArrays bigArrays) {
             this.message = message;
             this.bigArrays = bigArrays;
         }
@@ -358,7 +413,7 @@ private MessageSerializerProtobuf(ProtobufOutboundMessage message, BigArrays big
         public BytesReference get() throws IOException {
             System.out.println("OutboundHandler.MessageSerializer.get");
             bytesStreamOutput = new ReleasableBytesStreamOutput(bigArrays);
-            return message.serialize(bytesStreamOutput);
+            return message.serialize1(bytesStreamOutput);
         }
 
         @Override
@@ -367,6 +422,35 @@ public void close() {
         }
     }
 
+    // /**
+    //  * Internal message serializer
+    //  *
+    //  * @opensearch.internal
+    //  */
+    // private static class MessageSerializerProtobuf implements CheckedSupplier<BytesReference, IOException>, Releasable {
+
+    //     private final ProtobufOutboundMessage message;
+    //     private final BigArrays bigArrays;
+    //     private volatile ReleasableBytesStreamOutput bytesStreamOutput;
+
+    //     private MessageSerializerProtobuf(ProtobufOutboundMessage message, BigArrays bigArrays) {
+    //         this.message = message;
+    //         this.bigArrays = bigArrays;
+    //     }
+
+    //     @Override
+    //     public BytesReference get() throws IOException {
+    //         System.out.println("OutboundHandler.MessageSerializer.get");
+    //         bytesStreamOutput = new ReleasableBytesStreamOutput(bigArrays);
+    //         return message.serialize(bytesStreamOutput);
+    //     }
+
+    //     @Override
+    //     public void close() {
+    //         IOUtils.closeWhileHandlingException(bytesStreamOutput);
+    //     }
+    // }
+
     private class SendContext extends NotifyOnceListener<Void> implements CheckedSupplier<BytesReference, IOException> {
 
         private final TcpChannel channel;
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java b/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
index dcaa560efc89d..20204fef3bcb4 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
@@ -8,279 +8,361 @@
 
 package org.opensearch.transport;
 
-import com.google.protobuf.CodedOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
 import org.opensearch.Version;
-import org.opensearch.common.bytes.BytesArray;
-import org.opensearch.common.bytes.BytesReference;
-import org.opensearch.common.bytes.CompositeBytesReference;
-import org.opensearch.common.io.stream.BytesStreamOutput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.io.stream.StreamOutput;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.example.proto.ExampleRequestProto.ExampleRequest;
+import org.opensearch.example.proto.OutboundMessageProto.OutboundMsg;
+import org.opensearch.example.proto.OutboundMessageProto.OutboundMsg.Header;
+import org.opensearch.example.proto.OutboundMessageProto.OutboundMsg.ResponseHandlersList;
 
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.util.Set;
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
 
 /**
  * Outbound data as a message
 *
 * @opensearch.internal
 */
-abstract class ProtobufOutboundMessage extends NetworkMessage {
-
-    private final TransportMessage message;
-
-    ProtobufOutboundMessage(ThreadContext threadContext, Version version, byte status, long requestId, TransportMessage message) {
-        super(threadContext, version, status, requestId);
-        this.message = message;
+public class ProtobufOutboundMessage {
+
+    private final OutboundMsg message;
+    private static final byte[] PREFIX = { (byte) 'E', (byte) 'S' };
+
+    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, ExampleRequest exampleRequest, String[] features, String action) {
+        Header header = Header.newBuilder()
+                            .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
+                            .setRequestId(requestId)
+                            .setStatus(ByteString.copyFrom(status))
+                            .setVersionId(version.id)
+                            .build();
+        Map<String, String> requestHeaders = threadContext.getHeaders();
+        Map<String, List<String>> responseHeaders = threadContext.getResponseHeaders();
+        Map<String, ResponseHandlersList> responseHandlers = new HashMap<>();
+        for (Map.Entry<String, List<String>> entry : responseHeaders.entrySet()) {
+            String key = entry.getKey();
+            List<String> value = entry.getValue();
+            ResponseHandlersList responseHandlersList = ResponseHandlersList.newBuilder()
+                                                                        .addAllSetOfResponseHandlers(value)
+                                                                        .build();
+            responseHandlers.put(key, responseHandlersList);
+        }
+        this.message = OutboundMsg.newBuilder()
+                            .setHeader(header)
+                            .putAllRequestHeaders(requestHeaders)
+                            .putAllResponseHandlers(responseHandlers)
+                            .setVersion(version.toString())
+                            .setStatus(ByteString.copyFrom(status))
+                            .setRequestId(requestId)
+                            .setMessage(exampleRequest)
+                            .setAction(action)
+                            .addAllFeatures(Arrays.asList(features))
+                            .setIsProtobuf(true)
+                            .build();
+                            
     }
 
-    BytesReference serialize(BytesStreamOutput bytesStream) throws IOException {
-        // TcpHeader.writeHeaderProtobuf(outputStream, requestId, status, version, TcpHeader.headerSize(version), TcpHeader.headerSize(version));
-        // writeVariableHeader(outputStream);
-        // message.writeTo(outputStream);
-        // System.out.println("Inside ProtobufOutboundMessage.serialize");
-        // CodedOutputStream codedOutputStream = CodedOutputStream.newInstance(bytesStream);
-        // ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(codedOutputStream);
-        // protobufStreamOutput.setVersion(version);
-        // // bytesStream.setVersion(version);
-        // // bytesStream.skip(TcpHeader.headerSize(version));
-
-        // // The compressible bytes stream will not close the underlying bytes stream
-        // BytesReference reference;
-        // int variableHeaderLength = -1;
-        // final long preHeaderPosition = codedOutputStream.getTotalBytesWritten();
-        // writeVariableHeader(codedOutputStream);
-        // variableHeaderLength = Math.toIntExact(codedOutputStream.getTotalBytesWritten() - preHeaderPosition);
-
-        // protobufStreamOutput.setFeatures(bytesStream.getFeatures());
-        // if (variableHeaderLength == -1) {
-        //         writeVariableHeader(codedOutputStream);
-        // }
-        // reference = writeMessage(codedOutputStream);
-        // // try (CompressibleBytesOutputStream stream = new CompressibleBytesOutputStream(bytesStream, TransportStatus.isCompress(status))) {
-        // //     stream.setVersion(version);
-        // //     stream.setFeatures(bytesStream.getFeatures());
-
-        // //     if (variableHeaderLength == -1) {
-        // //         writeVariableHeader(stream);
-        // //     }
-        // //     reference = writeMessage(stream);
-        // // }
-
-        // // bytesStream.seek(0);
-        // final int contentSize = reference.length() - TcpHeader.headerSize(version);
-        // TcpHeader.writeHeaderProtobuf(codedOutputStream, requestId, status, version, contentSize, variableHeaderLength);
-        // System.out.println("Bytes serialized length: " + reference.length());
-        // System.out.println("Bytes serialized: " + reference);
-        // System.out.println("Now the bytes: ");
-        // for (int i = 0; i < reference.length(); i++) {
-        //     System.out.print(reference.get(i) + " ");
-        // }
-        // System.out.println();
-        // return reference;
-
-        
-        bytesStream.setVersion(version);
-        bytesStream.skip(TcpHeader.headerSize(version));
-
-        // The compressible bytes stream will not close the underlying bytes stream
-        BytesReference reference;
-        int variableHeaderLength = -1;
-        final long preHeaderPosition = bytesStream.position();
-        writeVariableHeader(bytesStream);
-        variableHeaderLength = Math.toIntExact(bytesStream.position() - preHeaderPosition);
-
-        try (CompressibleBytesOutputStream stream = new CompressibleBytesOutputStream(bytesStream, TransportStatus.isCompress(status))) {
-            stream.setVersion(version);
-            stream.setFeatures(bytesStream.getFeatures());
-
-            if (variableHeaderLength == -1) {
-                writeVariableHeader(stream);
-            }
-            reference = writeMessage(stream);
-        }
+    public ProtobufOutboundMessage(byte[] data) throws InvalidProtocolBufferException {
+        this.message = OutboundMsg.parseFrom(data);
+    }
 
-        bytesStream.seek(0);
-        final int contentSize = reference.length() - TcpHeader.headerSize(version);
-        TcpHeader.writeHeader(bytesStream, requestId, status, version, contentSize, variableHeaderLength);
-        System.out.println("Bytes serialized length: " + reference.length());
-        System.out.println("Bytes serialized: " + reference);
-        System.out.println("Now the bytes: ");
-        for (int i = 0; i < reference.length(); i++) {
-            System.out.print(reference.get(i) + " ");
-        }
-        System.out.println();
-        // convert output stream to bytes
-        // ByteArrayOutputStream baos = new ByteArrayOutputStream();
-        // baos.write(outputStream);
-        // outputStream.writeTo(baos);
-        // byte[] bytes = baos.toByteArray();
-        // System.out.println("Bytes serialized length: " + bytes.length);
-        // System.out.println("Bytes serialized: " + bytes);
-        // System.out.println("Now the bytes: ");
-
-        return reference;
+    public void writeTo(OutputStream out) throws IOException {
+        // super.writeTo(out);
+        out.write(this.message.toByteArray());
     }
 
-    protected void writeVariableHeader(StreamOutput stream) throws IOException {
-        threadContext.writeTo(stream);
+    public OutboundMsg getMessage() {
+        return this.message;
     }
 
-    protected BytesReference writeMessage(CompressibleBytesOutputStream stream) throws IOException {
-        // final BytesReference zeroCopyBuffer;
-        // if (message instanceof BytesTransportRequest) {
-        //     BytesTransportRequest bRequest = (BytesTransportRequest) message;
-        //     bRequest.writeThinProtobuf(stream);
-        //     zeroCopyBuffer = bRequest.bytes;
-        // } else if (message instanceof ProtobufRemoteTransportException) {
-        //     ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(stream);
-        //     protobufStreamOutput.writeException((ProtobufRemoteTransportException) message);
-        //     zeroCopyBuffer = BytesArray.EMPTY;
-        // } else {
-        //     message.writeTo(stream);
-        //     zeroCopyBuffer = BytesArray.EMPTY;
-        // }
-        // // we have to call materializeBytes() here before accessing the bytes. A CompressibleBytesOutputStream
-        // // might be implementing compression. And materializeBytes() ensures that some marker bytes (EOS marker)
-        // // are written. Otherwise we barf on the decompressing end when we read past EOF on purpose in the
-        // // #validateRequest method. this might be a problem in deflate after all but it's important to write
-        // // the marker bytes.
-        // ByteBuffer byteBuffer = ByteBuffer.wrap(bytes);
-        // final BytesReference message = stream
-        // if (zeroCopyBuffer.length() == 0) {
-        //     return message;
-        // } else {
-        //     return CompositeBytesReference.of(message, zeroCopyBuffer);
-        // }
-        final BytesReference zeroCopyBuffer;
-        if (message instanceof BytesTransportRequest) {
-            BytesTransportRequest bRequest = (BytesTransportRequest) message;
-            bRequest.writeThin(stream);
-            zeroCopyBuffer = bRequest.bytes;
-        // } else if (message instanceof RemoteTransportException) {
-        //     stream.writeException((RemoteTransportException) message);
-        //     zeroCopyBuffer = BytesArray.EMPTY;
-        } else {
-            // CodedOutputStream outputStream = CodedOutputStream.newInstance(stream);
-            message.writeTo(stream);
-            zeroCopyBuffer = BytesArray.EMPTY;
-        }
-        // we have to call materializeBytes() here before accessing the bytes. A CompressibleBytesOutputStream
-        // might be implementing compression. And materializeBytes() ensures that some marker bytes (EOS marker)
-        // are written. Otherwise we barf on the decompressing end when we read past EOF on purpose in the
-        // #validateRequest method. this might be a problem in deflate after all but it's important to write
-        // the marker bytes.
-        final BytesReference message = stream.materializeBytes();
-        if (zeroCopyBuffer.length() == 0) {
-            return message;
-        } else {
-            return CompositeBytesReference.of(message, zeroCopyBuffer);
-        }
+    @Override
+    public String toString() {
+        return "ProtobufOutboundMessage [message=" + message + "]";
     }
 
-    /**
-     * Internal outbound message request
-    *
-    * @opensearch.internal
-    */
-    static class Request extends ProtobufOutboundMessage {
-
-        private final String[] features;
-        private final String action;
-
-        Request(
-            ThreadContext threadContext,
-            String[] features,
-            TransportMessage message,
-            Version version,
-            String action,
-            long requestId,
-            boolean isHandshake,
-            boolean compress
-        ) {
-            super(threadContext, version, setStatus(compress, isHandshake, message), requestId, message);
-            this.features = features;
-            this.action = action;
-        }
+    public Header getHeader() {
+        return this.message.getHeader();
+    }
 
-        @Override
-        protected void writeVariableHeader(StreamOutput stream) throws IOException {
-            // super.writeVariableHeader(out);
-            // ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            // protobufStreamOutput.writeStringArray(features);
-            // out.writeStringNoTag(action);
-            super.writeVariableHeader(stream);
-            stream.writeStringArray(features);
-            stream.writeString(action);
-        }
+    public Map<String, String> getRequestHeaders() {
+        return this.message.getRequestHeadersMap();
+    }
 
-        private static byte setStatus(boolean compress, boolean isHandshake, TransportMessage message) {
-            byte status = 0;
-            status = TransportStatus.setRequest(status);
-            if (compress && ProtobufOutboundMessage.canCompress(message)) {
-                status = TransportStatus.setCompress(status);
-            }
-            if (isHandshake) {
-                status = TransportStatus.setHandshake(status);
-            }
-
-            return status;
+    public Map<String, Set<String>> getResponseHandlers() {
+        Map<String, ResponseHandlersList> responseHandlers = this.message.getResponseHandlersMap();
+        Map<String, Set<String>> responseHandlersMap = new HashMap<>();
+        for (Map.Entry<String, ResponseHandlersList> entry : responseHandlers.entrySet()) {
+            String key = entry.getKey();
+            ResponseHandlersList value = entry.getValue();
+            Set<String> setOfResponseHandlers = value.getSetOfResponseHandlersList().stream().collect(Collectors.toSet());
+            responseHandlersMap.put(key, setOfResponseHandlers);
         }
+        return responseHandlersMap;
     }
 
-    /**
-     * Internal message response
-    *
-    * @opensearch.internal
-    */
-    static class Response extends ProtobufOutboundMessage {
-
-        private final Set<String> features;
-
-        Response(
-            ThreadContext threadContext,
-            Set<String> features,
-            TransportMessage message,
-            Version version,
-            long requestId,
-            boolean isHandshake,
-            boolean compress
-        ) {
-            super(threadContext, version, setStatus(compress, isHandshake, message), requestId, message);
-            this.features = features;
-        }
+    public boolean isProtobuf() {
+        return this.message.getIsProtobuf();
+    }
 
-        @Override
-        protected void writeVariableHeader(StreamOutput stream) throws IOException {
-            // super.writeVariableHeader(out);
-            // ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            // protobufStreamOutput.setFeatures(features);
-            super.writeVariableHeader(stream);
-            stream.setFeatures(features);
-        }
 
-        private static byte setStatus(boolean compress, boolean isHandshake, TransportMessage message) {
-            byte status = 0;
-            status = TransportStatus.setResponse(status);
-            // if (message instanceof RemoteTransportException) {
-            //     status = TransportStatus.setError(status);
-            // }
-            if (compress) {
-                status = TransportStatus.setCompress(status);
-            }
-            if (isHandshake) {
-                status = TransportStatus.setHandshake(status);
-            }
-
-            return status;
-        }
-    }
+    // private final TransportMessage message;
+
+    // ProtobufOutboundMessage(ThreadContext threadContext, Version version, byte status, long requestId, TransportMessage message) {
+    //     super(threadContext, version, status, requestId);
+    //     this.message = message;
+    // }
+
+    // BytesReference serialize(BytesStreamOutput bytesStream) throws IOException {
+    //     // TcpHeader.writeHeaderProtobuf(outputStream, requestId, status, version, TcpHeader.headerSize(version), TcpHeader.headerSize(version));
+    //     // writeVariableHeader(outputStream);
+    //     // message.writeTo(outputStream);
+    //     // System.out.println("Inside ProtobufOutboundMessage.serialize");
+    //     // CodedOutputStream codedOutputStream = CodedOutputStream.newInstance(bytesStream);
+    //     // ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(codedOutputStream);
+    //     // protobufStreamOutput.setVersion(version);
+    //     // // bytesStream.setVersion(version);
+    //     // // bytesStream.skip(TcpHeader.headerSize(version));
+
+    //     // // The compressible bytes stream will not close the underlying bytes stream
+    //     // BytesReference reference;
+    //     // int variableHeaderLength = -1;
+    //     // final long preHeaderPosition = codedOutputStream.getTotalBytesWritten();
+    //     // writeVariableHeader(codedOutputStream);
+    //     // variableHeaderLength = Math.toIntExact(codedOutputStream.getTotalBytesWritten() - preHeaderPosition);
+
+    //     // protobufStreamOutput.setFeatures(bytesStream.getFeatures());
+    //     // if (variableHeaderLength == -1) {
+    //     //         writeVariableHeader(codedOutputStream);
+    //     // }
+    //     // reference = writeMessage(codedOutputStream);
+    //     // // try (CompressibleBytesOutputStream stream = new CompressibleBytesOutputStream(bytesStream, TransportStatus.isCompress(status))) {
+    //     // //     stream.setVersion(version);
+    //     // //     stream.setFeatures(bytesStream.getFeatures());
+
+    //     // //     if (variableHeaderLength == -1) {
+    //     // //         writeVariableHeader(stream);
+    //     // //     }
+    //     // //     reference = writeMessage(stream);
+    //     // // }
+
+    //     // // bytesStream.seek(0);
+    //     // final int contentSize = reference.length() - TcpHeader.headerSize(version);
+    //     // TcpHeader.writeHeaderProtobuf(codedOutputStream, requestId, status, version, contentSize, variableHeaderLength);
+    //     // System.out.println("Bytes serialized length: " + reference.length());
+    //     // System.out.println("Bytes serialized: " + reference);
+    //     // System.out.println("Now the bytes: ");
+    //     // for (int i = 0; i < reference.length(); i++) {
+    //     //     System.out.print(reference.get(i) + " ");
+    //     // }
+    //     // System.out.println();
+    //     // return reference;
 
-    private static boolean canCompress(TransportMessage message) {
-        return message instanceof ProtobufBytesTransportRequest == false;
-    }
+        
+    //     bytesStream.setVersion(version);
+    //     bytesStream.skip(TcpHeader.headerSize(version));
+
+    //     // The compressible bytes stream will not close the underlying bytes stream
+    //     BytesReference reference;
+    //     int variableHeaderLength = -1;
+    //     final long preHeaderPosition = bytesStream.position();
+    //     writeVariableHeader(bytesStream);
+    //     variableHeaderLength = Math.toIntExact(bytesStream.position() - preHeaderPosition);
+
+    //     try (CompressibleBytesOutputStream stream = new CompressibleBytesOutputStream(bytesStream, TransportStatus.isCompress(status))) {
+    //         stream.setVersion(version);
+    //         stream.setFeatures(bytesStream.getFeatures());
+
+    //         if (variableHeaderLength == -1) {
+    //             writeVariableHeader(stream);
+    //         }
+    //         reference = writeMessage(stream);
+    //     }
+
+    //     bytesStream.seek(0);
+    //     final int contentSize = reference.length() - TcpHeader.headerSize(version);
+    //     TcpHeader.writeHeader(bytesStream, requestId, status, version, contentSize, variableHeaderLength);
+    //     System.out.println("Bytes serialized length: " + reference.length());
+    //     System.out.println("Bytes serialized: " + reference);
+    //     System.out.println("Now the bytes: ");
+    //     for (int i = 0; i < reference.length(); i++) {
+    //         System.out.print(reference.get(i) + " ");
+    //     }
+    //     System.out.println();
+    //     // convert output stream to bytes
+    //     // ByteArrayOutputStream baos = new ByteArrayOutputStream();
+    //     // baos.write(outputStream);
+    //     // outputStream.writeTo(baos);
+    //     // byte[] bytes = baos.toByteArray();
+    //     // System.out.println("Bytes serialized length: " + bytes.length);
+    //     // System.out.println("Bytes serialized: " + bytes);
+    //     // System.out.println("Now the bytes: ");
+
+    //     return reference;
+    // }
+
+    // protected void writeVariableHeader(StreamOutput stream) throws IOException {
+    //     threadContext.writeTo(stream);
+    // }
+
+    // protected BytesReference writeMessage(CompressibleBytesOutputStream stream) throws IOException {
+    //     // final BytesReference zeroCopyBuffer;
+    //     // if (message instanceof BytesTransportRequest) {
+    //     //     BytesTransportRequest bRequest = (BytesTransportRequest) message;
+    //     //     bRequest.writeThinProtobuf(stream);
+    //     //     zeroCopyBuffer = bRequest.bytes;
+    //     // } else if (message instanceof ProtobufRemoteTransportException) {
+    //     //     ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(stream);
+    //     //     protobufStreamOutput.writeException((ProtobufRemoteTransportException) message);
+    //     //     zeroCopyBuffer = BytesArray.EMPTY;
+    //     // } else {
+    //     //     message.writeTo(stream);
+    //     //     zeroCopyBuffer = BytesArray.EMPTY;
+    //     // }
+    //     // // we have to call materializeBytes() here before accessing the bytes. A CompressibleBytesOutputStream
+    //     // // might be implementing compression. And materializeBytes() ensures that some marker bytes (EOS marker)
+    //     // // are written. Otherwise we barf on the decompressing end when we read past EOF on purpose in the
+    //     // // #validateRequest method. this might be a problem in deflate after all but it's important to write
+    //     // // the marker bytes.
+    //     // ByteBuffer byteBuffer = ByteBuffer.wrap(bytes);
+    //     // final BytesReference message = stream
+    //     // if (zeroCopyBuffer.length() == 0) {
+    //     //     return message;
+    //     // } else {
+    //     //     return CompositeBytesReference.of(message, zeroCopyBuffer);
+    //     // }
+    //     final BytesReference zeroCopyBuffer;
+    //     if (message instanceof BytesTransportRequest) {
+    //         BytesTransportRequest bRequest = (BytesTransportRequest) message;
+    //         bRequest.writeThin(stream);
+    //         zeroCopyBuffer = bRequest.bytes;
+    //     // } else if (message instanceof RemoteTransportException) {
+    //     //     stream.writeException((RemoteTransportException) message);
+    //     //     zeroCopyBuffer = BytesArray.EMPTY;
+    //     } else {
+    //         // CodedOutputStream outputStream = CodedOutputStream.newInstance(stream);
+    //         message.writeTo(stream);
+    //         zeroCopyBuffer = BytesArray.EMPTY;
+    //     }
+    //     // we have to call materializeBytes() here before accessing the bytes. A CompressibleBytesOutputStream
+    //     // might be implementing compression. And materializeBytes() ensures that some marker bytes (EOS marker)
+    //     // are written. Otherwise we barf on the decompressing end when we read past EOF on purpose in the
+    //     // #validateRequest method. this might be a problem in deflate after all but it's important to write
+    //     // the marker bytes.
+    //     final BytesReference message = stream.materializeBytes();
+    //     if (zeroCopyBuffer.length() == 0) {
+    //         return message;
+    //     } else {
+    //         return CompositeBytesReference.of(message, zeroCopyBuffer);
+    //     }
+    // }
+
+    // /**
+    //  * Internal outbound message request
+    // *
+    // * @opensearch.internal
+    // */
+    // static class Request extends ProtobufOutboundMessage {
+
+    //     private final String[] features;
+    //     private final String action;
+
+    //     Request(
+    //         ThreadContext threadContext,
+    //         String[] features,
+    //         TransportMessage message,
+    //         Version version,
+    //         String action,
+    //         long requestId,
+    //         boolean isHandshake,
+    //         boolean compress
+    //     ) {
+    //         super(threadContext, version, setStatus(compress, isHandshake, message), requestId, message);
+    //         this.features = features;
+    //         this.action = action;
+    //     }
+
+    //     @Override
+    //     protected void writeVariableHeader(StreamOutput stream) throws IOException {
+    //         // super.writeVariableHeader(out);
+    //         // ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+    //         // protobufStreamOutput.writeStringArray(features);
+    //         // out.writeStringNoTag(action);
+    //         super.writeVariableHeader(stream);
+    //         stream.writeStringArray(features);
+    //         stream.writeString(action);
+    //     }
+
+    //     private static byte setStatus(boolean compress, boolean isHandshake, TransportMessage message) {
+    //         byte status = 0;
+    //         status = TransportStatus.setRequest(status);
+    //         if (compress && ProtobufOutboundMessage.canCompress(message)) {
+    //             status = TransportStatus.setCompress(status);
+    //         }
+    //         if (isHandshake) {
+    //             status = TransportStatus.setHandshake(status);
+    //         }
+
+    //         return status;
+    //     }
+    // }
+
+    // /**
+    //  * Internal message response
+    // *
+    // * @opensearch.internal
+    // */
+    // static class Response extends ProtobufOutboundMessage {
+
+    //     private final Set<String> features;
+
+    //     Response(
+    //         ThreadContext threadContext,
+    //         Set<String> features,
+    //         TransportMessage message,
+    //         Version version,
+    //         long requestId,
+    //         boolean isHandshake,
+    //         boolean compress
+    //     ) {
+    //         super(threadContext, version, setStatus(compress, isHandshake, message), requestId, message);
+    //         this.features = features;
+    //     }
+
+    //     @Override
+    //     protected void writeVariableHeader(StreamOutput stream) throws IOException {
+    //         // super.writeVariableHeader(out);
+    //         // ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+    //         // protobufStreamOutput.setFeatures(features);
+    //         super.writeVariableHeader(stream);
+    //         stream.setFeatures(features);
+    //     }
+
+    //     private static byte setStatus(boolean compress, boolean isHandshake, TransportMessage message) {
+    //         byte status = 0;
+    //         status = TransportStatus.setResponse(status);
+    //         // if (message instanceof RemoteTransportException) {
+    //         //     status = TransportStatus.setError(status);
+    //         // }
+    //         if (compress) {
+    //             status = TransportStatus.setCompress(status);
+    //         }
+    //         if (isHandshake) {
+    //             status = TransportStatus.setHandshake(status);
+    //         }
+
+    //         return status;
+    //     }
+    // }
+
+    // private static boolean canCompress(TransportMessage message) {
+    //     return message instanceof ProtobufBytesTransportRequest == false;
+    // }
 }
diff --git a/server/src/main/java/org/opensearch/transport/TcpTransport.java b/server/src/main/java/org/opensearch/transport/TcpTransport.java
index 162f917eabbc5..fffc3e359e11c 100644
--- a/server/src/main/java/org/opensearch/transport/TcpTransport.java
+++ b/server/src/main/java/org/opensearch/transport/TcpTransport.java
@@ -837,6 +837,13 @@ public void inboundMessage(TcpChannel channel, InboundMessage message) {
         }
     }
 
+    public void inboundMessageProtobuf(TcpChannel channel, BytesReference message) {
+        try {
+            inboundHandler.inboundMessageProtobuf(channel, message);
+        } catch (Exception e) {
+            onException(channel, e);
+        }
+    }
     /**
      * Validates the first 6 bytes of the message header and returns the length of the message. If 6 bytes
      * are not available, it returns -1.
@@ -858,6 +865,9 @@ public static int readMessageLength(BytesReference networkBytes) throws IOExcept
 
     private static int readHeaderBuffer(BytesReference headerBuffer) throws IOException {
         if (headerBuffer.get(0) != 'E' || headerBuffer.get(1) != 'S') {
+            System.out.println("headerBuffer: " + headerBuffer);
+            System.out.println("headerBuffer.get(0): " + headerBuffer.get(0));
+            System.out.println("headerBuffer.get(1): " + headerBuffer.get(1));
             if (appearsToBeHTTPRequest(headerBuffer)) {
                 throw new HttpRequestOnTransportException("This is not an HTTP port");
             }
diff --git a/server/src/main/proto/examples/ExampleRequestProto.proto b/server/src/main/proto/examples/ExampleRequestProto.proto
new file mode 100644
index 0000000000000..48d2f8de963a9
--- /dev/null
+++ b/server/src/main/proto/examples/ExampleRequestProto.proto
@@ -0,0 +1,20 @@
+/*
+ * 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.
+ *
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+syntax = "proto3";
+package org.opensearch.example.proto;
+
+option java_outer_classname = "ExampleRequestProto";
+
+message ExampleRequest {
+  int32 id = 1;
+  string message = 2;
+}
diff --git a/server/src/main/proto/examples/OutboundMessageProto.proto b/server/src/main/proto/examples/OutboundMessageProto.proto
new file mode 100644
index 0000000000000..68721910c3f89
--- /dev/null
+++ b/server/src/main/proto/examples/OutboundMessageProto.proto
@@ -0,0 +1,41 @@
+/*
+ * 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.
+ *
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+syntax = "proto3";
+package org.opensearch.example.proto;
+
+import "examples/ExampleRequestProto.proto";
+
+option java_outer_classname = "OutboundMessageProto";
+
+message OutboundMsg {
+  Header header = 1;
+  map<string, string> requestHeaders = 2;
+  map<string, ResponseHandlersList> responseHandlers = 3;
+  string version = 4;
+  repeated string features = 5;
+  bytes status = 6;
+  string action = 7;
+  int64 requestId = 8;
+  ExampleRequest message = 9;
+  bool isProtobuf = 10;
+  
+  message Header {
+    repeated bytes prefix = 1;
+    int64 requestId = 2;
+    bytes status = 3;
+    int32 versionId = 4;
+  }
+
+  message ResponseHandlersList {
+    repeated string setOfResponseHandlers = 1;
+  }
+}
diff --git a/server/src/test/java/org/opensearch/transport/InboundPipelineTests.java b/server/src/test/java/org/opensearch/transport/InboundPipelineTests.java
index c6b16d70fc7e0..9d9d2051e7382 100644
--- a/server/src/test/java/org/opensearch/transport/InboundPipelineTests.java
+++ b/server/src/test/java/org/opensearch/transport/InboundPipelineTests.java
@@ -94,6 +94,7 @@ public void testPipelineHandling() throws IOException {
                 throw new AssertionError(e);
             }
         };
+        final BiConsumer<TcpChannel, BytesReference> messageHandlerProtobuf = (c, m) -> {};
 
         final StatsTracker statsTracker = new StatsTracker();
         final LongSupplier millisSupplier = () -> TimeValue.nsecToMSec(System.nanoTime());
@@ -104,7 +105,7 @@ public void testPipelineHandling() throws IOException {
         final TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
         circuitBreaker.startBreaking();
         final InboundAggregator aggregator = new InboundAggregator(() -> circuitBreaker, canTripBreaker);
-        final InboundPipeline pipeline = new InboundPipeline(statsTracker, millisSupplier, decoder, aggregator, messageHandler);
+        final InboundPipeline pipeline = new InboundPipeline(statsTracker, millisSupplier, decoder, aggregator, messageHandler, messageHandlerProtobuf);
         final FakeTcpChannel channel = new FakeTcpChannel();
 
         final int iterations = randomIntBetween(5, 10);
@@ -215,12 +216,13 @@ public void testPipelineHandling() throws IOException {
 
     public void testDecodeExceptionIsPropagated() throws IOException {
         BiConsumer<TcpChannel, InboundMessage> messageHandler = (c, m) -> {};
+        final BiConsumer<TcpChannel, BytesReference> messageHandlerProtobuf = (c, m) -> {};
         final StatsTracker statsTracker = new StatsTracker();
         final LongSupplier millisSupplier = () -> TimeValue.nsecToMSec(System.nanoTime());
         final InboundDecoder decoder = new InboundDecoder(Version.CURRENT, PageCacheRecycler.NON_RECYCLING_INSTANCE);
         final Supplier<CircuitBreaker> breaker = () -> new NoopCircuitBreaker("test");
         final InboundAggregator aggregator = new InboundAggregator(breaker, (Predicate<String>) action -> true);
-        final InboundPipeline pipeline = new InboundPipeline(statsTracker, millisSupplier, decoder, aggregator, messageHandler);
+        final InboundPipeline pipeline = new InboundPipeline(statsTracker, millisSupplier, decoder, aggregator, messageHandler, messageHandlerProtobuf);
 
         try (BytesStreamOutput streamOutput = new BytesStreamOutput()) {
             String actionName = "actionName";
@@ -269,12 +271,13 @@ public void testDecodeExceptionIsPropagated() throws IOException {
 
     public void testEnsureBodyIsNotPrematurelyReleased() throws IOException {
         BiConsumer<TcpChannel, InboundMessage> messageHandler = (c, m) -> {};
+        final BiConsumer<TcpChannel, BytesReference> messageHandlerProtobuf = (c, m) -> {};
         final StatsTracker statsTracker = new StatsTracker();
         final LongSupplier millisSupplier = () -> TimeValue.nsecToMSec(System.nanoTime());
         final InboundDecoder decoder = new InboundDecoder(Version.CURRENT, PageCacheRecycler.NON_RECYCLING_INSTANCE);
         final Supplier<CircuitBreaker> breaker = () -> new NoopCircuitBreaker("test");
         final InboundAggregator aggregator = new InboundAggregator(breaker, (Predicate<String>) action -> true);
-        final InboundPipeline pipeline = new InboundPipeline(statsTracker, millisSupplier, decoder, aggregator, messageHandler);
+        final InboundPipeline pipeline = new InboundPipeline(statsTracker, millisSupplier, decoder, aggregator, messageHandler, messageHandlerProtobuf);
 
         try (BytesStreamOutput streamOutput = new BytesStreamOutput()) {
             String actionName = "actionName";
diff --git a/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java b/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
index 8b652880b54db..2c65042c40d97 100644
--- a/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
+++ b/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
@@ -49,6 +49,7 @@
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.common.util.io.Streams;
+import org.opensearch.example.proto.ExampleProtoRequest;
 import org.opensearch.example.proto.ExampleRequestProto.ExampleRequest;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
@@ -76,6 +77,7 @@ public class OutboundHandlerTests extends OpenSearchTestCase {
     private final TestThreadPool threadPool = new TestThreadPool(getClass().getName());
     private final TransportRequestOptions options = TransportRequestOptions.EMPTY;
     private final AtomicReference<Tuple<Header, BytesReference>> message = new AtomicReference<>();
+    private final AtomicReference<BytesReference> protobufMessage = new AtomicReference<>();
     private InboundPipeline pipeline;
     private OutboundHandler handler;
     private FakeTcpChannel channel;
@@ -102,6 +104,8 @@ public void setUp() throws Exception {
             } catch (IOException e) {
                 throw new AssertionError(e);
             }
+        }, (c, m) -> {
+            protobufMessage.set(m);
         });
     }
 
@@ -315,6 +319,7 @@ public void onResponseSent(long requestId, String action, Exception error) {
     }
 
     public void testSendRequestProtobuf() throws IOException {
+        System.out.println("In testSendRequestProtobuf");
         ThreadContext threadContext = threadPool.getThreadContext();
         Version version = randomFrom(Version.CURRENT, Version.CURRENT.minimumCompatibilityVersion());
         String action = "example";
@@ -323,7 +328,7 @@ public void testSendRequestProtobuf() throws IOException {
         boolean compress = false;
         String value = "message";
         threadContext.putHeader("header", "header_value");
-        ExampleRequest request = ExampleRequest.newBuilder().setHeader("header_value").setMessage(value).build();
+        ExampleProtoRequest request = new ExampleProtoRequest(1, value);
 
         AtomicReference<DiscoveryNode> nodeRef = new AtomicReference<>();
         AtomicLong requestIdRef = new AtomicLong();
@@ -344,40 +349,55 @@ public void onRequestSent(
                 requestRef.set(request);
             }
         });
-        handler.sendRequest(node, channel, requestId, action, request, options, version, compress, isHandshake);
+        handler.sendProtobufRequest(node, channel, requestId, action, request, options, version, compress, isHandshake);
 
         BytesReference reference = channel.getMessageCaptor().get();
         ActionListener<Void> sendListener = channel.getListenerCaptor().get();
-        if (randomBoolean()) {
+        // if (randomBoolean()) {
             sendListener.onResponse(null);
-        } else {
-            sendListener.onFailure(new IOException("failed"));
-        }
+        // } else {
+        //     sendListener.onFailure(new IOException("failed"));
+        // }
         assertEquals(node, nodeRef.get());
         assertEquals(requestId, requestIdRef.get());
         assertEquals(action, actionRef.get());
         assertEquals(request, requestRef.get());
 
         pipeline.handleBytes(channel, new ReleasableBytesReference(reference, () -> {}));
-        final Tuple<Header, BytesReference> tuple = message.get();
-        final Header header = tuple.v1();
-        final TestRequest message = new TestRequest(tuple.v2().streamInput());
-        assertEquals(version, header.getVersion());
-        assertEquals(requestId, header.getRequestId());
-        assertTrue(header.isRequest());
-        assertFalse(header.isResponse());
-        if (isHandshake) {
-            assertTrue(header.isHandshake());
-        } else {
-            assertFalse(header.isHandshake());
-        }
-        if (compress) {
-            assertTrue(header.isCompressed());
-        } else {
-            assertFalse(header.isCompressed());
+        // final Tuple<Header, BytesReference> tuple = message.get();
+        // final Header header = tuple.v1();
+        // final TestRequest message = new TestRequest(tuple.v2().streamInput());
+        final BytesReference reference2 = protobufMessage.get();
+        byte[] incomingBytes = BytesReference.toBytes(reference2);
+        System.out.println("Size of incoming bytes: " + incomingBytes.length);
+        for (int i = 0; i < incomingBytes.length; i++) {
+            System.out.println("Byte " + i + " is: " + incomingBytes[i]);
         }
-
-        assertEquals(value, message.value);
-        assertEquals("header_value", header.getHeaders().v1().get("header"));
+        ProtobufOutboundMessage protobufOutboundMessage = new ProtobufOutboundMessage(incomingBytes);
+        System.out.println("Received protobuf message is: " + protobufOutboundMessage);
+        // ProtobufOutboundMessage protobufOutboundMessage = new ProtobufOutboundMessage(incomingBytes);
+        // System.out.println("Received protobuf message is: " + protobufOutboundMessage);
+        // final Header header = tuple.v1();
+        // final ExampleProtoRequest message = new ExampleProtoRequest(tuple.v2().toBytesRef().bytes);
+        // assertEquals(version, header.getVersion());
+        // assertEquals(requestId, header.getRequestId());
+        // assertTrue(header.isRequest());
+        // assertFalse(header.isResponse());
+        // if (isHandshake) {
+        //     assertTrue(header.isHandshake());
+        // } else {
+        //     assertFalse(header.isHandshake());
+        // }
+        // if (compress) {
+        //     assertTrue(header.isCompressed());
+        // } else {
+        //     assertFalse(header.isCompressed());
+        // }
+
+        // System.out.println("Received request after deserialization is: " + message);
+
+        // assertEquals(value, message.message());
+        // assertEquals(1, message.id());
+        // assertEquals("header_value", header.getHeaders().v1().get("header"));
     }
 }
diff --git a/test/framework/src/main/java/org/opensearch/transport/nio/MockNioTransport.java b/test/framework/src/main/java/org/opensearch/transport/nio/MockNioTransport.java
index 73b2e5dd82f62..7b51d01986f75 100644
--- a/test/framework/src/main/java/org/opensearch/transport/nio/MockNioTransport.java
+++ b/test/framework/src/main/java/org/opensearch/transport/nio/MockNioTransport.java
@@ -325,7 +325,8 @@ private MockTcpReadWriteHandler(MockSocketChannel channel, PageCacheRecycler rec
                 threadPool::relativeTimeInMillis,
                 breaker,
                 requestHandlers::getHandler,
-                transport::inboundMessage
+                transport::inboundMessage,
+                transport::inboundMessageProtobuf
             );
         }
 

From 8aab04b0f5f2e90eda8b0096227252d9618efe74 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Fri, 28 Jul 2023 20:28:33 +0000
Subject: [PATCH 19/37] Changes for multi node - working on single and multi
 node

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../action/ActionListenerResponseHandler.java |    6 +
 ...ProtobufActionListenerResponseHandler.java |   15 +-
 .../opensearch/action/ProtobufActionType.java |    7 +
 .../cluster/node/info/ProtobufNodeInfo.java   |   33 +-
 .../node/info/ProtobufNodesInfoRequest.java   |   24 +-
 .../node/info/ProtobufNodesInfoResponse.java  |   29 +
 .../ProtobufTransportNodesInfoAction.java     |   38 +-
 .../node/info/TransportNodesInfoAction.java   |    4 +
 .../cluster/node/stats/ProtobufNodeStats.java |  148 +-
 .../node/stats/ProtobufNodesStatsRequest.java |   25 +-
 .../stats/ProtobufNodesStatsResponse.java     |   30 +
 .../ProtobufTransportNodesStatsAction.java    |   34 +-
 .../cluster/state/ClusterStateResponse.java   |    3 +
 .../state/ProtobufClusterStateAction.java     |    2 +-
 .../state/ProtobufClusterStateRequest.java    |  171 +-
 .../ProtobufClusterStateRequestBuilder.java   |    8 +-
 .../state/ProtobufClusterStateResponse.java   |  107 +-
 .../ProtobufTransportClusterStateAction.java  |    9 +
 .../state/TransportClusterStateAction.java    |    4 +
 ...TransportFieldCapabilitiesIndexAction.java |    6 +
 .../TransportResyncReplicationAction.java     |    6 +
 .../opensearch/action/search/PitService.java  |    6 +
 .../ProtobufHandledTransportAction.java       |    1 +
 .../support/ProtobufTransportAction.java      |    7 +
 .../broadcast/TransportBroadcastAction.java   |    6 +
 .../node/TransportBroadcastByNodeAction.java  |    7 +
 ...obufTransportClusterManagerNodeAction.java |   16 +-
 .../TransportClusterManagerNodeAction.java    |    5 +-
 .../nodes/ProtobufBaseNodeResponse.java       |    4 +
 .../nodes/ProtobufBaseNodesRequest.java       |    4 +
 .../nodes/ProtobufTransportNodesAction.java   |    8 +
 .../support/nodes/TransportNodesAction.java   |    6 +
 .../TransportReplicationAction.java           |    6 +
 ...ransportInstanceSingleOperationAction.java |    6 +
 .../shard/TransportSingleShardAction.java     |   12 +
 .../support/tasks/TransportTasksAction.java   |    7 +
 .../cluster/ProtobufClusterChangedEvent.java  |  308 ----
 .../cluster/ProtobufClusterState.java         |  872 ---------
 .../cluster/ProtobufClusterStateApplier.java  |   29 -
 .../cluster/ProtobufClusterStateListener.java |   22 -
 .../cluster/ProtobufClusterStateObserver.java |  384 ----
 .../ProtobufTimeoutClusterStateListener.java  |   49 -
 .../cluster/coordination/Coordinator.java     |   12 -
 .../coordination/FollowersChecker.java        |    6 +
 .../cluster/coordination/JoinHelper.java      |   12 +
 .../cluster/coordination/LeaderChecker.java   |    6 +
 .../coordination/PreVoteCollector.java        |    6 +
 .../PublicationTransportHandler.java          |   12 +
 .../decommission/DecommissionController.java  |    6 +
 .../ProtobufIndexNameExpressionResolver.java  | 1351 --------------
 .../cluster/node/DiscoveryNode.java           |   14 +-
 .../cluster/node/ProtobufDiscoveryNodes.java  |  885 ---------
 .../cluster/service/ClusterApplier.java       |    7 -
 .../service/ClusterApplierService.java        |   22 -
 .../cluster/service/ClusterService.java       |    9 -
 ...ProtobufNodeAndClusterIdStateListener.java |   71 -
 .../transport/ProtobufTransportAddress.java   |  134 --
 .../org/opensearch/discovery/PeerFinder.java  |    6 +
 .../example/proto/ExampleProtoRequest.java    |    3 +-
 .../extensions/ExtensionsManager.java         |    6 +
 .../UpdateSettingsResponseHandler.java        |    6 +
 .../ExtensionTransportActionsHandler.java     |   12 +
 .../rest/RestSendToExtensionAction.java       |    6 +
 .../RetentionLeaseBackgroundSyncAction.java   |    6 +
 .../index/seqno/RetentionLeaseSyncAction.java |    6 +
 .../recovery/PeerRecoveryTargetService.java   |    6 +
 .../checkpoint/PublishCheckpointAction.java   |    6 +
 .../indices/store/IndicesStore.java           |    6 +
 .../monitor/jvm/ProtobufJvmInfo.java          |  684 +++++++
 .../main/java/org/opensearch/node/Node.java   |   97 -
 .../action/cat/ProtobufRestNodesAction.java   |  264 +--
 .../snapshots/SnapshotShardsService.java      |    6 +
 .../EmptyTransportResponseHandler.java        |    6 +
 .../opensearch/transport/InboundHandler.java  |  236 ++-
 .../opensearch/transport/InboundPipeline.java |   14 +-
 .../opensearch/transport/OutboundHandler.java |  184 +-
 .../opensearch/transport/OutboundMessage.java |    8 +-
 .../transport/PlainTransportFuture.java       |    6 +
 .../ProtobufClusterConnectionManager.java     |  283 ---
 .../transport/ProtobufConnectionManager.java  |  114 --
 .../transport/ProtobufConnectionProfile.java  |  359 ----
 ...ProtobufEmptyTransportResponseHandler.java |    5 +
 .../transport/ProtobufOutboundHandler.java    |  281 ---
 .../transport/ProtobufOutboundMessage.java    |  437 ++---
 .../ProtobufPlainTransportFuture.java         |    5 +
 .../ProtobufRemoteClusterAwareClient.java     |    2 +-
 .../ProtobufRemoteClusterConnection.java      |    5 +
 .../ProtobufRemoteConnectionManager.java      |  222 ---
 .../ProtobufRequestHandlerRegistry.java       |    5 +
 .../ProtobufSniffConnectionStrategy.java      |    5 +
 .../ProtobufTaskTransportChannel.java         |   67 -
 .../ProtobufTcpTransportChannel.java          |  110 --
 .../ProtobufTransportActionProxy.java         |   21 +-
 .../transport/ProtobufTransportChannel.java   |   56 -
 .../ProtobufTransportConnectionListener.java  |   43 -
 .../ProtobufTransportInterceptor.java         |   59 -
 .../transport/ProtobufTransportMessage.java   |   45 -
 .../ProtobufTransportMessageListener.java     |   69 -
 .../transport/ProtobufTransportRequest.java   |   60 -
 .../transport/ProtobufTransportResponse.java  |   59 -
 .../ProtobufTransportResponseHandler.java     |   57 -
 .../transport/ProtobufTransportService.java   | 1610 -----------------
 .../transport/RemoteClusterConnection.java    |    6 +
 .../transport/SniffConnectionStrategy.java    |    6 +
 .../transport/TransportActionProxy.java       |    6 +
 .../transport/TransportHandshaker.java        |    6 +
 .../transport/TransportRequest.java           |   13 +
 .../transport/TransportResponseHandler.java   |   19 +-
 .../transport/TransportService.java           |  302 +---
 .../server/ClusterStateRequestProto.proto     |   26 +
 .../server/ClusterStateResponseProto.proto    |   59 +
 .../main/proto/server/NodesInfoProto.proto    |   25 +
 .../proto/server/NodesInfoRequestProto.proto  |   20 +
 .../proto/server/NodesInfoResponseProto.proto |   22 +
 .../main/proto/server/NodesStatsProto.proto   |  147 ++
 .../proto/server/NodesStatsRequestProto.proto |   20 +
 .../server/NodesStatsResponseProto.proto      |   22 +
 .../OutboundMessageProto.proto                |   20 +-
 .../proto/server/TransportRequestProto.proto  |   21 +
 .../transport/OutboundHandlerTests.java       |    2 +-
 120 files changed, 2629 insertions(+), 8693 deletions(-)
 delete mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufClusterChangedEvent.java
 delete mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java
 delete mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufClusterStateApplier.java
 delete mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufClusterStateListener.java
 delete mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufClusterStateObserver.java
 delete mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufTimeoutClusterStateListener.java
 delete mode 100644 server/src/main/java/org/opensearch/cluster/metadata/ProtobufIndexNameExpressionResolver.java
 delete mode 100644 server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java
 delete mode 100644 server/src/main/java/org/opensearch/common/logging/ProtobufNodeAndClusterIdStateListener.java
 delete mode 100644 server/src/main/java/org/opensearch/common/transport/ProtobufTransportAddress.java
 create mode 100644 server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufConnectionProfile.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTaskTransportChannel.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTcpTransportChannel.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportChannel.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportMessage.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportRequest.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportResponse.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportResponseHandler.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportService.java
 create mode 100644 server/src/main/proto/server/ClusterStateRequestProto.proto
 create mode 100644 server/src/main/proto/server/ClusterStateResponseProto.proto
 create mode 100644 server/src/main/proto/server/NodesInfoProto.proto
 create mode 100644 server/src/main/proto/server/NodesInfoRequestProto.proto
 create mode 100644 server/src/main/proto/server/NodesInfoResponseProto.proto
 create mode 100644 server/src/main/proto/server/NodesStatsProto.proto
 create mode 100644 server/src/main/proto/server/NodesStatsRequestProto.proto
 create mode 100644 server/src/main/proto/server/NodesStatsResponseProto.proto
 rename server/src/main/proto/{examples => server}/OutboundMessageProto.proto (59%)
 create mode 100644 server/src/main/proto/server/TransportRequestProto.proto

diff --git a/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java b/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java
index 79a9a198e1836..7fcf9fb886e38 100644
--- a/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java
+++ b/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java
@@ -104,4 +104,10 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
         // TODO Auto-generated method stub
         throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
     }
+
+    @Override
+    public Response read(byte[] in) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'read'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java b/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
index c7b1d2f97b490..4955b1a717cd1 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
@@ -11,6 +11,7 @@
 import com.google.protobuf.CodedInputStream;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.ProtobufTransportException;
@@ -31,12 +32,12 @@ public class ProtobufActionListenerResponseHandler<Response extends TransportRes
         TransportResponseHandler<Response> {
 
     private final ActionListener<? super Response> listener;
-    private final ProtobufWriteable.Reader<Response> reader;
+    private final TryWriteable.Reader<Response> reader;
     private final String executor;
 
     public ProtobufActionListenerResponseHandler(
         ActionListener<? super Response> listener,
-        ProtobufWriteable.Reader<Response> reader,
+        TryWriteable.Reader<Response> reader,
         String executor
     ) {
         this.listener = Objects.requireNonNull(listener);
@@ -44,7 +45,7 @@ public ProtobufActionListenerResponseHandler(
         this.executor = Objects.requireNonNull(executor);
     }
 
-    public ProtobufActionListenerResponseHandler(ActionListener<? super Response> listener, ProtobufWriteable.Reader<Response> reader) {
+    public ProtobufActionListenerResponseHandler(ActionListener<? super Response> listener, TryWriteable.Reader<Response> reader) {
         this(listener, reader, ThreadPool.Names.SAME);
     }
 
@@ -65,7 +66,8 @@ public String executor() {
 
     @Override
     public Response read(CodedInputStream in) throws IOException {
-        return reader.read(in);
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'read'");
     }
 
     @Override
@@ -83,4 +85,9 @@ public Response read(StreamInput in) throws IOException {
     public void handleException(TransportException exp) {
         listener.onFailure(exp);
     }
+
+    @Override
+    public Response read(byte[] in) throws IOException {
+        return reader.read(in);
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionType.java b/server/src/main/java/org/opensearch/action/ProtobufActionType.java
index c8fc92a3e9f35..2ddd444d4ce8b 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionType.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionType.java
@@ -9,6 +9,7 @@
 package org.opensearch.action;
 
 import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.transport.TransportRequestOptions;
 
@@ -21,6 +22,7 @@ public class ProtobufActionType<Response extends ProtobufActionResponse> {
 
     private final String name;
     private final ProtobufWriteable.Reader<Response> responseReader;
+    private final TryWriteable.Reader<Response> responseReaderTry;
 
     /**
      * @param name The name of the action, must be unique across actions.
@@ -29,6 +31,7 @@ public class ProtobufActionType<Response extends ProtobufActionResponse> {
     public ProtobufActionType(String name, ProtobufWriteable.Reader<Response> responseReader) {
         this.name = name;
         this.responseReader = responseReader;
+        this.responseReaderTry = null;
     }
 
     /**
@@ -45,6 +48,10 @@ public ProtobufWriteable.Reader<Response> getResponseReader() {
         return responseReader;
     }
 
+    public TryWriteable.Reader<Response> getResponseReaderTry() {
+        return responseReaderTry;
+    }
+
     /**
      * Optional request options for the action.
     */
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
index d8184bfa0a46d..63390fe874351 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
@@ -15,6 +15,8 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
+import com.google.protobuf.InvalidProtocolBufferException;
+
 import org.opensearch.Build;
 import org.opensearch.Version;
 import org.opensearch.action.support.nodes.ProtobufBaseNodeResponse;
@@ -22,22 +24,24 @@
 import org.opensearch.common.Nullable;
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.ByteSizeValue;
 import org.opensearch.http.ProtobufHttpInfo;
 import org.opensearch.ingest.ProtobufIngestInfo;
 import org.opensearch.monitor.jvm.JvmInfo;
-import org.opensearch.monitor.jvm.JvmInfo;
 import org.opensearch.monitor.os.OsInfo;
 import org.opensearch.monitor.os.ProtobufOsInfo;
 import org.opensearch.monitor.process.ProtobufProcessInfo;
 import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.search.aggregations.support.ProtobufAggregationInfo;
 import org.opensearch.search.pipeline.ProtobufSearchPipelineInfo;
+import org.opensearch.server.proto.NodesInfoProto;
 import org.opensearch.threadpool.ProtobufThreadPoolInfo;
 import org.opensearch.transport.ProtobufTransportInfo;
 
 import java.io.IOException;
+import java.io.OutputStream;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -46,7 +50,7 @@
 *
 * @opensearch.internal
 */
-public class ProtobufNodeInfo extends ProtobufBaseNodeResponse {
+public class ProtobufNodeInfo extends ProtobufBaseNodeResponse implements TryWriteable {
 
     private Version version;
     private Build build;
@@ -54,6 +58,8 @@ public class ProtobufNodeInfo extends ProtobufBaseNodeResponse {
     @Nullable
     private Settings settings;
 
+    private NodesInfoProto.NodesInfo nodesInfoResponse;
+
     /**
      * Do not expose this map to other classes. For type safety, use {@link #getInfo(Class)}
     * to retrieve items from this map and {@link #addInfoIfNonNull(Class, ProtobufReportingService.ProtobufInfo)}
@@ -91,6 +97,11 @@ public ProtobufNodeInfo(CodedInputStream in) throws IOException {
         }
     }
 
+    public ProtobufNodeInfo(byte[] data) throws InvalidProtocolBufferException {
+        super(data);
+        this.nodesInfoResponse = NodesInfoProto.NodesInfo.parseFrom(data);
+    }
+
     public ProtobufNodeInfo(
         Version version,
         Build build,
@@ -123,6 +134,15 @@ public ProtobufNodeInfo(
         addInfoIfNonNull(ProtobufAggregationInfo.class, aggsInfo);
         addInfoIfNonNull(ProtobufSearchPipelineInfo.class, ProtobufSearchPipelineInfo);
         this.totalIndexingBuffer = totalIndexingBuffer;
+        this.nodesInfoResponse = NodesInfoProto.NodesInfo.newBuilder()
+            .setNodeId(node.getId())
+            .setProcessId(process.getId())
+            .setAddress(http.getAddress().publishAddress().toString())
+            .setDisplayName(this.build.type().displayName())
+            .setHash(this.build.hash())
+            .setJvmInfoVersion(jvm.version())
+            .setJvmHeapMax(jvm.getMem().getHeapMax().toString())
+            .build();
     }
 
     /**
@@ -329,4 +349,13 @@ public ProtobufNodeInfo build() {
 
     }
 
+    @Override
+    public void writeTo(OutputStream out) throws IOException {
+        out.write(this.nodesInfoResponse.toByteArray());
+    }
+
+    public NodesInfoProto.NodesInfo response() {
+        return this.nodesInfoResponse;
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
index 2fb3c3319822b..b57674283a880 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
@@ -19,8 +19,12 @@
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.TryWriteable;
+import org.opensearch.server.proto.NodesInfoRequestProto.NodesInfoReq;
+import org.opensearch.server.proto.NodesInfoRequestProto;
 
 import java.io.IOException;
+import java.io.OutputStream;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
@@ -33,9 +37,10 @@
  *
  * @opensearch.internal
  */
-public class ProtobufNodesInfoRequest extends ProtobufBaseNodesRequest<ProtobufNodesInfoRequest> {
+public class ProtobufNodesInfoRequest extends ProtobufBaseNodesRequest<ProtobufNodesInfoRequest> implements TryWriteable {
 
     private Set<String> requestedMetrics = Metric.allMetrics();
+    private NodesInfoRequestProto.NodesInfoReq nodesInfoRequest;
 
     /**
      * Create a new NodeInfoRequest from a {@link StreamInput} object.
@@ -79,7 +84,7 @@ public ProtobufNodesInfoRequest all() {
      * Get the names of requested metrics
      */
     public Set<String> requestedMetrics() {
-        return new HashSet<>(requestedMetrics);
+        return new HashSet<>(this.nodesInfoRequest.getRequestedMetricsList());
     }
 
     /**
@@ -103,6 +108,7 @@ public ProtobufNodesInfoRequest addMetrics(String... metrics) {
             String plural = metricsSet.size() == 1 ? "" : "s";
             throw new IllegalStateException("Used illegal metric" + plural + ": " + metricsSet);
         }
+        this.nodesInfoRequest = NodesInfoRequestProto.NodesInfoReq.newBuilder().addAllRequestedMetrics(metricsSet).build();
         requestedMetrics.addAll(metricsSet);
         return this;
     }
@@ -125,6 +131,11 @@ public void writeTo(CodedOutputStream out) throws IOException {
         protobufStreamOutput.writeStringArray(requestedMetrics.toArray(new String[0]));
     }
 
+    public ProtobufNodesInfoRequest(byte[] data) throws IOException {
+        super(data);
+        this.nodesInfoRequest = NodesInfoRequestProto.NodesInfoReq.parseFrom(data);
+    }
+
     /**
      * An enumeration of the "core" sections of metrics that may be requested
      * from the nodes information endpoint. Eventually this list list will be
@@ -162,4 +173,13 @@ public static Set<String> allMetrics() {
             return Arrays.stream(values()).map(Metric::metricName).collect(Collectors.toSet());
         }
     }
+
+    @Override
+    public void writeTo(OutputStream out) throws IOException {
+        this.nodesInfoRequest.writeTo(out);
+    }
+
+    public NodesInfoReq request() {
+        return this.nodesInfoRequest;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
index 7b46d535c5224..b8b46d6dd5f22 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
@@ -53,10 +53,14 @@
 import org.opensearch.monitor.process.ProtobufProcessInfo;
 import org.opensearch.search.aggregations.support.ProtobufAggregationInfo;
 import org.opensearch.search.pipeline.ProtobufSearchPipelineInfo;
+import org.opensearch.server.proto.NodesInfoResponseProto;
+import org.opensearch.server.proto.NodesInfoProto.NodesInfo;
 import org.opensearch.threadpool.ProtobufThreadPoolInfo;
 import org.opensearch.transport.ProtobufTransportInfo;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -67,12 +71,29 @@
 */
 public class ProtobufNodesInfoResponse extends ProtobufBaseNodesResponse<ProtobufNodeInfo> implements ToXContentFragment {
 
+    private NodesInfoResponseProto.NodesInfoRes nodesInfoRes;
+    private Map<String, NodesInfo> nodesMap = new HashMap<>();
+
     public ProtobufNodesInfoResponse(CodedInputStream in) throws IOException {
         super(in);
     }
 
     public ProtobufNodesInfoResponse(ClusterName clusterName, List<ProtobufNodeInfo> nodes, List<ProtobufFailedNodeException> failures) {
         super(clusterName, nodes, failures);
+        System.out.println("ProtobufNodesInfoResponse constructor");
+        System.out.println("clusterName: " + clusterName);
+        System.out.println("nodes: " + nodes);
+        List<NodesInfo> nodesInfo = new ArrayList<>();
+        for (ProtobufNodeInfo nodeInfo : nodes) {
+            nodesInfo.add(nodeInfo.response());
+            this.nodesMap.put(nodeInfo.response().getNodeId(), nodeInfo.response());
+        }
+        this.nodesInfoRes = NodesInfoResponseProto.NodesInfoRes.newBuilder()
+            .setClusterName(clusterName.value())
+            .addAllNodesInfo(nodesInfo)
+            .build();
+        System.out.println("Proto nodes info: " + this.nodesInfoRes);
+        System.out.println("Nodes info map: " + this.nodesMap);
     }
 
     @Override
@@ -175,4 +196,12 @@ public String toString() {
             return "{ \"error\" : \"" + e.getMessage() + "\"}";
         }
     }
+
+    public NodesInfoResponseProto.NodesInfoRes response() {
+        return nodesInfoRes;
+    }
+
+    public Map<String, NodesInfo> nodesMap() {
+        return nodesMap;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
index e5f185d6e2d07..f890a1549d252 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
@@ -16,12 +16,14 @@
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.inject.Inject;
+import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.node.ProtobufNodeService;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
+import java.io.OutputStream;
 import java.util.List;
 import java.util.Set;
 
@@ -66,10 +68,10 @@ protected ProtobufNodesInfoResponse newResponse(
         List<ProtobufNodeInfo> responses,
         List<ProtobufFailedNodeException> failures
     ) {
-        // System.out.println("Inside newResponse");
-        // System.out.println("nodesInfoRequest: " + nodesInfoRequest);
-        // System.out.println("responses: " + responses);
-        // System.out.println("failures: " + failures);
+        System.out.println("Inside newResponse");
+        System.out.println("nodesInfoRequest: " + nodesInfoRequest);
+        System.out.println("responses: " + responses);
+        System.out.println("failures: " + failures);
         return new ProtobufNodesInfoResponse(new ClusterName(clusterService.getClusterName().value()), responses, failures);
     }
 
@@ -81,14 +83,18 @@ protected NodeInfoRequest newNodeRequest(ProtobufNodesInfoRequest request) {
 
     @Override
     protected ProtobufNodeInfo newNodeResponse(CodedInputStream in) throws IOException {
-        // System.out.println("Inside newNodeResponse with input stream");
+        System.out.println("Inside newNodeResponse with input stream");
         return new ProtobufNodeInfo(in);
     }
 
     @Override
     protected ProtobufNodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
+        System.out.println("Inside nodeOperation in ProtobufTransportNodesInfoAction");
+        System.out.println("nodeRequest: " + nodeRequest);
         ProtobufNodesInfoRequest request = nodeRequest.request;
+        System.out.println("request: " + request);
         Set<String> metrics = request.requestedMetrics();
+        System.out.println("Metrics: " + metrics);
         ProtobufNodeInfo protobufNodeInfo = nodeService.info(
             metrics.contains(ProtobufNodesInfoRequest.Metric.SETTINGS.metricName()),
             metrics.contains(ProtobufNodesInfoRequest.Metric.OS.metricName()),
@@ -103,6 +109,7 @@ protected ProtobufNodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
             metrics.contains(ProtobufNodesInfoRequest.Metric.INDICES.metricName()),
             metrics.contains(ProtobufNodesInfoRequest.Metric.SEARCH_PIPELINES.metricName())
         );
+        System.out.println("protobufNodeInfo: " + protobufNodeInfo);
         return protobufNodeInfo;
     }
 
@@ -111,7 +118,7 @@ protected ProtobufNodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
     *
     * @opensearch.internal
     */
-    public static class NodeInfoRequest extends TransportRequest {
+    public static class NodeInfoRequest extends TransportRequest implements TryWriteable {
 
         ProtobufNodesInfoRequest request;
 
@@ -120,6 +127,10 @@ public NodeInfoRequest(CodedInputStream in) throws IOException {
             request = new ProtobufNodesInfoRequest(in);
         }
 
+        public NodeInfoRequest(byte[] data) throws IOException {
+            request = new ProtobufNodesInfoRequest(data);
+        }
+
         public NodeInfoRequest(ProtobufNodesInfoRequest request) {
             this.request = request;
         }
@@ -129,5 +140,20 @@ public void writeTo(CodedOutputStream out) throws IOException {
             super.writeTo(out);
             request.writeTo(out);
         }
+
+        public ProtobufNodesInfoRequest request() {
+            return request;
+        }
+
+        @Override
+        public void writeTo(OutputStream out) throws IOException {
+            request.writeTo(out);
+        }
+    }
+
+    @Override
+    protected ProtobufNodeInfo newNodeResponse(byte[] in) throws IOException {
+        System.out.println("Inside newNodeResponse with byte array");
+        return new ProtobufNodeInfo(in);
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
index 9223f532d7bde..45ead36c725a0 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
@@ -110,8 +110,11 @@ protected NodeInfo newNodeResponse(StreamInput in) throws IOException {
 
     @Override
     protected NodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
+        System.out.println("TransportNodesInfoAction.nodeOperation");
         NodesInfoRequest request = nodeRequest.request;
+        System.out.println("request: " + request);
         Set<String> metrics = request.requestedMetrics();
+        System.out.println("metrics: " + metrics);
         NodeInfo nodeInfo = nodeService.info(
             metrics.contains(NodesInfoRequest.Metric.SETTINGS.metricName()),
             metrics.contains(NodesInfoRequest.Metric.OS.metricName()),
@@ -126,6 +129,7 @@ protected NodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
             metrics.contains(NodesInfoRequest.Metric.INDICES.metricName()),
             metrics.contains(NodesInfoRequest.Metric.SEARCH_PIPELINES.metricName())
         );
+        System.out.println("nodeInfo: " + nodeInfo);
         return nodeInfo;
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
index 5c5a13a4e5e65..b1a79ed9ef3e0 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
@@ -10,12 +10,15 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
+import com.google.protobuf.InvalidProtocolBufferException;
+
 import org.opensearch.action.support.nodes.ProtobufBaseNodeResponse;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.discovery.ProtobufDiscoveryStats;
@@ -29,18 +32,25 @@
 import org.opensearch.monitor.process.ProtobufProcessStats;
 import org.opensearch.node.ProtobufAdaptiveSelectionStats;
 import org.opensearch.script.ProtobufScriptStats;
+import org.opensearch.server.proto.NodesStatsProto;
+import org.opensearch.server.proto.NodesStatsProto.NodesStats;
 import org.opensearch.threadpool.ProtobufThreadPoolStats;
 import org.opensearch.transport.ProtobufTransportStats;
 
 import java.io.IOException;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 /**
  * Node statistics (dynamic, changes depending on when created).
 *
 * @opensearch.internal
 */
-public class ProtobufNodeStats extends ProtobufBaseNodeResponse implements ToXContentFragment {
+public class ProtobufNodeStats extends ProtobufBaseNodeResponse implements ToXContentFragment, TryWriteable {
 
     private long timestamp;
 
@@ -83,6 +93,8 @@ public class ProtobufNodeStats extends ProtobufBaseNodeResponse implements ToXCo
     @Nullable
     private ProtobufAdaptiveSelectionStats adaptiveSelectionStats;
 
+    private NodesStatsProto.NodesStats nodesStatsResponse;
+
     public ProtobufNodeStats(CodedInputStream in) throws IOException {
         super(in);
         ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
@@ -104,6 +116,11 @@ public ProtobufNodeStats(CodedInputStream in) throws IOException {
         adaptiveSelectionStats = protobufStreamInput.readOptionalWriteable(ProtobufAdaptiveSelectionStats::new);
     }
 
+    public ProtobufNodeStats(byte[] data) throws InvalidProtocolBufferException {
+        super(data);
+        this.nodesStatsResponse = NodesStatsProto.NodesStats.parseFrom(data);
+    }
+
     public ProtobufNodeStats(
         DiscoveryNode node,
         long timestamp,
@@ -136,6 +153,126 @@ public ProtobufNodeStats(
         this.discoveryStats = discoveryStats;
         this.ingestStats = ingestStats;
         this.adaptiveSelectionStats = adaptiveSelectionStats;
+        NodesStatsProto.NodesStats.CompletionStats completionStats = NodesStatsProto.NodesStats.CompletionStats.newBuilder()
+            .setSize(indices.getCompletion().getSizeInBytes())
+            .build();
+        NodesStatsProto.NodesStats.FieldDataStats fieldDataStats = NodesStatsProto.NodesStats.FieldDataStats.newBuilder()
+            .setMemSize(indices.getFieldData().getMemorySizeInBytes())
+            .setEvictions(indices.getFieldData().getEvictions())
+            .build();
+        NodesStatsProto.NodesStats.QueryCacheStats queryCacheStats = NodesStatsProto.NodesStats.QueryCacheStats.newBuilder()
+            .setRamBytesUsed(indices.getQueryCache().getMemorySizeInBytes())
+            .setHitCount(indices.getQueryCache().getEvictions())
+            .setMissCount(indices.getQueryCache().getHitCount())
+            .setCacheCount(indices.getQueryCache().getMissCount())
+            .setCacheSize(indices.getQueryCache().getCacheSize())
+            .build();
+        NodesStatsProto.NodesStats.RequestCacheStats requestCacheStats = NodesStatsProto.NodesStats.RequestCacheStats.newBuilder()
+            .setMemorySize(indices.getRequestCache().getMemorySizeInBytes())
+            .setEvictions(indices.getRequestCache().getEvictions())
+            .setHitCount(indices.getRequestCache().getHitCount())
+            .setMissCount(indices.getRequestCache().getMissCount())
+            .build();
+         NodesStatsProto.NodesStats.FlushStats flushStats = NodesStatsProto.NodesStats.FlushStats.newBuilder()
+            .setTotal(indices.getFlush().getTotal())
+            .setPeriodic(indices.getFlush().getPeriodic())
+            .setTotalTimeInMillis(indices.getFlush().getTotalTimeInMillis())
+            .build();
+        NodesStatsProto.NodesStats.GetStats getStats = NodesStatsProto.NodesStats.GetStats.newBuilder()
+            .setExistsCount(indices.getGet().getExistsCount())
+            .setExistsTimeInMillis(indices.getGet().getExistsTimeInMillis())
+            .setMissingCount(indices.getGet().getMissingCount())
+            .setMissingTimeInMillis(indices.getGet().getMissingTimeInMillis())
+            .setCurrent(indices.getGet().current())
+            .setCount(indices.getGet().getCount())
+            .setTime(indices.getGet().getTimeInMillis())
+            .build();
+        NodesStatsProto.NodesStats.IndexingStats indexingStats = NodesStatsProto.NodesStats.IndexingStats.newBuilder()
+            .setIndexCount(indices.getIndexing().getTotal().getIndexCount())
+            .setIndexTimeInMillis(indices.getIndexing().getTotal().getIndexTime().getMillis())
+            .setIndexCurrent(indices.getIndexing().getTotal().getIndexCurrent())
+            .setIndexFailedCount(indices.getIndexing().getTotal().getIndexFailedCount())
+            .setDeleteCount(indices.getIndexing().getTotal().getDeleteCount())
+            .setDeleteTimeInMillis(indices.getIndexing().getTotal().getDeleteTime().getMillis())
+            .setDeleteCurrent(indices.getIndexing().getTotal().getDeleteCurrent())
+            .setNoopUpdateCount(indices.getIndexing().getTotal().getNoopUpdateCount())
+            .setIsThrottled(indices.getIndexing().getTotal().isThrottled())
+            .setThrottleTimeInMillis(indices.getIndexing().getTotal().getThrottleTime().getMillis())
+            .build();
+        NodesStatsProto.NodesStats.MergeStats mergeStats = NodesStatsProto.NodesStats.MergeStats.newBuilder()
+            .setTotal(indices.getMerge().getTotal())
+            .setTotalTimeInMillis(indices.getMerge().getTotalTimeInMillis())
+            .setTotalNumDocs(indices.getMerge().getTotalNumDocs())
+            .setTotalSizeInBytes(indices.getMerge().getTotalSizeInBytes())
+            .setCurrent(indices.getMerge().getCurrent())
+            .setCurrentNumDocs(indices.getMerge().getCurrentNumDocs())
+            .setCurrentSizeInBytes(indices.getMerge().getCurrentSizeInBytes())
+            .build();
+        NodesStatsProto.NodesStats.RefreshStats refreshStats = NodesStatsProto.NodesStats.RefreshStats.newBuilder()
+            .setTotal(indices.getRefresh().getTotal())
+            .setTotalTimeInMillis(indices.getRefresh().getTotalTimeInMillis())
+            .setExternalTotal(indices.getRefresh().getExternalTotal())
+            .setExternalTotalTimeInMillis(indices.getRefresh().getExternalTotalTimeInMillis())
+            .setListeners(indices.getRefresh().getListeners())
+            .build();
+        NodesStatsProto.NodesStats.ScriptStats scStats = NodesStatsProto.NodesStats.ScriptStats.newBuilder()
+            .setCompilations(scriptStats.getCompilations())
+            .setCacheEvictions(scriptStats.getCacheEvictions())
+            .setCompilationLimitTriggered(scriptStats.getCompilationLimitTriggered())
+            .build();
+        NodesStatsProto.NodesStats.SearchStats searchStats = NodesStatsProto.NodesStats.SearchStats.newBuilder()
+            .setQueryCount(indices.getSearch().getTotal().getQueryCount())
+            .setQueryTimeInMillis(indices.getSearch().getTotal().getQueryTimeInMillis())
+            .setQueryCurrent(indices.getSearch().getTotal().getQueryCurrent())
+            .setFetchCount(indices.getSearch().getTotal().getFetchCount())
+            .setFetchTimeInMillis(indices.getSearch().getTotal().getFetchTimeInMillis())
+            .setFetchCurrent(indices.getSearch().getTotal().getFetchCurrent())
+            .setScrollCount(indices.getSearch().getTotal().getScrollCount())
+            .setScrollTimeInMillis(indices.getSearch().getTotal().getScrollTimeInMillis())
+            .setScrollCurrent(indices.getSearch().getTotal().getScrollCurrent())
+            .setSuggestCount(indices.getSearch().getTotal().getSuggestCount())
+            .setSuggestTimeInMillis(indices.getSearch().getTotal().getSuggestTimeInMillis())
+            .setSuggestCurrent(indices.getSearch().getTotal().getSuggestCurrent())
+            .setPitCount(indices.getSearch().getTotal().getPitCount())
+            .setPitTimeInMillis(indices.getSearch().getTotal().getPitTimeInMillis())
+            .setPitCurrent(indices.getSearch().getTotal().getPitCurrent())
+            .setOpenContexts(indices.getSearch().getOpenContexts())
+            .build();
+        NodesStatsProto.NodesStats.SegmentStats segmentStats = NodesStatsProto.NodesStats.SegmentStats.newBuilder()
+            .setCount(indices.getSegments().getCount())
+            .setIndexWriterMemoryInBytes(indices.getSegments().getIndexWriterMemoryInBytes())
+            .setVersionMapMemoryInBytes(indices.getSegments().getVersionMapMemoryInBytes())
+            .setMaxUnsafeAutoIdTimestamp(indices.getSegments().getMaxUnsafeAutoIdTimestamp())
+            .setBitsetMemoryInBytes(indices.getSegments().getBitsetMemoryInBytes())
+            .build();
+        List<Double> list = Arrays.stream(os.getCpu().getLoadAverage()).boxed().collect(Collectors.toList());
+        this.nodesStatsResponse = NodesStatsProto.NodesStats.newBuilder()
+            .setNodeId(node.getId())
+            .setJvmHeapUsed(jvm.getMem().getHeapUsed().getBytes())
+            .setJvmHeapUsedPercent(Short.toString(jvm.getMem().getHeapUsedPercent()))
+            .setJvmUpTime(jvm.getUptime().getMillis())
+            .setDiskTotal(fs.getTotal().getTotal().getBytes())
+            .setDiskAvailable(fs.getTotal().getAvailable().getBytes())
+            .setOsMemUsed(os.getMem().getUsed().getBytes())
+            .setOsMemUsedPercent(Short.toString(os.getMem().getUsedPercent()))
+            .setOsMemTotal(os.getMem().getTotal().getBytes())
+            .setOsCpuPercent(Short.toString(os.getCpu().getPercent()))
+            .addAllOsCpuLoadAverage(list)
+            .setProcessOpenFileDescriptors(process.getOpenFileDescriptors())
+            .setProcessMaxFileDescriptors(process.getMaxFileDescriptors())
+            .setCompletionStats(completionStats)
+            .setFieldDataStats(fieldDataStats)
+            .setQueryCacheStats(queryCacheStats)
+            .setRequestCacheStats(requestCacheStats)
+            .setFlushStats(flushStats)
+            .setGetStats(getStats)
+            .setIndexingStats(indexingStats)
+            .setMergeStats(mergeStats)
+            .setRefreshStats(refreshStats)
+            .setScriptStats(scStats)
+            .setSearchStats(searchStats)
+            .setSegmentStats(segmentStats)
+            .build();
     }
 
     public long getTimestamp() {
@@ -319,4 +456,13 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
 
         return builder;
     }
+
+    @Override
+    public void writeTo(OutputStream out) throws IOException {
+        out.write(this.nodesStatsResponse.toByteArray());
+    }
+
+    public NodesStatsProto.NodesStats response() {
+        return this.nodesStatsResponse;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
index 19b7f907932c7..37cc281463568 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
@@ -14,7 +14,12 @@
 import org.opensearch.action.support.nodes.ProtobufBaseNodesRequest;
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.TryWriteable;
+import org.opensearch.server.proto.NodesStatsRequestProto.NodesStatsReq;
+import org.opensearch.server.proto.NodesStatsRequestProto;
+
 import java.io.IOException;
+import java.io.OutputStream;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
@@ -27,10 +32,11 @@
 *
 * @opensearch.internal
 */
-public class ProtobufNodesStatsRequest extends ProtobufBaseNodesRequest<ProtobufNodesStatsRequest> {
+public class ProtobufNodesStatsRequest extends ProtobufBaseNodesRequest<ProtobufNodesStatsRequest> implements TryWriteable {
 
     private CommonStatsFlags indices = new CommonStatsFlags();
     private final Set<String> requestedMetrics = new HashSet<>();
+    private NodesStatsRequestProto.NodesStatsReq nodesStatsRequest;
 
     public ProtobufNodesStatsRequest() {
         super((String[]) null);
@@ -108,7 +114,7 @@ public ProtobufNodesStatsRequest indices(boolean indices) {
     * handled separately.
     */
     public Set<String> requestedMetrics() {
-        return new HashSet<>(requestedMetrics);
+        return new HashSet<>(this.nodesStatsRequest.getRequestedMetricsList());
     }
 
     /**
@@ -133,6 +139,7 @@ public ProtobufNodesStatsRequest addMetrics(String... metrics) {
             String plural = metricsSet.size() == 1 ? "" : "s";
             throw new IllegalStateException("Used illegal metric" + plural + ": " + metricsSet);
         }
+        this.nodesStatsRequest = NodesStatsRequestProto.NodesStatsReq.newBuilder().addAllRequestedMetrics(metricsSet).build();
         requestedMetrics.addAll(metricsSet);
         return this;
     }
@@ -156,6 +163,11 @@ public void writeTo(CodedOutputStream out) throws IOException {
         protobufStreamOutput.writeStringArray(requestedMetrics.toArray(new String[0]));
     }
 
+    public ProtobufNodesStatsRequest(byte[] data) throws IOException {
+        super(data);
+        this.nodesStatsRequest = NodesStatsRequestProto.NodesStatsReq.parseFrom(data);
+    }
+
     /**
      * An enumeration of the "core" sections of metrics that may be requested
     * from the nodes stats endpoint. Eventually this list will be pluggable.
@@ -199,4 +211,13 @@ static Set<String> allMetrics() {
             return Arrays.stream(values()).map(Metric::metricName).collect(Collectors.toSet());
         }
     }
+
+    @Override
+    public void writeTo(OutputStream out) throws IOException {
+        this.nodesStatsRequest.writeTo(out);
+    }
+
+    public NodesStatsReq request() {
+        return this.nodesStatsRequest;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
index ef18285256f39..2249656f78424 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
@@ -18,10 +18,15 @@
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.server.proto.NodesStatsResponseProto;
+import org.opensearch.server.proto.NodesStatsProto.NodesStats;
 import org.opensearch.common.xcontent.XContentFactory;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Transport response for obtaining OpenSearch Node Stats
@@ -30,12 +35,29 @@
 */
 public class ProtobufNodesStatsResponse extends ProtobufBaseNodesResponse<ProtobufNodeStats> implements ToXContentFragment {
 
+    private NodesStatsResponseProto.NodesStatsRes nodesStatsRes;
+    private Map<String, NodesStats> nodesMap = new HashMap<>();
+
     public ProtobufNodesStatsResponse(CodedInputStream in) throws IOException {
         super(in);
     }
 
     public ProtobufNodesStatsResponse(ClusterName clusterName, List<ProtobufNodeStats> nodes, List<ProtobufFailedNodeException> failures) {
         super(clusterName, nodes, failures);
+        System.out.println("ProtobufNodesStatsResponse constructor");
+        System.out.println("clusterName: " + clusterName);
+        System.out.println("nodes: " + nodes);
+        List<NodesStats> nodesStats = new ArrayList<>();
+        for (ProtobufNodeStats nodeStats : nodes) {
+            nodesStats.add(nodeStats.response());
+            this.nodesMap.put(nodeStats.response().getNodeId(), nodeStats.response());
+        }
+        this.nodesStatsRes = NodesStatsResponseProto.NodesStatsRes.newBuilder()
+            .setClusterName(clusterName.value())
+            .addAllNodesStats(nodesStats)
+            .build();
+        System.out.println("Proto nodes stats: " + this.nodesStatsRes);
+        System.out.println("Nodes info map: " + this.nodesMap);
     }
 
     @Override
@@ -77,4 +99,12 @@ public String toString() {
             return "{ \"error\" : \"" + e.getMessage() + "\"}";
         }
     }
+
+    public NodesStatsResponseProto.NodesStatsRes response() {
+        return nodesStatsRes;
+    }
+
+    public Map<String, NodesStats> nodesMap() {
+        return nodesMap;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
index 481c3b624e399..70843521d1d31 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
@@ -11,17 +11,20 @@
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
 import org.opensearch.action.ProtobufFailedNodeException;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodeInfo;
 import org.opensearch.action.support.ProtobufActionFilters;
 import org.opensearch.action.support.nodes.ProtobufTransportNodesAction;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.inject.Inject;
+import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.node.ProtobufNodeService;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
+import java.io.OutputStream;
 import java.util.List;
 import java.util.Set;
 
@@ -66,6 +69,10 @@ protected ProtobufNodesStatsResponse newResponse(
         List<ProtobufNodeStats> responses,
         List<ProtobufFailedNodeException> failures
     ) {
+        System.out.println("Inside newResponse");
+        System.out.println("nodesStatsRequest: " + request);
+        System.out.println("responses: " + responses);
+        System.out.println("failures: " + failures);
         return new ProtobufNodesStatsResponse(new ClusterName(clusterService.getClusterName().value()), responses, failures);
     }
 
@@ -83,7 +90,7 @@ protected ProtobufNodeStats newNodeResponse(CodedInputStream in) throws IOExcept
     protected ProtobufNodeStats nodeOperation(NodeStatsRequest nodeStatsRequest) {
         ProtobufNodesStatsRequest request = nodeStatsRequest.request;
         Set<String> metrics = request.requestedMetrics();
-        return nodeService.stats(
+        ProtobufNodeStats protobufNodeStats = nodeService.stats(
             request.indices(),
             ProtobufNodesStatsRequest.Metric.OS.containedIn(metrics),
             ProtobufNodesStatsRequest.Metric.PROCESS.containedIn(metrics),
@@ -105,6 +112,8 @@ protected ProtobufNodeStats nodeOperation(NodeStatsRequest nodeStatsRequest) {
             ProtobufNodesStatsRequest.Metric.WEIGHTED_ROUTING_STATS.containedIn(metrics),
             ProtobufNodesStatsRequest.Metric.FILE_CACHE_STATS.containedIn(metrics)
         );
+        System.out.println("protobufNodeStats: " + protobufNodeStats);
+        return protobufNodeStats;
     }
 
     /**
@@ -112,7 +121,7 @@ protected ProtobufNodeStats nodeOperation(NodeStatsRequest nodeStatsRequest) {
     *
     * @opensearch.internal
     */
-    public static class NodeStatsRequest extends TransportRequest {
+    public static class NodeStatsRequest extends TransportRequest implements TryWriteable {
 
         ProtobufNodesStatsRequest request;
 
@@ -121,7 +130,11 @@ public NodeStatsRequest(CodedInputStream in) throws IOException {
             request = new ProtobufNodesStatsRequest(in);
         }
 
-        NodeStatsRequest(ProtobufNodesStatsRequest request) {
+        public NodeStatsRequest(byte[] data) throws IOException {
+            request = new ProtobufNodesStatsRequest(data);
+        }
+
+        public NodeStatsRequest(ProtobufNodesStatsRequest request) {
             this.request = request;
         }
 
@@ -130,5 +143,20 @@ public void writeTo(CodedOutputStream out) throws IOException {
             super.writeTo(out);
             request.writeTo(out);
         }
+
+        public ProtobufNodesStatsRequest request() {
+            return request;
+        }
+
+        @Override
+        public void writeTo(OutputStream out) throws IOException {
+            request.writeTo(out);
+        }
+    }
+
+    @Override
+    protected ProtobufNodeStats newNodeResponse(byte[] in) throws IOException {
+        System.out.println("Inside newNodeResponse with byte array");
+        return new ProtobufNodeStats(in);
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateResponse.java
index d196a06dcc5cb..efc0dfbd1ac6e 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateResponse.java
@@ -64,9 +64,12 @@ public ClusterStateResponse(StreamInput in) throws IOException {
     }
 
     public ClusterStateResponse(ClusterName clusterName, ClusterState clusterState, boolean waitForTimedOut) {
+        System.out.println("Inside ClusterStateResponse constructor");
         this.clusterName = clusterName;
         this.clusterState = clusterState;
         this.waitForTimedOut = waitForTimedOut;
+        System.out.println("Cluster name: " + clusterName);
+        System.out.println("Cluster state: " + clusterState);
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateAction.java
index 4f6b619049466..3f3c2a4d80d0e 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateAction.java
@@ -18,7 +18,7 @@
 public class ProtobufClusterStateAction extends ProtobufActionType<ProtobufClusterStateResponse> {
 
     public static final ProtobufClusterStateAction INSTANCE = new ProtobufClusterStateAction();
-    public static final String NAME = "cluster:monitor/stateprotobuf";
+    public static final String NAME = "cluster:monitor/state";
 
     private ProtobufClusterStateAction() {
         super(NAME, ProtobufClusterStateResponse::new);
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
index c6271e403c812..f3d0c8a02eace 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
@@ -20,11 +20,15 @@
 import org.opensearch.action.support.IndicesOptions;
 import org.opensearch.action.support.clustermanager.ProtobufClusterManagerNodeReadRequest;
 import org.opensearch.common.Strings;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.server.proto.ClusterStateRequestProto;
+import org.opensearch.server.proto.ClusterStateRequestProto.ClusterStateReq;
 
 import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Arrays;
+import java.util.List;
 
 /**
  * Transport request for obtaining cluster state
@@ -33,62 +37,34 @@
 */
 public class ProtobufClusterStateRequest extends ProtobufClusterManagerNodeReadRequest<ProtobufClusterStateRequest>
     implements
-        IndicesRequest.Replaceable {
+        IndicesRequest.Replaceable, TryWriteable {
 
     public static final TimeValue DEFAULT_WAIT_FOR_NODE_TIMEOUT = TimeValue.timeValueMinutes(1);
-
-    // private PRotoClusterSatteRq clusterStateRequest;
-    private boolean routingTable = true;
-    private boolean nodes = true;
-    private boolean metadata = true;
-    private boolean blocks = true;
-    private boolean customs = true;
-    private Long waitForMetadataVersion;
-    private TimeValue waitForTimeout = DEFAULT_WAIT_FOR_NODE_TIMEOUT;
-    private String[] indices = Strings.EMPTY_ARRAY;
-    private IndicesOptions indicesOptions = IndicesOptions.lenientExpandOpen();
-
-    public ProtobufClusterStateRequest() {}
-
+    private ClusterStateRequestProto.ClusterStateReq clusterStateRequest;
+
+    public ProtobufClusterStateRequest () {}
+
+    public ProtobufClusterStateRequest(boolean routingTable, boolean nodes, boolean metadata, boolean blocks,
+                                        boolean customs, long waitForMetadataVersion, TimeValue waitForTimeout, List<String> indices) {
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setRoutingTable(routingTable)
+                                        .setNodes(nodes)
+                                        .setMetadata(metadata)
+                                        .setBlocks(blocks)
+                                        .setCustoms(customs)
+                                        .setWaitForMetadataVersion(waitForMetadataVersion)
+                                        .setWaitForTimeout(waitForTimeout.toString())
+                                        .addAllIndices(indices)
+                                        .build();               
+    }
+    
     public ProtobufClusterStateRequest(CodedInputStream in) throws IOException {
         super(in);
         System.out.println("ProtobufClusterStateRequest constructor");
-        System.out.println("in: " + in);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        routingTable = in.readBool();
-        nodes = in.readBool();
-        metadata = in.readBool();
-        blocks = in.readBool();
-        customs = in.readBool();
-        indices = protobufStreamInput.readStringArray();
-        indicesOptions = IndicesOptions.readIndicesOptionsProtobuf(in);
-        waitForTimeout = protobufStreamInput.readTimeValue();
-        waitForMetadataVersion = protobufStreamInput.readOptionalLong();
-        System.out.println("ClusterStateRequest");
-        System.out.println("routingTable: " + routingTable);
-        System.out.println("nodes: " + nodes);
-        System.out.println("metadata: " + metadata);
-        System.out.println("blocks: " + blocks);
-        System.out.println("customs: " + customs);
-        System.out.println("indices: " + indices);
-        System.out.println("indicesOptions: " + indicesOptions);
-        System.out.println("waitForTimeout: " + waitForTimeout);
-        System.out.println("waitForMetadataVersion: " + waitForMetadataVersion);
     }
 
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
         super.writeTo(out);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeBoolNoTag(routingTable);
-        out.writeBoolNoTag(nodes);
-        out.writeBoolNoTag(metadata);
-        out.writeBoolNoTag(blocks);
-        out.writeBoolNoTag(customs);
-        protobufStreamOutput.writeStringArray(indices);
-        indicesOptions.writeIndicesOptionsProtobuf(out);
-        protobufStreamOutput.writeTimeValue(waitForTimeout);
-        protobufStreamOutput.writeOptionalLong(waitForMetadataVersion);
     }
 
     @Override
@@ -97,81 +73,85 @@ public ActionRequestValidationException validate() {
     }
 
     public ProtobufClusterStateRequest all() {
-        routingTable = true;
-        nodes = true;
-        metadata = true;
-        blocks = true;
-        customs = true;
-        indices = Strings.EMPTY_ARRAY;
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setRoutingTable(true)
+                                        .setNodes(true)
+                                        .setMetadata(true)
+                                        .setBlocks(true)
+                                        .setCustoms(true)
+                                        .addAllIndices(Arrays.asList(Strings.EMPTY_ARRAY))
+                                        .setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString())
+                                        .build();
         return this;
     }
 
     public ProtobufClusterStateRequest clear() {
-        routingTable = false;
-        nodes = false;
-        metadata = false;
-        blocks = false;
-        customs = false;
-        indices = Strings.EMPTY_ARRAY;
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setRoutingTable(false)
+                                        .setNodes(false)
+                                        .setMetadata(false)
+                                        .setBlocks(false)
+                                        .setCustoms(false)
+                                        .addAllIndices(Arrays.asList(Strings.EMPTY_ARRAY))
+                                        .setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString())
+                                        .build();
         return this;
     }
 
     public boolean routingTable() {
-        return routingTable;
+        return this.clusterStateRequest.getRoutingTable();
     }
 
     public ProtobufClusterStateRequest routingTable(boolean routingTable) {
-        this.routingTable = routingTable;
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setRoutingTable(routingTable).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
         return this;
     }
 
     public boolean nodes() {
-        return nodes;
+        return this.clusterStateRequest.getNodes();
     }
 
     public ProtobufClusterStateRequest nodes(boolean nodes) {
-        this.nodes = nodes;
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setNodes(nodes).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
         return this;
     }
 
     public boolean metadata() {
-        return metadata;
+        return this.clusterStateRequest.getMetadata();
     }
 
     public ProtobufClusterStateRequest metadata(boolean metadata) {
-        this.metadata = metadata;
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setMetadata(metadata).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
         return this;
     }
 
     public boolean blocks() {
-        return blocks;
+        return this.clusterStateRequest.getBlocks();
     }
 
     public ProtobufClusterStateRequest blocks(boolean blocks) {
-        this.blocks = blocks;
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).setBlocks(blocks).build();
         return this;
     }
 
     @Override
     public String[] indices() {
-        return indices;
+        return this.clusterStateRequest.getIndicesList().toArray(new String[0]);
     }
 
     @Override
     public ProtobufClusterStateRequest indices(String... indices) {
-        this.indices = indices;
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().addAllIndices(Arrays.asList(indices)).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
         return this;
     }
 
-    @Override
-    public IndicesOptions indicesOptions() {
-        return this.indicesOptions;
-    }
+    // @Override
+    // public IndicesOptions indicesOptions() {
+    //     return this.clusterStateRequest.;
+    // }
 
-    public final ProtobufClusterStateRequest indicesOptions(IndicesOptions indicesOptions) {
-        this.indicesOptions = indicesOptions;
-        return this;
-    }
+    // public final ProtobufClusterStateRequest indicesOptions(IndicesOptions indicesOptions) {
+    //     this.indicesOptions = indicesOptions;
+    //     return this;
+    // }
 
     @Override
     public boolean includeDataStreams() {
@@ -179,25 +159,28 @@ public boolean includeDataStreams() {
     }
 
     public ProtobufClusterStateRequest customs(boolean customs) {
-        this.customs = customs;
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setCustoms(customs).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
         return this;
     }
 
     public boolean customs() {
-        return customs;
+        return this.clusterStateRequest.getCustoms();
     }
 
     public TimeValue waitForTimeout() {
-        return waitForTimeout;
+        return TimeValue.parseTimeValue(
+            this.clusterStateRequest.getWaitForTimeout(),
+            getClass().getSimpleName() + ".clusterManagerNodeTimeout"
+        );
     }
 
     public ProtobufClusterStateRequest waitForTimeout(TimeValue waitForTimeout) {
-        this.waitForTimeout = waitForTimeout;
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setWaitForTimeout(waitForTimeout.toString()).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
         return this;
     }
 
     public Long waitForMetadataVersion() {
-        return waitForMetadataVersion;
+        return this.clusterStateRequest.getWaitForMetadataVersion();
     }
 
     public ProtobufClusterStateRequest waitForMetadataVersion(long waitForMetadataVersion) {
@@ -206,7 +189,7 @@ public ProtobufClusterStateRequest waitForMetadataVersion(long waitForMetadataVe
                 "provided waitForMetadataVersion should be >= 1, but instead is [" + waitForMetadataVersion + "]"
             );
         }
-        this.waitForMetadataVersion = waitForMetadataVersion;
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setWaitForMetadataVersion(waitForMetadataVersion).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
         return this;
     }
 
@@ -220,9 +203,27 @@ public String toString() {
         builder.append(",blocks=").append(blocks());
         builder.append(",customs=").append(customs());
         builder.append(",indices=").append(indices());
-        builder.append(",indicesOptions=").append(indicesOptions());
         builder.append(",waitForTimeout=").append(waitForTimeout());
         builder.append(",waitForMetadataVersion=").append(waitForMetadataVersion());
         return builder.append("]").toString();
     }
+
+    @Override
+    public IndicesOptions indicesOptions() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'indicesOptions'");
+    }
+
+    public ProtobufClusterStateRequest(byte[] data) throws IOException {
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.parseFrom(data);
+    }
+
+    @Override
+    public void writeTo(OutputStream out) throws IOException {
+        out.write(this.clusterStateRequest.toByteArray());
+    }
+
+    public ClusterStateReq request() {
+        return this.clusterStateRequest;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequestBuilder.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequestBuilder.java
index 93c45eccd89a4..bbfea70eda383 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequestBuilder.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequestBuilder.java
@@ -93,10 +93,10 @@ public ProtobufClusterStateRequestBuilder setIndices(String... indices) {
         return this;
     }
 
-    public ProtobufClusterStateRequestBuilder setIndicesOptions(IndicesOptions indicesOptions) {
-        request.indicesOptions(indicesOptions);
-        return this;
-    }
+    // public ProtobufClusterStateRequestBuilder setIndicesOptions(IndicesOptions indicesOptions) {
+    //     request.indicesOptions(indicesOptions);
+    //     return this;
+    // }
 
     /**
      * Causes the request to wait for the metadata version to advance to at least the given version.
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
index 9241404c6f00b..157d5a415d1f5 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
@@ -15,25 +15,42 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
+
+import org.opensearch.Version;
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
+import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.common.collect.ImmutableOpenMap;
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.TryWriteable;
+import org.opensearch.server.proto.ClusterStateRequestProto;
+import org.opensearch.server.proto.ClusterStateResponseProto;
+import org.opensearch.server.proto.ClusterStateResponseProto.ClusterStateRes;
 
 import java.io.IOException;
+import java.io.OutputStream;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * The response for getting the cluster state.
 *
 * @opensearch.internal
 */
-public class ProtobufClusterStateResponse extends ProtobufActionResponse {
+public class ProtobufClusterStateResponse extends ProtobufActionResponse implements TryWriteable {
 
     private ClusterName clusterName;
     private ClusterState clusterState;
     private boolean waitForTimedOut = false;
+    private ClusterStateResponseProto.ClusterStateRes clusterStateRes;
 
     public ProtobufClusterStateResponse(CodedInputStream in) throws IOException {
         super(in);
@@ -48,9 +65,58 @@ public ProtobufClusterStateResponse(CodedInputStream in) throws IOException {
     }
 
     public ProtobufClusterStateResponse(ClusterName clusterName, ClusterState clusterState, boolean waitForTimedOut) {
+        System.out.println("Inside ProtobufClusterStateResponse constructor");
         this.clusterName = clusterName;
         this.clusterState = clusterState;
         this.waitForTimedOut = waitForTimedOut;
+        //convert clusterState to ClusterStateResponseProto.ClusterStateRes.ClusterState
+        
+        ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Builder discoveryNodesBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.newBuilder();
+        DiscoveryNodes nodes = clusterState.getNodes();
+        ImmutableOpenMap<String, DiscoveryNode> allNodes = nodes.getNodes();
+
+        Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> allNodesMap = convertNodes(allNodes);
+        System.out.println("All nodes map:" + allNodes);
+        discoveryNodesBuilder.putAllAllNodes(allNodesMap).setClusterManagerNodeId(nodes.getClusterManagerNodeId()).setLocalNodeId(nodes.getLocalNodeId()).setMinNonClientNodeVersion(nodes.getSmallestNonClientNodeVersion().toString()).setMaxNonClientNodeVersion(nodes.getLargestNonClientNodeVersion().toString()).setMinNodeVersion(nodes.getMinNodeVersion().toString()).setMaxNodeVersion(nodes.getMaxNodeVersion().toString());
+
+        ClusterStateResponseProto.ClusterStateRes.ClusterState.Builder clusterStateBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.newBuilder();
+        clusterStateBuilder.setClusterName(clusterState.getClusterName().value())
+            .setVersion(clusterState.version())
+            .setStateUUID(clusterState.stateUUID())
+            .setNodes(discoveryNodesBuilder.build());
+        this.clusterStateRes = ClusterStateResponseProto.ClusterStateRes.newBuilder()
+                                            .setClusterName(clusterName.value())
+                                            .setClusterState(clusterStateBuilder.build())
+                                            .setWaitForTimedOut(waitForTimedOut)
+                                            .build();
+        System.out.println("Proto cluster state response: " + this.clusterStateRes);
+    }
+
+    private Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> convertNodes(ImmutableOpenMap<String, DiscoveryNode> nodes) {
+        Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> convertedNodes = new HashMap<>();
+        if (nodes.isEmpty()) {
+            return convertedNodes;
+        }
+        System.out.println("In convertNodes");
+        System.out.println("Nodes: " + nodes);
+        Iterator<String> keysIt = nodes.keysIt();
+        while(keysIt.hasNext()) {
+            System.out.println("Inside while loop");
+            String key = keysIt.next();
+            System.out.println("Key: " + key);
+            DiscoveryNode node = nodes.get(key);
+            Set<ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole> nodeRoles = new HashSet<>();
+            node.getRoles().forEach(role -> {
+                ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole.Builder nodeRoleBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole.newBuilder();
+                nodeRoleBuilder.setIsKnownRole(role.isKnownRole()).setIsDynamicRole(role.isDynamicRole()).setRoleName(role.roleName()).setRoleNameAbbreviation(role.roleNameAbbreviation()).setCanContainData(role.canContainData()).build();
+                nodeRoles.add(nodeRoleBuilder.build());
+            });
+            ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.Builder nodeBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.newBuilder();
+            nodeBuilder.setNodeName(node.getName()).setNodeId(node.getId()).setEphemeralId(node.getEphemeralId()).setHostName(node.getHostName())
+            .setHostAddress(node.getHostAddress()).setTransportAddress(node.getAddress().toString()).putAllAttributes(node.getAttributes()).addAllRoles(nodeRoles).setVersion(node.getVersion().toString()).build();
+            convertedNodes.put(key, nodeBuilder.build());
+        }
+        return convertedNodes;
     }
 
     /**
@@ -89,4 +155,43 @@ public void writeTo(CodedOutputStream out) throws IOException {
     public String toString() {
         return "ProtobufClusterStateResponse{" + "clusterState=" + clusterState + '}';
     }
+
+    public ClusterStateRes response() {
+        return this.clusterStateRes;
+    }
+
+    public ProtobufClusterStateResponse(byte[] data) throws IOException {
+        this.clusterStateRes = ClusterStateResponseProto.ClusterStateRes.parseFrom(data);
+        // this.clusterName = new ClusterName(this.clusterStateRes.getClusterName());
+        // org.opensearch.server.proto.ClusterStateResponseProto.ClusterStateRes.ClusterState clusterState = this.clusterStateRes.getClusterState();
+        // org.opensearch.server.proto.ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes discoveryNodesProto = clusterState.getNodes();
+        // discoveryNodesProto.getAllNodesMap().forEach((key, value) -> {
+        //     System.out.println("Key: " + key);
+        //     System.out.println("Value: " + value);
+        // });
+        // Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> nodeMap = discoveryNodesProto.getAllNodesMap();
+        // ImmutableOpenMap<String, DiscoveryNode> allNodes = new ImmutableOpenMap.Builder<String, DiscoveryNode>().build();
+        // for (Map.Entry<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> entry : nodeMap.entrySet()) {
+        //     String key = entry.getKey();
+        //     ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node value = entry.getValue();
+        //     Set<DiscoveryNodeRole> roles = new HashSet<>();
+        //     value.getRolesList().forEach(role -> {
+        //         String roleName = role.getRoleName();
+        //         String roleNameAbbreviation = role.getRoleNameAbbreviation();
+        //         boolean canContainData = role.getCanContainData();
+        //         DiscoveryNodeRole discoveryNodeRole = DiscoveryNode.roleMap.get(roleName);
+        //         roles.add(discoveryNodeRole);
+        //     });
+        //     DiscoveryNode node = new DiscoveryNode();
+        //     allNodes = allNodes.copyAndPut(key, node);
+        // }
+        // allNodes.putAll(nodeMap);
+        // DiscoveryNodes discoveryNodes = new DiscoveryNodes(discoveryNodesProto.getClusterManagerNodeId(), discoveryNodesProto.getLocalNodeId(), discoveryNodesProto.getMinNonClientNodeVersion(), discoveryNodesProto.getMaxNonClientNodeVersion(), discoveryNodesProto.getMinNodeVersion(), discoveryNodesProto.getMaxNodeVersion());
+        // this.clusterState = new ClusterState(clusterName, clusterState.getVersion(), clusterState.getStateUUID(), null, null, null, null, null, 0, waitForTimedOut);
+    }
+
+    @Override
+    public void writeTo(OutputStream out) throws IOException {
+        out.write(this.clusterStateRes.toByteArray());
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
index 4565a52282b35..1257bfcddbfed 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
@@ -100,6 +100,7 @@ protected void clusterManagerOperation(
         final ActionListener<ProtobufClusterStateResponse> listener
     ) throws IOException {
 
+        System.out.println("Inside ProtobufTransportClusterStateAction.clusterManagerOperation");
         final Predicate<ClusterState> acceptableClusterStatePredicate = request.waitForMetadataVersion() == null
             ? clusterState -> true
             : clusterState -> clusterState.metadata().version() >= request.waitForMetadataVersion();
@@ -147,6 +148,9 @@ public void onTimeout(TimeValue timeout) {
 
     private ProtobufClusterStateResponse buildResponse(final ProtobufClusterStateRequest request, final ClusterState currentState) {
         logger.trace("Serving cluster state request using version {}", currentState.version());
+        System.out.println("Protobuf Building cluster state response");
+        System.out.println("ProtobufClusterStateRequest: " + request.toString());
+        System.out.println("ClusterState: " + currentState.toString());
         ClusterState.Builder builder = ClusterState.builder(currentState.getClusterName());
         builder.version(currentState.version());
         builder.stateUUID(currentState.stateUUID());
@@ -210,4 +214,9 @@ private ProtobufClusterStateResponse buildResponse(final ProtobufClusterStateReq
         return new ProtobufClusterStateResponse(currentState.getClusterName(), builder.build(), false);
     }
 
+    @Override
+    protected ProtobufClusterStateResponse read(byte[] in) throws IOException {
+        return new ProtobufClusterStateResponse(in);
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
index e57d2cf1b9803..e5b487b981669 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
@@ -121,6 +121,7 @@ protected void clusterManagerOperation(
         final ActionListener<ClusterStateResponse> listener
     ) throws IOException {
 
+        System.out.println("Cluster state action called");
         final Predicate<ClusterState> acceptableClusterStatePredicate = request.waitForMetadataVersion() == null
             ? clusterState -> true
             : clusterState -> clusterState.metadata().version() >= request.waitForMetadataVersion();
@@ -168,6 +169,9 @@ public void onTimeout(TimeValue timeout) {
 
     private ClusterStateResponse buildResponse(final ClusterStateRequest request, final ClusterState currentState) {
         logger.trace("Serving cluster state request using version {}", currentState.version());
+        System.out.println("Building cluster state response");
+        System.out.println("ClusterStateRequest: " + request.toString());
+        System.out.println("ClusterState: " + currentState.toString());
         ClusterState.Builder builder = ClusterState.builder(currentState.getClusterName());
         builder.version(currentState.version());
         builder.stateUUID(currentState.stateUUID());
diff --git a/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java b/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java
index 08dd2acfec50c..da66b2fb67af2 100644
--- a/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java
+++ b/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java
@@ -354,6 +354,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                             // TODO Auto-generated method stub
                             throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                         }
+
+                        @Override
+                        public FieldCapabilitiesIndexResponse read(byte[] in) throws IOException {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'read'");
+                        }
                     }
                 );
             }
diff --git a/server/src/main/java/org/opensearch/action/resync/TransportResyncReplicationAction.java b/server/src/main/java/org/opensearch/action/resync/TransportResyncReplicationAction.java
index f574ae6bd6df2..c182ff29d69b0 100644
--- a/server/src/main/java/org/opensearch/action/resync/TransportResyncReplicationAction.java
+++ b/server/src/main/java/org/opensearch/action/resync/TransportResyncReplicationAction.java
@@ -265,6 +265,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                 }
+
+                @Override
+                public ResyncReplicationResponse read(byte[] in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
             }
         );
     }
diff --git a/server/src/main/java/org/opensearch/action/search/PitService.java b/server/src/main/java/org/opensearch/action/search/PitService.java
index 61496264be5a6..06f4035d8389a 100644
--- a/server/src/main/java/org/opensearch/action/search/PitService.java
+++ b/server/src/main/java/org/opensearch/action/search/PitService.java
@@ -216,6 +216,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                 }
+
+                @Override
+                public GetAllPitNodesResponse read(byte[] in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
             }
         );
     }
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java b/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
index 0078815cdaf62..865f1d300c91f 100644
--- a/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
@@ -76,6 +76,7 @@ protected ProtobufHandledTransportAction(
     class TransportHandler implements ProtobufTransportRequestHandler<Request> {
         @Override
         public final void messageReceived(final Request request, final TransportChannel channel, ProtobufTask task) {
+            System.out.println("ProtobufHandledTransportAction: messageReceived");
             // We already got the task created on the network layer - no need to create it again on the transport layer
             execute(task, request, new ProtobufChannelActionListener<>(channel, actionName, request));
         }
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java b/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
index d0156218dc381..47a8c44fa5557 100644
--- a/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
@@ -149,6 +149,9 @@ public void onFailure(Exception e) {
      * Use this method when the transport action should continue to run in the context of the current task
     */
     public final void execute(ProtobufTask task, Request request, ActionListener<Response> listener) {
+        System.out.println("Inside execute");
+        System.out.println("task: " + task);
+        System.out.println("request: " + request);
         ActionRequestValidationException validationException = request.validate();
         if (validationException != null) {
             listener.onFailure(validationException);
@@ -186,6 +189,10 @@ private RequestFilterChain(ProtobufTransportAction<Request, Response> action, Lo
         @Override
         public void proceed(ProtobufTask task, String actionName, Request request, ActionListener<Response> listener) {
             int i = index.getAndIncrement();
+            System.out.println("Inside proceed");
+            System.out.println("task: " + task);
+            System.out.println("actionName: " + actionName);
+            System.out.println("request: " + request);
             try {
                 if (i < this.action.filters.length) {
                     this.action.filters[i].apply(task, actionName, request, listener, this);
diff --git a/server/src/main/java/org/opensearch/action/support/broadcast/TransportBroadcastAction.java b/server/src/main/java/org/opensearch/action/support/broadcast/TransportBroadcastAction.java
index 109f73685901e..e54169a683f94 100644
--- a/server/src/main/java/org/opensearch/action/support/broadcast/TransportBroadcastAction.java
+++ b/server/src/main/java/org/opensearch/action/support/broadcast/TransportBroadcastAction.java
@@ -244,6 +244,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                                     // TODO Auto-generated method stub
                                     throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                                 }
+
+                                @Override
+                                public ShardResponse read(byte[] in) throws IOException {
+                                    // TODO Auto-generated method stub
+                                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                                }
                             }
                         );
                     }
diff --git a/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java b/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
index 597d45a35db3f..8bfc28f9d5757 100644
--- a/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
@@ -409,6 +409,13 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                             // TODO Auto-generated method stub
                             throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                         }
+
+                        @Override
+                        public TransportBroadcastByNodeAction<Request, Response, ShardOperationResult>.NodeResponse read(
+                                byte[] in) throws IOException {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'read'");
+                        }
                     }
                 );
             } catch (Exception e) {
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
index 02b8f7db082ba..93366069a52ea 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
@@ -101,6 +101,8 @@ protected ProtobufTransportClusterManagerNodeAction(
 
     protected abstract Response read(CodedInputStream in) throws IOException;
 
+    protected abstract Response read(byte[] in) throws IOException;
+
     /**
      * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #clusterManagerOperation(ProtobufClusterManagerNodeRequest, ClusterState, ActionListener)}
      */
@@ -216,13 +218,12 @@ public Exception getTimeoutException(Exception e) {
 
         protected void doStart(ClusterState clusterState) {
             try {
-                // System.out.println("ProtobufTransportClusterManagerNodeAction.doStart");
-                //this needs fixing
+                System.out.println("ProtobufTransportClusterManagerNodeAction.doStart");
                 final DiscoveryNodes nodes = clusterService.state().nodes();
-                // System.out.println("nodes: " + nodes);
+                System.out.println("nodes: " + nodes);
                 // final DiscoveryNodes discoveryNodes = clusterService.state().nodes();
                 if (nodes.isLocalNodeElectedClusterManager() || localExecute(request)) {
-                    // System.out.println("ProtobufTransportClusterManagerNodeAction.doStart.isLocalNodeElectedClusterManager");
+                    System.out.println("ProtobufTransportClusterManagerNodeAction.doStart.isLocalNodeElectedClusterManager");
                     // check for block, if blocked, retry, else, execute locally
                     final ClusterBlockException blockException = checkBlock(request, clusterState);
                     if (blockException != null) {
@@ -242,6 +243,7 @@ protected void doStart(ClusterState clusterState) {
                             });
                         }
                     } else {
+                        System.out.println("No blocks");
                         ActionListener<Response> delegate = ActionListener.delegateResponse(listener, (delegatedListener, t) -> {
                             if (t instanceof FailedToCommitClusterStateException || t instanceof NotClusterManagerException) {
                                 logger.debug(
@@ -261,13 +263,13 @@ protected void doStart(ClusterState clusterState) {
                             .execute(ActionRunnable.wrap(delegate, l -> clusterManagerOperation(task, request, clusterState, l)));
                     }
                 } else {
-                    // System.out.println("In else");
+                    System.out.println("In else");
                     if (nodes.getClusterManagerNode() == null) {
-                        // System.out.println("In else if");
+                        System.out.println("In else if");
                         logger.debug("no known cluster-manager node, scheduling a retry");
                         retryOnMasterChange(clusterState, null);
                     } else {
-                        // System.out.println("In else else");
+                        System.out.println("In else else");
                         DiscoveryNode clusterManagerNode = nodes.getClusterManagerNode();
                         final String actionName = getClusterManagerActionName(clusterManagerNode);
                         transportService.sendRequest(
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
index 5c7edaf450fc5..7de1327a10423 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
@@ -231,11 +231,11 @@ public Exception getTimeoutException(Exception e) {
 
         protected void doStart(ClusterState clusterState) {
             try {
-                // System.out.println("TransportClusterManagerNodeAction.doStart");
+                System.out.println("TransportClusterManagerNodeAction.doStart");
                 final DiscoveryNodes nodes = clusterState.nodes();
                 // System.out.println("nodes: " + nodes);
                 if (nodes.isLocalNodeElectedClusterManager() || localExecute(request)) {
-                    // System.out.println("TransportClusterManagerNodeAction.doStart.isLocalNodeElectedClusterManager");
+                    System.out.println("TransportClusterManagerNodeAction.doStart.isLocalNodeElectedClusterManager");
                     // check for block, if blocked, retry, else, execute locally
                     final ClusterBlockException blockException = checkBlock(request, clusterState);
                     if (blockException != null) {
@@ -255,6 +255,7 @@ protected void doStart(ClusterState clusterState) {
                             });
                         }
                     } else {
+                        System.out.println("No blocks");
                         ActionListener<Response> delegate = ActionListener.delegateResponse(listener, (delegatedListener, t) -> {
                             if (t instanceof FailedToCommitClusterStateException || t instanceof NotClusterManagerException) {
                                 logger.debug(
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
index 1d9fdfd4b25d9..cd8f53f318ad1 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
@@ -34,6 +34,10 @@ protected ProtobufBaseNodeResponse(CodedInputStream in) throws IOException {
         node = new DiscoveryNode(in);
     }
 
+    protected ProtobufBaseNodeResponse(byte[] data) {
+        
+    }
+
     protected ProtobufBaseNodeResponse(DiscoveryNode node) {
         assert node != null;
         this.node = node;
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
index 490c1a8ecf862..646c83933c60c 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
@@ -60,6 +60,10 @@ protected ProtobufBaseNodesRequest(CodedInputStream in) throws IOException {
         timeout = protobufStreamInput.readOptionalTimeValue();
     }
 
+    protected ProtobufBaseNodesRequest(byte[] data) throws IOException {
+        // this(CodedInputStream.newInstance(data));
+    }
+
     protected ProtobufBaseNodesRequest(String... nodesIds) {
         this.nodesIds = nodesIds;
     }
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
index c42b1163c51c9..fa6bf3d01cc74 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
@@ -176,6 +176,8 @@ protected abstract NodesResponse newResponse(
 
     protected abstract NodeResponse newNodeResponse(CodedInputStream in) throws IOException;
 
+    protected abstract NodeResponse newNodeResponse(byte[] in) throws IOException;
+
     protected abstract NodeResponse nodeOperation(NodeRequest request);
 
     protected NodeResponse nodeOperation(NodeRequest request, ProtobufTask task) {
@@ -283,6 +285,11 @@ public NodeResponse read(StreamInput in) throws IOException {
                             public void handleException(TransportException exp) {
                                 onFailure(idx, node.getId(), exp);
                             }
+
+                            @Override
+                            public NodeResponse read(byte[] in) throws IOException {
+                                return newNodeResponse(in);
+                            }
                         }
                     );
                 } catch (Exception e) {
@@ -322,6 +329,7 @@ class NodeTransportHandler implements ProtobufTransportRequestHandler<NodeReques
 
         @Override
         public void messageReceived(NodeRequest request, TransportChannel channel, ProtobufTask task) throws Exception {
+            System.out.println("ProtoTransportNodesAction.NodeTransportHandler.messageReceived");
             channel.sendResponse(nodeOperation(request, task));
         }
     }
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java b/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
index 01ce93ad14c43..b87d6566850d5 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
@@ -303,6 +303,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                                 // TODO Auto-generated method stub
                                 throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                             }
+
+                            @Override
+                            public NodeResponse read(byte[] in) throws IOException {
+                                // TODO Auto-generated method stub
+                                throw new UnsupportedOperationException("Unimplemented method 'read'");
+                            }
                         }
                     );
                 } catch (Exception e) {
diff --git a/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java b/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java
index 648321f2b060c..de25f848d4aab 100644
--- a/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java
+++ b/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java
@@ -1117,6 +1117,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                 }
+
+                @Override
+                public Response read(byte[] in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
             });
         }
 
diff --git a/server/src/main/java/org/opensearch/action/support/single/instance/TransportInstanceSingleOperationAction.java b/server/src/main/java/org/opensearch/action/support/single/instance/TransportInstanceSingleOperationAction.java
index 972f52d82b086..3cf85ff3311c3 100644
--- a/server/src/main/java/org/opensearch/action/support/single/instance/TransportInstanceSingleOperationAction.java
+++ b/server/src/main/java/org/opensearch/action/support/single/instance/TransportInstanceSingleOperationAction.java
@@ -260,6 +260,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                 }
+
+                @Override
+                public Response read(byte[] in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
             });
         }
 
diff --git a/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java b/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java
index 22eb74b03bf52..ac1da4329bc2e 100644
--- a/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java
+++ b/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java
@@ -241,6 +241,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                             throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                         }
 
+                        @Override
+                        public Response read(byte[] in) throws IOException {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'read'");
+                        }
+
                         
                     }
                 );
@@ -331,6 +337,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                             // TODO Auto-generated method stub
                             throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                         }
+
+                        @Override
+                        public Response read(byte[] in) throws IOException {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'read'");
+                        }
                     }
                 );
             }
diff --git a/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java b/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java
index b26e09b10e130..657222e7a31e7 100644
--- a/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java
+++ b/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java
@@ -332,6 +332,13 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                                         // TODO Auto-generated method stub
                                         throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                                     }
+
+                                    @Override
+                                    public TransportTasksAction<OperationTask, TasksRequest, TasksResponse, TaskResponse>.NodeTasksResponse read(
+                                            byte[] in) throws IOException {
+                                        // TODO Auto-generated method stub
+                                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                                    }
                                 }
                             );
                         }
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterChangedEvent.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterChangedEvent.java
deleted file mode 100644
index ca58668147e26..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/ProtobufClusterChangedEvent.java
+++ /dev/null
@@ -1,308 +0,0 @@
-// /*
-// * 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.
-// */
-
-// package org.opensearch.cluster;
-
-// import org.opensearch.cluster.metadata.IndexGraveyard;
-// import org.opensearch.cluster.metadata.IndexGraveyard.IndexGraveyardDiff;
-// import org.opensearch.cluster.metadata.IndexMetadata;
-// import org.opensearch.cluster.metadata.Metadata;
-// import org.opensearch.cluster.node.DiscoveryNodes;
-// import org.opensearch.cluster.node.DiscoveryNodes;
-// import org.opensearch.gateway.GatewayService;
-// import org.opensearch.index.Index;
-
-// import java.util.ArrayList;
-// import java.util.Collections;
-// import java.util.HashSet;
-// import java.util.List;
-// import java.util.Map;
-// import java.util.Objects;
-// import java.util.Set;
-// import java.util.stream.Collectors;
-
-// /**
-//  * An event received by the local node, signaling that the cluster state has changed.
-// *
-// * @opensearch.internal
-// */
-// public class ProtobufClusterChangedEvent {
-
-//     private final String source;
-
-//     private final ProtobufClusterState previousState;
-
-//     private final ProtobufClusterState state;
-
-//     private final DiscoveryNodes.Delta nodesDelta;
-
-//     public ProtobufClusterChangedEvent(String source, ProtobufClusterState state, ProtobufClusterState previousState) {
-//         Objects.requireNonNull(source, "source must not be null");
-//         Objects.requireNonNull(state, "state must not be null");
-//         Objects.requireNonNull(previousState, "previousState must not be null");
-//         this.source = source;
-//         this.state = state;
-//         this.previousState = previousState;
-//         this.nodesDelta = state.nodes().delta(previousState.nodes());
-//     }
-
-//     /**
-//      * The source that caused this cluster event to be raised.
-//     */
-//     public String source() {
-//         return this.source;
-//     }
-
-//     /**
-//      * The new cluster state that caused this change event.
-//     */
-//     public ProtobufClusterState state() {
-//         return this.state;
-//     }
-
-//     /**
-//      * The previous cluster state for this change event.
-//     */
-//     public ProtobufClusterState previousState() {
-//         return this.previousState;
-//     }
-
-//     /**
-//      * Returns <code>true</code> iff the routing tables (for all indices) have
-//     * changed between the previous cluster state and the current cluster state.
-//     * Note that this is an object reference equality test, not an equals test.
-//     */
-//     public boolean routingTableChanged() {
-//         return state.routingTable() != previousState.routingTable();
-//     }
-
-//     /**
-//      * Returns <code>true</code> iff the routing table has changed for the given index.
-//     * Note that this is an object reference equality test, not an equals test.
-//     */
-//     public boolean indexRoutingTableChanged(String index) {
-//         Objects.requireNonNull(index, "index must not be null");
-//         if (!state.routingTable().hasIndex(index) && !previousState.routingTable().hasIndex(index)) {
-//             return false;
-//         }
-//         if (state.routingTable().hasIndex(index) && previousState.routingTable().hasIndex(index)) {
-//             return state.routingTable().index(index) != previousState.routingTable().index(index);
-//         }
-//         return true;
-//     }
-
-//     /**
-//      * Returns the indices created in this event
-//     */
-//     public List<String> indicesCreated() {
-//         if (!metadataChanged()) {
-//             return Collections.emptyList();
-//         }
-//         List<String> created = null;
-//         for (final String index : state.metadata().indices().keySet()) {
-//             if (!previousState.metadata().hasIndex(index)) {
-//                 if (created == null) {
-//                     created = new ArrayList<>();
-//                 }
-//                 created.add(index);
-//             }
-//         }
-//         return created == null ? Collections.<String>emptyList() : created;
-//     }
-
-//     /**
-//      * Returns the indices deleted in this event
-//     */
-//     public List<Index> indicesDeleted() {
-//         if (previousState.blocks().hasGlobalBlock(GatewayService.STATE_NOT_RECOVERED_BLOCK)) {
-//             // working off of a non-initialized previous state, so use the tombstones for index deletions
-//             return indicesDeletedFromTombstones();
-//         } else {
-//             // examine the diffs in index metadata between the previous and new cluster states to get the deleted indices
-//             return indicesDeletedFromClusterState();
-//         }
-//     }
-
-//     /**
-//      * Returns <code>true</code> iff the metadata for the cluster has changed between
-//     * the previous cluster state and the new cluster state. Note that this is an object
-//     * reference equality test, not an equals test.
-//     */
-//     public boolean metadataChanged() {
-//         return state.metadata() != previousState.metadata();
-//     }
-
-//     /**
-//      * Returns a set of custom meta data types when any custom metadata for the cluster has changed
-//     * between the previous cluster state and the new cluster state. custom meta data types are
-//     * returned iff they have been added, updated or removed between the previous and the current state
-//     */
-//     public Set<String> changedCustomMetadataSet() {
-//         Set<String> result = new HashSet<>();
-//         Map<String, Metadata.Custom> currentCustoms = state.metadata().customs();
-//         Map<String, Metadata.Custom> previousCustoms = previousState.metadata().customs();
-//         if (currentCustoms.equals(previousCustoms) == false) {
-//             for (Map.Entry<String, Metadata.Custom> currentCustomMetadata : currentCustoms.entrySet()) {
-//                 // new custom md added or existing custom md changed
-//                 if (previousCustoms.containsKey(currentCustomMetadata.getKey()) == false
-//                     || currentCustomMetadata.getValue().equals(previousCustoms.get(currentCustomMetadata.getKey())) == false) {
-//                     result.add(currentCustomMetadata.getKey());
-//                 }
-//             }
-//             // existing custom md deleted
-//             for (Map.Entry<String, Metadata.Custom> previousCustomMetadata : previousCustoms.entrySet()) {
-//                 if (currentCustoms.containsKey(previousCustomMetadata.getKey()) == false) {
-//                     result.add(previousCustomMetadata.getKey());
-//                 }
-//             }
-//         }
-//         return result;
-//     }
-
-//     /**
-//      * Returns <code>true</code> iff the {@link IndexMetadata} for a given index
-//     * has changed between the previous cluster state and the new cluster state.
-//     * Note that this is an object reference equality test, not an equals test.
-//     */
-//     public static boolean indexMetadataChanged(IndexMetadata metadata1, IndexMetadata metadata2) {
-//         assert metadata1 != null && metadata2 != null;
-//         // no need to check on version, since disco modules will make sure to use the
-//         // same instance if its a version match
-//         return metadata1 != metadata2;
-//     }
-
-//     /**
-//      * Returns <code>true</code> iff the cluster level blocks have changed between cluster states.
-//     * Note that this is an object reference equality test, not an equals test.
-//     */
-//     public boolean blocksChanged() {
-//         return state.blocks() != previousState.blocks();
-//     }
-
-//     /**
-//      * Returns <code>true</code> iff the local node is the mater node of the cluster.
-//     */
-//     public boolean localNodeClusterManager() {
-//         return state.nodes().isLocalNodeElectedClusterManager();
-//     }
-
-//     /**
-//      * Returns <code>true</code> iff the local node is the mater node of the cluster.
-//     *
-//     * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #localNodeClusterManager()}
-//     */
-//     @Deprecated
-//     public boolean localNodeMaster() {
-//         return localNodeClusterManager();
-//     }
-
-//     /**
-//      * Returns the {@link org.opensearch.cluster.node.DiscoveryNodes.Delta} between
-//     * the previous cluster state and the new cluster state.
-//     */
-//     public DiscoveryNodes.Delta nodesDelta() {
-//         return this.nodesDelta;
-//     }
-
-//     /**
-//      * Returns <code>true</code> iff nodes have been removed from the cluster since the last cluster state.
-//     */
-//     public boolean nodesRemoved() {
-//         return nodesDelta.removed();
-//     }
-
-//     /**
-//      * Returns <code>true</code> iff nodes have been added from the cluster since the last cluster state.
-//     */
-//     public boolean nodesAdded() {
-//         return nodesDelta.added();
-//     }
-
-//     /**
-//      * Returns <code>true</code> iff nodes have been changed (added or removed) from the cluster since the last cluster state.
-//     */
-//     public boolean nodesChanged() {
-//         return nodesRemoved() || nodesAdded();
-//     }
-
-//     /**
-//      * Determines whether or not the current cluster state represents an entirely
-//     * new cluster, either when a node joins a cluster for the first time or when
-//     * the node receives a cluster state update from a brand new cluster (different
-//     * UUID from the previous cluster), which will happen when a cluster-manager node is
-//     * elected that has never been part of the cluster before.
-//     */
-//     public boolean isNewCluster() {
-//         final String prevClusterUUID = previousState.metadata().clusterUUID();
-//         final String currClusterUUID = state.metadata().clusterUUID();
-//         return prevClusterUUID.equals(currClusterUUID) == false;
-//     }
-
-//     // Get the deleted indices by comparing the index metadatas in the previous and new cluster states.
-//     // If an index exists in the previous cluster state, but not in the new cluster state, it must have been deleted.
-//     private List<Index> indicesDeletedFromClusterState() {
-//         // If the new cluster state has a new cluster UUID, the likely scenario is that a node was elected cluster-manager
-//         // that has had its data directory wiped out, in which case we don't want to delete the indices and lose data;
-//         // rather we want to import them as dangling indices instead. So we check here if the cluster UUID differs from the previous
-//         // cluster UUID, in which case, we don't want to delete indices that the cluster-manager erroneously believes shouldn't exist.
-//         // See test DiscoveryWithServiceDisruptionsIT.testIndicesDeleted()
-//         // See discussion on https://github.com/elastic/elasticsearch/pull/9952 and
-//         // https://github.com/elastic/elasticsearch/issues/11665
-//         if (metadataChanged() == false || isNewCluster()) {
-//             return Collections.emptyList();
-//         }
-//         Set<Index> deleted = null;
-//         final Metadata previousMetadata = previousState.metadata();
-//         final Metadata currentMetadata = state.metadata();
-
-//         for (final IndexMetadata index : previousMetadata.indices().values()) {
-//             IndexMetadata current = currentMetadata.index(index.getIndex());
-//             if (current == null) {
-//                 if (deleted == null) {
-//                     deleted = new HashSet<>();
-//                 }
-//                 deleted.add(index.getIndex());
-//             }
-//         }
-
-//         final IndexGraveyard currentGraveyard = currentMetadata.indexGraveyard();
-//         final IndexGraveyard previousGraveyard = previousMetadata.indexGraveyard();
-
-//         // Look for new entries in the index graveyard, where there's no corresponding index in the
-//         // previous metadata. This indicates that a dangling index has been explicitly deleted, so
-//         // each node should make sure to delete any related data.
-//         if (currentGraveyard != previousGraveyard) {
-//             final IndexGraveyardDiff indexGraveyardDiff = (IndexGraveyardDiff) currentGraveyard.diff(previousGraveyard);
-
-//             final List<IndexGraveyard.Tombstone> added = indexGraveyardDiff.getAdded();
-
-//             if (added.isEmpty() == false) {
-//                 if (deleted == null) {
-//                     deleted = new HashSet<>();
-//                 }
-//                 for (IndexGraveyard.Tombstone tombstone : added) {
-//                     deleted.add(tombstone.getIndex());
-//                 }
-//             }
-//         }
-
-//         return deleted == null ? Collections.<Index>emptyList() : new ArrayList<>(deleted);
-//     }
-
-//     private List<Index> indicesDeletedFromTombstones() {
-//         // We look at the full tombstones list to see which indices need to be deleted. In the case of
-//         // a valid previous cluster state, indicesDeletedFromClusterState() will be used to get the deleted
-//         // list, so a diff doesn't make sense here. When a node (re)joins the cluster, its possible for it
-//         // to re-process the same deletes or process deletes about indices it never knew about. This is not
-//         // an issue because there are safeguards in place in the delete store operation in case the index
-//         // folder doesn't exist on the file system.
-//         List<IndexGraveyard.Tombstone> tombstones = state.metadata().indexGraveyard().getTombstones();
-//         return tombstones.stream().map(IndexGraveyard.Tombstone::getIndex).collect(Collectors.toList());
-//     }
-
-// }
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java
deleted file mode 100644
index 4bfd0ab460719..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/ProtobufClusterState.java
+++ /dev/null
@@ -1,872 +0,0 @@
-/*
-* 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.
-*/
-
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
-package org.opensearch.cluster;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import com.carrotsearch.hppc.cursors.ObjectCursor;
-import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
-import org.opensearch.cluster.block.ClusterBlock;
-import org.opensearch.cluster.block.ClusterBlocks;
-import org.opensearch.cluster.coordination.CoordinationMetadata;
-import org.opensearch.cluster.coordination.CoordinationMetadata.VotingConfigExclusion;
-import org.opensearch.cluster.coordination.CoordinationMetadata.VotingConfiguration;
-import org.opensearch.cluster.metadata.IndexMetadata;
-import org.opensearch.cluster.metadata.Metadata;
-import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.DiscoveryNodes;
-import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.DiscoveryNodes;
-import org.opensearch.cluster.routing.IndexRoutingTable;
-import org.opensearch.cluster.routing.IndexShardRoutingTable;
-import org.opensearch.cluster.routing.RoutingNodes;
-import org.opensearch.cluster.routing.RoutingTable;
-import org.opensearch.cluster.routing.ShardRouting;
-import org.opensearch.cluster.service.ClusterService;
-import org.opensearch.common.Strings;
-import org.opensearch.common.UUIDs;
-import org.opensearch.common.collect.ImmutableOpenMap;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufVersionedNamedWriteable;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.discovery.Discovery;
-
-import java.io.IOException;
-import java.util.EnumSet;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.Set;
-import java.util.stream.StreamSupport;
-
-import static org.opensearch.cluster.coordination.Coordinator.ZEN1_BWC_TERM;
-
-/** not used
- * Represents the current state of the cluster.
-* <p>
-* The cluster state object is immutable with the exception of the {@link RoutingNodes} structure, which is
-* built on demand from the {@link RoutingTable}.
-* The cluster state can be updated only on the cluster-manager node. All updates are performed by on a
-* single thread and controlled by the {@link ClusterService}. After every update the
-* {@link Discovery#publish} method publishes a new version of the cluster state to all other nodes in the
-* cluster. The actual publishing mechanism is delegated to the {@link Discovery#publish} method and depends on
-* the type of discovery.
-* <p>
-* The cluster state implements the {@link Diffable} interface in order to support publishing of cluster state
-* differences instead of the entire state on each change. The publishing mechanism should only send differences
-* to a node if this node was present in the previous version of the cluster state. If a node was
-* not present in the previous version of the cluster state, this node is unlikely to have the previous cluster
-* state version and should be sent a complete version. In order to make sure that the differences are applied to the
-* correct version of the cluster state, each cluster state version update generates {@link #stateUUID} that uniquely
-* identifies this version of the state. This uuid is verified by the {@link ClusterStateDiff#apply} method to
-* make sure that the correct diffs are applied. If uuids don’t match, the {@link ClusterStateDiff#apply} method
-* throws the {@link IncompatibleClusterStateVersionException}, which causes the publishing mechanism to send
-* a full version of the cluster state to the node on which this exception was thrown.
-*
-* @opensearch.internal
-*/
-public class ProtobufClusterState implements ToXContentFragment, ProtobufDiffable<ProtobufClusterState> {
-
-    public static final ProtobufClusterState EMPTY_STATE = builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).build();
-
-    /**
-     * An interface that implementors use when a class requires a client to maybe have a feature.
-    *
-    * @opensearch.internal
-    */
-    public interface FeatureAware {
-
-        /**
-         * An optional feature that is required for the client to have.
-        *
-        * @return an empty optional if no feature is required otherwise a string representing the required feature
-        */
-        default Optional<String> getRequiredFeature() {
-            return Optional.empty();
-        }
-
-        /**
-         * Tests whether the custom should be serialized. The criterion is that
-        * the output stream must be at least the minimum supported version of the custom.
-        * <p>
-        * That is, we only serialize customs to clients than can understand the custom based on the version of the client.
-        *
-        * @param out    the output stream
-        * @param custom the custom to serialize
-        * @param <T>    the type of the custom
-        * @return true if the custom should be serialized and false otherwise
-        */
-        static <T extends ProtobufVersionedNamedWriteable & FeatureAware> boolean shouldSerialize(
-            final CodedOutputStream out,
-            final T custom
-        ) {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            return protobufStreamOutput.getVersion().onOrAfter(custom.getMinimalSupportedVersion());
-        }
-
-    }
-
-    /**
-     * Custom cluster state.
-    *
-    * @opensearch.internal
-    */
-    public interface Custom extends ProtobufNamedDiffable<Custom>, ToXContentFragment, FeatureAware {
-
-        /**
-         * Returns <code>true</code> iff this {@link Custom} is private to the cluster and should never be send to a client.
-        * The default is <code>false</code>;
-        */
-        default boolean isPrivate() {
-            return false;
-        }
-
-    }
-
-    private static final ProtobufNamedDiffableValueSerializer<Custom> CUSTOM_VALUE_SERIALIZER = new ProtobufNamedDiffableValueSerializer<>(
-        Custom.class
-    );
-
-    public static final String UNKNOWN_UUID = "_na_";
-
-    public static final long UNKNOWN_VERSION = -1;
-
-    private final long version;
-
-    private final String stateUUID;
-
-    private final RoutingTable routingTable;
-
-    private final DiscoveryNodes nodes;
-
-    private final Metadata metadata;
-
-    private final ClusterBlocks blocks;
-
-    private final ImmutableOpenMap<String, Custom> customs;
-
-    private final ClusterName clusterName;
-
-    private final boolean wasReadFromDiff;
-
-    private final int minimumClusterManagerNodesOnPublishingClusterManager;
-
-    // built on demand
-    private volatile RoutingNodes routingNodes;
-
-    public ProtobufClusterState(long version, String stateUUID, ProtobufClusterState state) {
-        this(
-            state.clusterName,
-            version,
-            stateUUID,
-            state.metadata(),
-            state.routingTable(),
-            state.nodes(),
-            state.blocks(),
-            state.customs(),
-            -1,
-            false
-        );
-    }
-
-    public ProtobufClusterState(
-        ClusterName clusterName,
-        long version,
-        String stateUUID,
-        Metadata metadata,
-        RoutingTable routingTable,
-        DiscoveryNodes nodes,
-        ClusterBlocks blocks,
-        ImmutableOpenMap<String, Custom> customs,
-        int minimumClusterManagerNodesOnPublishingClusterManager,
-        boolean wasReadFromDiff
-    ) {
-        this.version = version;
-        this.stateUUID = stateUUID;
-        this.clusterName = clusterName;
-        this.metadata = metadata;
-        this.routingTable = routingTable;
-        this.nodes = nodes;
-        this.blocks = blocks;
-        this.customs = customs;
-        this.minimumClusterManagerNodesOnPublishingClusterManager = minimumClusterManagerNodesOnPublishingClusterManager;
-        this.wasReadFromDiff = wasReadFromDiff;
-    }
-
-    public long term() {
-        return coordinationMetadata().term();
-    }
-
-    public long version() {
-        return this.version;
-    }
-
-    public long getVersion() {
-        return version();
-    }
-
-    public long getVersionOrMetadataVersion() {
-        // When following a Zen1 cluster-manager, the cluster state version is not guaranteed to increase,
-        // so instead it is preferable to use the metadata version to determine the freshest node.
-        // However when following a Zen2 cluster-manager the cluster state version should be used.
-        return term() == ZEN1_BWC_TERM ? metadata().version() : version();
-    }
-
-    /**
-     * This stateUUID is automatically generated for for each version of cluster state. It is used to make sure that
-    * we are applying diffs to the right previous state.
-    */
-    public String stateUUID() {
-        return this.stateUUID;
-    }
-
-    public DiscoveryNodes nodes() {
-        return this.nodes;
-    }
-
-    public DiscoveryNodes getNodes() {
-        return nodes();
-    }
-
-    public Metadata metadata() {
-        return this.metadata;
-    }
-
-    public Metadata getMetadata() {
-        return metadata();
-    }
-
-    public CoordinationMetadata coordinationMetadata() {
-        return metadata.coordinationMetadata();
-    }
-
-    public RoutingTable routingTable() {
-        return routingTable;
-    }
-
-    public RoutingTable getRoutingTable() {
-        return routingTable();
-    }
-
-    public ClusterBlocks blocks() {
-        return this.blocks;
-    }
-
-    public ClusterBlocks getBlocks() {
-        return blocks;
-    }
-
-    public ImmutableOpenMap<String, Custom> customs() {
-        return this.customs;
-    }
-
-    public ImmutableOpenMap<String, Custom> getCustoms() {
-        return this.customs;
-    }
-
-    public <T extends Custom> T custom(String type) {
-        return (T) customs.get(type);
-    }
-
-    @SuppressWarnings("unchecked")
-    public <T extends Custom> T custom(String type, T defaultValue) {
-        return (T) customs.getOrDefault(type, defaultValue);
-    }
-
-    public ClusterName getClusterName() {
-        return this.clusterName;
-    }
-
-    public VotingConfiguration getLastAcceptedConfiguration() {
-        return coordinationMetadata().getLastAcceptedConfiguration();
-    }
-
-    public VotingConfiguration getLastCommittedConfiguration() {
-        return coordinationMetadata().getLastCommittedConfiguration();
-    }
-
-    public Set<VotingConfigExclusion> getVotingConfigExclusions() {
-        return coordinationMetadata().getVotingConfigExclusions();
-    }
-
-    /**
-     * Returns a built (on demand) routing nodes view of the routing table.
-    */
-    // public RoutingNodes getRoutingNodes() {
-    // if (routingNodes != null) {
-    // return routingNodes;
-    // }
-    // routingNodes = new RoutingNodes(this);
-    // return routingNodes;
-    // }
-
-    /**
-     * Metrics for cluster state.
-    *
-    * @opensearch.internal
-    */
-    public enum Metric {
-        VERSION("version"),
-
-        /**
-         * @deprecated As of 2.0, because promoting inclusive language, replaced by {@link #CLUSTER_MANAGER_NODE}
-        */
-        @Deprecated
-        MASTER_NODE("master_node"),
-        CLUSTER_MANAGER_NODE("cluster_manager_node"),
-        BLOCKS("blocks"),
-        NODES("nodes"),
-        METADATA("metadata"),
-        ROUTING_TABLE("routing_table"),
-        ROUTING_NODES("routing_nodes"),
-        CUSTOMS("customs");
-
-        private static Map<String, Metric> valueToEnum;
-
-        static {
-            valueToEnum = new HashMap<>();
-            for (Metric metric : Metric.values()) {
-                valueToEnum.put(metric.value, metric);
-            }
-        }
-
-        private final String value;
-
-        Metric(String value) {
-            this.value = value;
-        }
-
-        public static EnumSet<Metric> parseString(String param, boolean ignoreUnknown) {
-            String[] metrics = Strings.splitStringByCommaToArray(param);
-            EnumSet<Metric> result = EnumSet.noneOf(Metric.class);
-            for (String metric : metrics) {
-                if ("_all".equals(metric)) {
-                    result = EnumSet.allOf(Metric.class);
-                    break;
-                }
-                Metric m = valueToEnum.get(metric);
-                if (m == null) {
-                    if (!ignoreUnknown) {
-                        throw new IllegalArgumentException("Unknown metric [" + metric + "]");
-                    }
-                } else {
-                    result.add(m);
-                }
-            }
-            return result;
-        }
-
-        @Override
-        public String toString() {
-            return value;
-        }
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        EnumSet<Metric> metrics = Metric.parseString(params.param("metric", "_all"), true);
-
-        // always provide the cluster_uuid as part of the top-level response (also part of the metadata response)
-        builder.field("cluster_uuid", metadata().clusterUUID());
-
-        if (metrics.contains(Metric.VERSION)) {
-            builder.field("version", version);
-            builder.field("state_uuid", stateUUID);
-        }
-
-        if (metrics.contains(Metric.MASTER_NODE)) {
-            builder.field("master_node", nodes().getClusterManagerNodeId());
-        }
-
-        // Value of the field is identical with the above, and aims to replace the above field.
-        if (metrics.contains(Metric.CLUSTER_MANAGER_NODE)) {
-            builder.field("cluster_manager_node", nodes().getClusterManagerNodeId());
-        }
-
-        if (metrics.contains(Metric.BLOCKS)) {
-            builder.startObject("blocks");
-
-            if (!blocks().global().isEmpty()) {
-                builder.startObject("global");
-                for (ClusterBlock block : blocks().global()) {
-                    block.toXContent(builder, params);
-                }
-                builder.endObject();
-            }
-
-            if (!blocks().indices().isEmpty()) {
-                builder.startObject("indices");
-                for (ObjectObjectCursor<String, Set<ClusterBlock>> entry : blocks().indices()) {
-                    builder.startObject(entry.key);
-                    for (ClusterBlock block : entry.value) {
-                        block.toXContent(builder, params);
-                    }
-                    builder.endObject();
-                }
-                builder.endObject();
-            }
-
-            builder.endObject();
-        }
-
-        // nodes
-        if (metrics.contains(Metric.NODES)) {
-            builder.startObject("nodes");
-            for (DiscoveryNode node : nodes) {
-                node.toXContent(builder, params);
-            }
-            builder.endObject();
-        }
-
-        // meta data
-        if (metrics.contains(Metric.METADATA)) {
-            metadata.toXContent(builder, params);
-        }
-
-        // routing table
-        if (metrics.contains(Metric.ROUTING_TABLE)) {
-            builder.startObject("routing_table");
-            builder.startObject("indices");
-            for (IndexRoutingTable indexRoutingTable : routingTable()) {
-                builder.startObject(indexRoutingTable.getIndex().getName());
-                builder.startObject("shards");
-                for (IndexShardRoutingTable indexShardRoutingTable : indexRoutingTable) {
-                    builder.startArray(Integer.toString(indexShardRoutingTable.shardId().id()));
-                    for (ShardRouting shardRouting : indexShardRoutingTable) {
-                        shardRouting.toXContent(builder, params);
-                    }
-                    builder.endArray();
-                }
-                builder.endObject();
-                builder.endObject();
-            }
-            builder.endObject();
-            builder.endObject();
-        }
-
-        // routing nodes
-        // if (metrics.contains(Metric.ROUTING_NODES)) {
-        // builder.startObject("routing_nodes");
-        // builder.startArray("unassigned");
-        // for (ShardRouting shardRouting : getRoutingNodes().unassigned()) {
-        // shardRouting.toXContent(builder, params);
-        // }
-        // builder.endArray();
-
-        // builder.startObject("nodes");
-        // for (RoutingNode routingNode : getRoutingNodes()) {
-        // builder.startArray(routingNode.nodeId() == null ? "null" : routingNode.nodeId());
-        // for (ShardRouting shardRouting : routingNode) {
-        // shardRouting.toXContent(builder, params);
-        // }
-        // builder.endArray();
-        // }
-        // builder.endObject();
-
-        // builder.endObject();
-        // }
-        if (metrics.contains(Metric.CUSTOMS)) {
-            for (ObjectObjectCursor<String, Custom> cursor : customs) {
-                builder.startObject(cursor.key);
-                cursor.value.toXContent(builder, params);
-                builder.endObject();
-            }
-        }
-
-        return builder;
-    }
-
-    public static Builder builder(ClusterName clusterName) {
-        return new Builder(clusterName);
-    }
-
-    public static Builder builder(ProtobufClusterState state) {
-        return new Builder(state);
-    }
-
-    @Override
-    public String toString() {
-        StringBuilder sb = new StringBuilder();
-        final String TAB = "   ";
-        sb.append("cluster uuid: ")
-            .append(metadata.clusterUUID())
-            .append(" [committed: ")
-            .append(metadata.clusterUUIDCommitted())
-            .append("]")
-            .append("\n");
-        sb.append("version: ").append(version).append("\n");
-        sb.append("state uuid: ").append(stateUUID).append("\n");
-        sb.append("from_diff: ").append(wasReadFromDiff).append("\n");
-        sb.append("meta data version: ").append(metadata.version()).append("\n");
-        sb.append(TAB).append("coordination_metadata:\n");
-        sb.append(TAB).append(TAB).append("term: ").append(coordinationMetadata().term()).append("\n");
-        sb.append(TAB)
-            .append(TAB)
-            .append("last_committed_config: ")
-            .append(coordinationMetadata().getLastCommittedConfiguration())
-            .append("\n");
-        sb.append(TAB)
-            .append(TAB)
-            .append("last_accepted_config: ")
-            .append(coordinationMetadata().getLastAcceptedConfiguration())
-            .append("\n");
-        sb.append(TAB).append(TAB).append("voting tombstones: ").append(coordinationMetadata().getVotingConfigExclusions()).append("\n");
-        for (IndexMetadata indexMetadata : metadata) {
-            sb.append(TAB).append(indexMetadata.getIndex());
-            sb.append(": v[")
-                .append(indexMetadata.getVersion())
-                .append("], mv[")
-                .append(indexMetadata.getMappingVersion())
-                .append("], sv[")
-                .append(indexMetadata.getSettingsVersion())
-                .append("], av[")
-                .append(indexMetadata.getAliasesVersion())
-                .append("]\n");
-            for (int shard = 0; shard < indexMetadata.getNumberOfShards(); shard++) {
-                sb.append(TAB).append(TAB).append(shard).append(": ");
-                sb.append("p_term [").append(indexMetadata.primaryTerm(shard)).append("], ");
-                sb.append("isa_ids ").append(indexMetadata.inSyncAllocationIds(shard)).append("\n");
-            }
-        }
-        if (metadata.customs().isEmpty() == false) {
-            sb.append("metadata customs:\n");
-            for (final Map.Entry<String, Metadata.Custom> cursor : metadata.customs().entrySet()) {
-                final String type = cursor.getKey();
-                final Metadata.Custom custom = cursor.getValue();
-                sb.append(TAB).append(type).append(": ").append(custom);
-            }
-            sb.append("\n");
-        }
-        sb.append(blocks());
-        sb.append(nodes());
-        sb.append(routingTable());
-        // sb.append(getRoutingNodes());
-        if (customs.isEmpty() == false) {
-            sb.append("customs:\n");
-            for (ObjectObjectCursor<String, Custom> cursor : customs) {
-                final String type = cursor.key;
-                final Custom custom = cursor.value;
-                sb.append(TAB).append(type).append(": ").append(custom);
-            }
-        }
-        return sb.toString();
-    }
-
-    /**
-     * Builder for cluster state.
-    *
-    * @opensearch.internal
-    */
-    public static class Builder {
-
-        private final ClusterName clusterName;
-        private long version = 0;
-        private String uuid = UNKNOWN_UUID;
-        private Metadata metadata = Metadata.EMPTY_METADATA;
-        private RoutingTable routingTable = RoutingTable.EMPTY_ROUTING_TABLE;
-        private DiscoveryNodes nodes = DiscoveryNodes.EMPTY_NODES;
-        private ClusterBlocks blocks = ClusterBlocks.EMPTY_CLUSTER_BLOCK;
-        private final ImmutableOpenMap.Builder<String, Custom> customs;
-        private boolean fromDiff;
-        private int minimumClusterManagerNodesOnPublishingClusterManager = -1;
-
-        public Builder(ProtobufClusterState state) {
-            this.clusterName = state.clusterName;
-            this.version = state.version();
-            this.uuid = state.stateUUID();
-            this.nodes = state.nodes();
-            this.routingTable = state.routingTable();
-            this.metadata = state.metadata();
-            this.blocks = state.blocks();
-            this.customs = ImmutableOpenMap.builder(state.customs());
-            this.minimumClusterManagerNodesOnPublishingClusterManager = state.minimumClusterManagerNodesOnPublishingClusterManager;
-            this.fromDiff = false;
-        }
-
-        public Builder(ClusterName clusterName) {
-            customs = ImmutableOpenMap.builder();
-            this.clusterName = clusterName;
-        }
-
-        public Builder nodes(DiscoveryNodes.Builder nodesBuilder) {
-            return nodes(nodesBuilder.build());
-        }
-
-        public Builder nodes(DiscoveryNodes nodes) {
-            this.nodes = nodes;
-            return this;
-        }
-
-        public DiscoveryNodes nodes() {
-            return nodes;
-        }
-
-        public Builder routingTable(RoutingTable routingTable) {
-            this.routingTable = routingTable;
-            return this;
-        }
-
-        public Builder metadata(Metadata.Builder metadataBuilder) {
-            return metadata(metadataBuilder.build());
-        }
-
-        public Builder metadata(Metadata metadata) {
-            this.metadata = metadata;
-            return this;
-        }
-
-        public Builder blocks(ClusterBlocks.Builder blocksBuilder) {
-            return blocks(blocksBuilder.build());
-        }
-
-        public Builder blocks(ClusterBlocks blocks) {
-            this.blocks = blocks;
-            return this;
-        }
-
-        public Builder version(long version) {
-            this.version = version;
-            return this;
-        }
-
-        public Builder incrementVersion() {
-            this.version = version + 1;
-            this.uuid = UNKNOWN_UUID;
-            return this;
-        }
-
-        public Builder stateUUID(String uuid) {
-            this.uuid = uuid;
-            return this;
-        }
-
-        public Builder minimumClusterManagerNodesOnPublishingClusterManager(int minimumClusterManagerNodesOnPublishingClusterManager) {
-            this.minimumClusterManagerNodesOnPublishingClusterManager = minimumClusterManagerNodesOnPublishingClusterManager;
-            return this;
-        }
-
-        public Builder putCustom(String type, Custom custom) {
-            customs.put(type, Objects.requireNonNull(custom, type));
-            return this;
-        }
-
-        public Builder removeCustom(String type) {
-            customs.remove(type);
-            return this;
-        }
-
-        public Builder customs(ImmutableOpenMap<String, Custom> customs) {
-            StreamSupport.stream(customs.spliterator(), false).forEach(cursor -> Objects.requireNonNull(cursor.value, cursor.key));
-            this.customs.putAll(customs);
-            return this;
-        }
-
-        public Builder fromDiff(boolean fromDiff) {
-            this.fromDiff = fromDiff;
-            return this;
-        }
-
-        public ProtobufClusterState build() {
-            if (UNKNOWN_UUID.equals(uuid)) {
-                uuid = UUIDs.randomBase64UUID();
-            }
-            return new ProtobufClusterState(
-                clusterName,
-                version,
-                uuid,
-                metadata,
-                routingTable,
-                nodes,
-                blocks,
-                customs.build(),
-                minimumClusterManagerNodesOnPublishingClusterManager,
-                fromDiff
-            );
-        }
-
-        // public static byte[] toBytes(ProtobufClusterState state) throws IOException {
-        // BytesStreamOutput os = new BytesStreamOutput();
-        // state.writeTo(os);
-        // return BytesReference.toBytes(os.bytes());
-        // }
-
-        // /**
-        // * @param data input bytes
-        // * @param localNode used to set the local node in the cluster state.
-        // */
-        // public static ProtobufClusterState fromBytes(byte[] data, DiscoveryNode localNode, NamedWriteableRegistry registry) throws
-        // IOException {
-        // StreamInput in = new NamedWriteableAwareStreamInput(StreamInput.wrap(data), registry);
-        // return readFrom(in, localNode);
-
-        // }
-    }
-
-    @Override
-    public ProtobufDiff<ProtobufClusterState> protobufDiff(ProtobufClusterState previousState) {
-        return new ClusterStateDiff(previousState, this);
-    }
-
-    public static ProtobufDiff<ProtobufClusterState> readDiffFrom(CodedInputStream in, DiscoveryNode localNode) throws IOException {
-        return new ClusterStateDiff(in, localNode);
-    }
-
-    public static ProtobufClusterState readFrom(CodedInputStream in, DiscoveryNode localNode) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        ClusterName clusterName = new ClusterName(in);
-        Builder builder = new Builder(clusterName);
-        builder.version = in.readInt64();
-        builder.uuid = in.readString();
-        // builder.metadata = Metadata.readFrom(in);
-        // builder.routingTable = RoutingTable.readFrom(in);
-        builder.nodes = DiscoveryNodes.readFromProtobuf(in, localNode);
-        // builder.blocks = ClusterBlocks.readFrom(in);
-        int customSize = in.readInt32();
-        for (int i = 0; i < customSize; i++) {
-            Custom customIndexMetadata = protobufStreamInput.readNamedWriteable(Custom.class);
-            builder.putCustom(customIndexMetadata.getWriteableName(), customIndexMetadata);
-        }
-        builder.minimumClusterManagerNodesOnPublishingClusterManager = in.readInt32();
-        return builder.build();
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        clusterName.writeTo(out);
-        out.writeInt64NoTag(version);
-        out.writeStringNoTag(stateUUID);
-        // metadata.writeTo(out);
-        // routingTable.writeTo(out);
-        nodes.writeTo(out);
-        // blocks.writeTo(out);
-        // filter out custom states not supported by the other node
-        int numberOfCustoms = 0;
-        for (final ObjectCursor<Custom> cursor : customs.values()) {
-            if (FeatureAware.shouldSerialize(out, cursor.value)) {
-                numberOfCustoms++;
-            }
-        }
-        out.writeInt32NoTag(numberOfCustoms);
-        for (final ObjectCursor<Custom> cursor : customs.values()) {
-            if (FeatureAware.shouldSerialize(out, cursor.value)) {
-                protobufStreamOutput.writeNamedWriteable(cursor.value);
-            }
-        }
-        out.writeInt32NoTag(minimumClusterManagerNodesOnPublishingClusterManager);
-    }
-
-    /**
-     * The cluster state diff.
-    *
-    * @opensearch.internal
-    */
-    private static class ClusterStateDiff implements ProtobufDiff<ProtobufClusterState> {
-
-        private final long toVersion;
-
-        private final String fromUuid;
-
-        private final String toUuid;
-
-        private final ClusterName clusterName;
-
-        private final ProtobufDiff<RoutingTable> routingTable;
-
-        private final ProtobufDiff<DiscoveryNodes> nodes;
-
-        private final ProtobufDiff<Metadata> metadata;
-
-        private final ProtobufDiff<ClusterBlocks> blocks;
-
-        private final ProtobufDiff<ImmutableOpenMap<String, Custom>> customs;
-
-        private final int minimumClusterManagerNodesOnPublishingClusterManager;
-
-        ClusterStateDiff(ProtobufClusterState before, ProtobufClusterState after) {
-            fromUuid = before.stateUUID;
-            toUuid = after.stateUUID;
-            toVersion = after.version;
-            clusterName = after.clusterName;
-            routingTable = null;
-            nodes = after.nodes.protobufDiff(before.nodes);;
-            metadata = null;
-            blocks = null;
-            customs = ProtobufDiffableUtils.diff(
-                before.customs,
-                after.customs,
-                ProtobufDiffableUtils.getStringKeySerializer(),
-                CUSTOM_VALUE_SERIALIZER
-            );
-            minimumClusterManagerNodesOnPublishingClusterManager = after.minimumClusterManagerNodesOnPublishingClusterManager;
-        }
-
-        ClusterStateDiff(CodedInputStream in, DiscoveryNode localNode) throws IOException {
-            clusterName = new ClusterName(in);
-            fromUuid = in.readString();
-            toUuid = in.readString();
-            toVersion = in.readInt64();
-            routingTable = null;
-            nodes = DiscoveryNodes.readDiffFrom(in, localNode);
-            metadata = null;
-            blocks = null;
-            customs = ProtobufDiffableUtils.readImmutableOpenMapDiff(
-                in,
-                ProtobufDiffableUtils.getStringKeySerializer(),
-                CUSTOM_VALUE_SERIALIZER
-            );
-            minimumClusterManagerNodesOnPublishingClusterManager = in.readInt32();
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            clusterName.writeTo(out);
-            out.writeStringNoTag(fromUuid);
-            out.writeStringNoTag(toUuid);
-            out.writeInt64NoTag(toVersion);
-            // routingTable.writeTo(out);
-            nodes.writeTo(out);
-            // metadata.writeTo(out);
-            // blocks.writeTo(out);
-            // customs.writeTo(out);
-            // out.writeVInt(minimumClusterManagerNodesOnPublishingClusterManager);
-        }
-
-        @Override
-        public ProtobufClusterState apply(ProtobufClusterState state) {
-            Builder builder = new Builder(clusterName);
-            if (toUuid.equals(state.stateUUID)) {
-                // no need to read the rest - cluster state didn't change
-                return state;
-            }
-            if (fromUuid.equals(state.stateUUID) == false) {
-                throw new IncompatibleClusterStateVersionException(state.version, state.stateUUID, toVersion, fromUuid);
-            }
-            builder.stateUUID(toUuid);
-            builder.version(toVersion);
-            builder.routingTable(routingTable.apply(state.routingTable));
-            builder.nodes(nodes.apply(state.nodes));
-            builder.metadata(metadata.apply(state.metadata));
-            builder.blocks(blocks.apply(state.blocks));
-            builder.customs(customs.apply(state.customs));
-            builder.minimumClusterManagerNodesOnPublishingClusterManager(minimumClusterManagerNodesOnPublishingClusterManager);
-            builder.fromDiff(true);
-            return builder.build();
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateApplier.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateApplier.java
deleted file mode 100644
index ed3abc2165943..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateApplier.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// /*
-// * 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.
-// */
-
-// package org.opensearch.cluster;
-
-// import org.opensearch.cluster.service.ClusterService;
-
-// /**
-//  * A component that is in charge of applying an incoming cluster state to the node internal data structures.
-// * The single apply method is called before the cluster state becomes visible via {@link ClusterService#state()}.
-// *
-// * @opensearch.internal
-// */
-// public interface ProtobufClusterStateApplier {
-
-//     /**
-//      * Called when a new cluster state ({@link ProtobufClusterChangedEvent#state()} needs to be applied. The cluster state to be applied is already
-//     * committed when this method is called, so an applier must therefore be prepared to deal with any state it receives without throwing
-//     * an exception. Throwing an exception from an applier is very bad because it will stop the application of this state before it has
-//     * reached all the other appliers, and will likely result in another attempt to apply the same (or very similar) cluster state which
-//     * might continue until this node is removed from the cluster.
-//     */
-//     void applyProtobufClusterState(ProtobufClusterChangedEvent event);
-// }
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateListener.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateListener.java
deleted file mode 100644
index eb22a3aa01b7e..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateListener.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// /*
-//  * 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.
-//  */
-
-// package org.opensearch.cluster;
-
-// /**
-//  * A listener to be notified when a cluster state changes.
-//  *
-//  * @opensearch.internal
-//  */
-// public interface ProtobufClusterStateListener {
-
-//     /**
-//      * Called when cluster state changes.
-//      */
-//     void clusterChanged(ProtobufClusterChangedEvent event);
-// }
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateObserver.java b/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateObserver.java
deleted file mode 100644
index a551df93bd80d..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/ProtobufClusterStateObserver.java
+++ /dev/null
@@ -1,384 +0,0 @@
-// /*
-//  * 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.
-//  */
-
-// package org.opensearch.cluster;
-
-// import org.apache.logging.log4j.Logger;
-// import org.opensearch.OpenSearchException;
-// import org.opensearch.cluster.service.ClusterApplierService;
-// import org.opensearch.cluster.service.ClusterService;
-// import org.opensearch.common.Nullable;
-// import org.opensearch.common.unit.TimeValue;
-// import org.opensearch.common.util.concurrent.ThreadContext;
-// import org.opensearch.threadpool.ThreadPool;
-
-// import java.util.Objects;
-// import java.util.concurrent.atomic.AtomicReference;
-// import java.util.function.Predicate;
-// import java.util.function.Supplier;
-
-// /**
-//  * A utility class which simplifies interacting with the cluster state in cases where
-//  * one tries to take action based on the current state but may want to wait for a new state
-//  * and retry upon failure.
-//  *
-//  * @opensearch.internal
-//  */
-// public class ProtobufClusterStateObserver {
-
-//     protected final Logger logger;
-
-//     private final Predicate<ProtobufClusterState> MATCH_ALL_CHANGES_PREDICATE = state -> true;
-
-//     private final ClusterApplierService clusterApplierService;
-//     private final ThreadPool threadPool;
-//     private final ThreadContext contextHolder;
-//     volatile TimeValue timeOutValue;
-
-//     final AtomicReference<StoredState> lastObservedState;
-//     final ProtobufTimeoutClusterStateListener clusterStateListener = new ObserverClusterStateListener();
-//     // observingContext is not null when waiting on cluster state changes
-//     final AtomicReference<ObservingContext> observingContext = new AtomicReference<>(null);
-//     volatile Long startTimeMS;
-//     volatile boolean timedOut;
-
-//     public ProtobufClusterStateObserver(ClusterService clusterService, Logger logger, ThreadContext contextHolder) {
-//         this(clusterService, new TimeValue(60000), logger, contextHolder);
-//     }
-
-//     /**
-//      * @param timeout        a global timeout for this observer. After it has expired the observer
-//      *                       will fail any existing or new #waitForNextChange calls. Set to null
-//      *                       to wait indefinitely
-//      */
-//     public ProtobufClusterStateObserver(
-//         ClusterService clusterService,
-//         @Nullable TimeValue timeout,
-//         Logger logger,
-//         ThreadContext contextHolder
-//     ) {
-//         this(clusterService.protobufState(), clusterService, timeout, logger, contextHolder);
-//     }
-
-//     /**
-//      * @param timeout        a global timeout for this observer. After it has expired the observer
-//      *                       will fail any existing or new #waitForNextChange calls. Set to null
-//      *                       to wait indefinitely
-//      */
-//     public ProtobufClusterStateObserver(
-//         ProtobufClusterState initialState,
-//         ClusterService clusterService,
-//         @Nullable TimeValue timeout,
-//         Logger logger,
-//         ThreadContext contextHolder
-//     ) {
-//         this(initialState, clusterService.getClusterApplierService(), timeout, logger, contextHolder);
-//     }
-
-//     public ProtobufClusterStateObserver(
-//         ProtobufClusterState initialState,
-//         ClusterApplierService clusterApplierService,
-//         @Nullable TimeValue timeout,
-//         Logger logger,
-//         ThreadContext contextHolder
-//     ) {
-//         this.clusterApplierService = clusterApplierService;
-//         this.threadPool = clusterApplierService.threadPool();
-//         this.lastObservedState = new AtomicReference<>(new StoredState(initialState));
-//         this.timeOutValue = timeout;
-//         if (timeOutValue != null) {
-//             this.startTimeMS = threadPool.relativeTimeInMillis();
-//         }
-//         this.logger = logger;
-//         this.contextHolder = contextHolder;
-//     }
-
-//     /** sets the last observed state to the currently applied cluster state and returns it */
-//     public ProtobufClusterState setAndGetObservedState() {
-//         if (observingContext.get() != null) {
-//             throw new OpenSearchException("cannot set current cluster state while waiting for a cluster state change");
-//         }
-//         ProtobufClusterState clusterState = clusterApplierService.protobufState();
-//         lastObservedState.set(new StoredState(clusterState));
-//         return clusterState;
-//     }
-
-//     /** indicates whether this observer has timed out */
-//     public boolean isTimedOut() {
-//         return timedOut;
-//     }
-
-//     public void waitForNextChange(Listener listener) {
-//         waitForNextChange(listener, MATCH_ALL_CHANGES_PREDICATE);
-//     }
-
-//     public void waitForNextChange(Listener listener, @Nullable TimeValue timeOutValue) {
-//         waitForNextChange(listener, MATCH_ALL_CHANGES_PREDICATE, timeOutValue);
-//     }
-
-//     public void waitForNextChange(Listener listener, Predicate<ProtobufClusterState> statePredicate) {
-//         waitForNextChange(listener, statePredicate, null);
-//     }
-
-//     /**
-//      * Wait for the next cluster state which satisfies statePredicate
-//      *
-//      * @param listener        callback listener
-//      * @param statePredicate predicate to check whether cluster state changes are relevant and the callback should be called
-//      * @param timeOutValue    a timeout for waiting. If null the global observer timeout will be used.
-//      */
-//     public void waitForNextChange(Listener listener, Predicate<ProtobufClusterState> statePredicate, @Nullable TimeValue timeOutValue) {
-//         listener = new ContextPreservingListener(listener, contextHolder.newRestorableContext(false));
-//         if (observingContext.get() != null) {
-//             throw new OpenSearchException("already waiting for a cluster state change");
-//         }
-
-//         Long timeoutTimeLeftMS;
-//         if (timeOutValue == null) {
-//             timeOutValue = this.timeOutValue;
-//             if (timeOutValue != null) {
-//                 long timeSinceStartMS = threadPool.relativeTimeInMillis() - startTimeMS;
-//                 timeoutTimeLeftMS = timeOutValue.millis() - timeSinceStartMS;
-//                 if (timeoutTimeLeftMS <= 0L) {
-//                     // things have timeout while we were busy -> notify
-//                     logger.trace(
-//                         "observer timed out. notifying listener. timeout setting [{}], time since start [{}]",
-//                         timeOutValue,
-//                         new TimeValue(timeSinceStartMS)
-//                     );
-//                     // update to latest, in case people want to retry
-//                     timedOut = true;
-//                     lastObservedState.set(new StoredState(clusterApplierService.protobufState()));
-//                     listener.onTimeout(timeOutValue);
-//                     return;
-//                 }
-//             } else {
-//                 timeoutTimeLeftMS = null;
-//             }
-//         } else {
-//             this.startTimeMS = threadPool.relativeTimeInMillis();
-//             this.timeOutValue = timeOutValue;
-//             timeoutTimeLeftMS = timeOutValue.millis();
-//             timedOut = false;
-//         }
-
-//         // sample a new state. This state maybe *older* than the supplied state if we are called from an applier,
-//         // which wants to wait for something else to happen
-//         ProtobufClusterState newState = clusterApplierService.protobufState();
-//         if (lastObservedState.get().isOlderOrDifferentClusterManager(newState) && statePredicate.test(newState)) {
-//             // good enough, let's go.
-//             logger.trace("observer: sampled state accepted by predicate ({})", newState);
-//             lastObservedState.set(new StoredState(newState));
-//             listener.onNewClusterState(newState);
-//         } else {
-//             logger.trace("observer: sampled state rejected by predicate ({}). adding listener to ClusterService", newState);
-//             final ObservingContext context = new ObservingContext(listener, statePredicate);
-//             if (!observingContext.compareAndSet(null, context)) {
-//                 throw new OpenSearchException("already waiting for a cluster state change");
-//             }
-//             // clusterApplierService.addTimeoutListener(
-//             // timeoutTimeLeftMS == null ? null : new TimeValue(timeoutTimeLeftMS),
-//             // clusterStateListener
-//             // );
-//         }
-//     }
-
-//     /**
-//      * An observer of the cluster state for changes.
-//      *
-//      * @opensearch.internal
-//      */
-//     class ObserverClusterStateListener implements ProtobufTimeoutClusterStateListener {
-
-//         @Override
-//         public void clusterChanged(ProtobufClusterChangedEvent event) {
-//             ObservingContext context = observingContext.get();
-//             if (context == null) {
-//                 // No need to remove listener as it is the responsibility of the thread that set observingContext to null
-//                 return;
-//             }
-//             final ProtobufClusterState state = event.state();
-//             if (context.statePredicate.test(state)) {
-//                 if (observingContext.compareAndSet(context, null)) {
-//                     // clusterApplierService.removeTimeoutListener(this);
-//                     logger.trace("observer: accepting cluster state change ({})", state);
-//                     lastObservedState.set(new StoredState(state));
-//                     context.listener.onNewClusterState(state);
-//                 } else {
-//                     logger.trace(
-//                         "observer: predicate approved change but observing context has changed "
-//                             + "- ignoring (new cluster state version [{}])",
-//                         state.version()
-//                     );
-//                 }
-//             } else {
-//                 logger.trace("observer: predicate rejected change (new cluster state version [{}])", state.version());
-//             }
-//         }
-
-//         @Override
-//         public void postAdded() {
-//             ObservingContext context = observingContext.get();
-//             if (context == null) {
-//                 // No need to remove listener as it is the responsibility of the thread that set observingContext to null
-//                 return;
-//             }
-//             ProtobufClusterState newState = clusterApplierService.protobufState();
-//             if (lastObservedState.get().isOlderOrDifferentClusterManager(newState) && context.statePredicate.test(newState)) {
-//                 // double check we're still listening
-//                 if (observingContext.compareAndSet(context, null)) {
-//                     logger.trace("observer: post adding listener: accepting current cluster state ({})", newState);
-//                     // clusterApplierService.removeTimeoutListener(this);
-//                     lastObservedState.set(new StoredState(newState));
-//                     context.listener.onNewClusterState(newState);
-//                 } else {
-//                     logger.trace(
-//                         "observer: postAdded - predicate approved state but observing context has changed - ignoring ({})",
-//                         newState
-//                     );
-//                 }
-//             } else {
-//                 logger.trace("observer: postAdded - predicate rejected state ({})", newState);
-//             }
-//         }
-
-//         @Override
-//         public void onClose() {
-//             ObservingContext context = observingContext.getAndSet(null);
-
-//             if (context != null) {
-//                 logger.trace("observer: cluster service closed. notifying listener.");
-//                 // clusterApplierService.removeTimeoutListener(this);
-//                 context.listener.onClusterServiceClose();
-//             }
-//         }
-
-//         @Override
-//         public void onTimeout(TimeValue timeout) {
-//             ObservingContext context = observingContext.getAndSet(null);
-//             if (context != null) {
-//                 // clusterApplierService.removeTimeoutListener(this);
-//                 long timeSinceStartMS = threadPool.relativeTimeInMillis() - startTimeMS;
-//                 logger.trace(
-//                     "observer: timeout notification from cluster service. timeout setting [{}], time since start [{}]",
-//                     timeOutValue,
-//                     new TimeValue(timeSinceStartMS)
-//                 );
-//                 // update to latest, in case people want to retry
-//                 lastObservedState.set(new StoredState(clusterApplierService.protobufState()));
-//                 timedOut = true;
-//                 context.listener.onTimeout(timeOutValue);
-//             }
-//         }
-
-//         @Override
-//         public String toString() {
-//             return "ProtobufClusterStateObserver[" + observingContext.get() + "]";
-//         }
-//     }
-
-//     /**
-//      * The observer considers two cluster states to be the same if they have the same version and cluster-manager node id (i.e. null or set)
-//      *
-//      * @opensearch.internal
-//      */
-//     private static class StoredState {
-//         private final String clusterManagerNodeId;
-//         private final long version;
-
-//         StoredState(ProtobufClusterState clusterState) {
-//             this.clusterManagerNodeId = clusterState.nodes().getClusterManagerNodeId();
-//             this.version = clusterState.version();
-//         }
-
-//         /**
-//          * returns true if stored state is older then given state or they are from a different cluster-manager, meaning they can't be compared
-//          * */
-//         public boolean isOlderOrDifferentClusterManager(ProtobufClusterState clusterState) {
-//             return version < clusterState.version()
-//                 || Objects.equals(clusterManagerNodeId, clusterState.nodes().getClusterManagerNodeId()) == false;
-//         }
-//     }
-
-//     /**
-//      * Listener for the observer.
-//      *
-//      * @opensearch.internal
-//      */
-//     public interface Listener {
-
-//         /** called when a new state is observed */
-//         void onNewClusterState(ProtobufClusterState state);
-
-//         /** called when the cluster service is closed */
-//         void onClusterServiceClose();
-
-//         void onTimeout(TimeValue timeout);
-//     }
-
-//     /**
-//      * Context for the observer.
-//      *
-//      * @opensearch.internal
-//      */
-//     static class ObservingContext {
-//         public final Listener listener;
-//         public final Predicate<ProtobufClusterState> statePredicate;
-
-//         ObservingContext(Listener listener, Predicate<ProtobufClusterState> statePredicate) {
-//             this.listener = listener;
-//             this.statePredicate = statePredicate;
-//         }
-
-//         @Override
-//         public String toString() {
-//             return "ObservingContext[" + listener + "]";
-//         }
-//     }
-
-//     /**
-//      * A context preserving listener.
-//      *
-//      * @opensearch.internal
-//      */
-//     private static final class ContextPreservingListener implements Listener {
-//         private final Listener delegate;
-//         private final Supplier<ThreadContext.StoredContext> contextSupplier;
-
-//         private ContextPreservingListener(Listener delegate, Supplier<ThreadContext.StoredContext> contextSupplier) {
-//             this.contextSupplier = contextSupplier;
-//             this.delegate = delegate;
-//         }
-
-//         @Override
-//         public void onNewClusterState(ProtobufClusterState state) {
-//             try (ThreadContext.StoredContext context = contextSupplier.get()) {
-//                 delegate.onNewClusterState(state);
-//             }
-//         }
-
-//         @Override
-//         public void onClusterServiceClose() {
-//             try (ThreadContext.StoredContext context = contextSupplier.get()) {
-//                 delegate.onClusterServiceClose();
-//             }
-//         }
-
-//         @Override
-//         public void onTimeout(TimeValue timeout) {
-//             try (ThreadContext.StoredContext context = contextSupplier.get()) {
-//                 delegate.onTimeout(timeout);
-//             }
-//         }
-
-//         @Override
-//         public String toString() {
-//             return "ContextPreservingListener[" + delegate + "]";
-//         }
-//     }
-// }
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufTimeoutClusterStateListener.java b/server/src/main/java/org/opensearch/cluster/ProtobufTimeoutClusterStateListener.java
deleted file mode 100644
index 278d11f6ea8e7..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/ProtobufTimeoutClusterStateListener.java
+++ /dev/null
@@ -1,49 +0,0 @@
-// /*
-//  * 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.cluster;
-
-// import org.opensearch.common.unit.TimeValue;
-
-// /**
-//  * An exception to cluster state listener that allows for timeouts and for post added notifications.
-//  *
-//  * @opensearch.internal
-//  */
-// public interface ProtobufTimeoutClusterStateListener extends ProtobufClusterStateListener {
-
-//     void postAdded();
-
-//     void onClose();
-
-//     void onTimeout(TimeValue timeout);
-// }
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
index b0b77a50da072..3910861cbe9bd 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
@@ -42,7 +42,6 @@
 import org.opensearch.cluster.ClusterStateTaskConfig;
 import org.opensearch.cluster.ClusterStateUpdateTask;
 import org.opensearch.cluster.LocalClusterUpdateTask;
-import org.opensearch.cluster.ProtobufClusterState;
 import org.opensearch.cluster.block.ClusterBlocks;
 import org.opensearch.cluster.coordination.ClusterFormationFailureHelper.ClusterFormationState;
 import org.opensearch.cluster.coordination.CoordinationMetadata.VotingConfigExclusion;
@@ -855,19 +854,8 @@ protected void doStart() {
                 )
                 .nodes(DiscoveryNodes.builder().add(getLocalNode()).localNodeId(getLocalNode().getId()))
                 .build();
-            // ProtobufClusterState protobufInitialState = ProtobufClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.get(settings))
-            //     .blocks(
-            //         ClusterBlocks.builder()
-            //             .addGlobalBlock(STATE_NOT_RECOVERED_BLOCK)
-            //             .addGlobalBlock(noClusterManagerBlockService.getNoClusterManagerBlock())
-            //     )
-            //     .nodes(DiscoveryNodes.builder().add(getLocalNode()).localNodeId(getLocalNode().getId()))
-            //     .build();
-            // System.out.println("cluster state initial: " + initialState);
-            // System.out.println("protobuf cluster state initial: " + protobufInitialState);
             applierState = initialState;
             clusterApplier.setInitialState(initialState);
-            // clusterApplier.setInitialProtobufState(protobufInitialState);
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java b/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java
index 67396c892fd18..29f38a8056d95 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java
@@ -415,6 +415,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                         // TODO Auto-generated method stub
                         throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                     }
+
+                    @Override
+                    public Empty read(byte[] in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
                 }
             );
         }
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java b/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java
index afaa4d8e72933..fb5fe5ffc6232 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java
@@ -428,6 +428,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                         // TODO Auto-generated method stub
                         throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                     }
+
+                    @Override
+                    public Empty read(byte[] in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
                 }
             );
         } else {
@@ -470,6 +476,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
             }
+
+            @Override
+            public Empty read(byte[] in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
         });
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java b/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java
index 18a0877e79639..2dfcbcd1e2418 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java
@@ -355,6 +355,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                         // TODO Auto-generated method stub
                         throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                     }
+
+                    @Override
+                    public Empty read(byte[] in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
                 }
             );
         }
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/PreVoteCollector.java b/server/src/main/java/org/opensearch/cluster/coordination/PreVoteCollector.java
index d673fb4ac388a..038f2c77bcc67 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/PreVoteCollector.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/PreVoteCollector.java
@@ -232,6 +232,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                             // TODO Auto-generated method stub
                             throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                         }
+
+                        @Override
+                        public PreVoteResponse read(byte[] in) throws IOException {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'read'");
+                        }
                     }
                 )
             );
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java b/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
index adb80c7687514..6655fdce381ef 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
@@ -404,6 +404,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                         // TODO Auto-generated method stub
                         throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                     }
+
+                    @Override
+                    public Empty read(byte[] in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
                 }
             );
         }
@@ -487,6 +493,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                         // TODO Auto-generated method stub
                         throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                     }
+
+                    @Override
+                    public PublishWithJoinResponse read(byte[] in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
                 };
                 transportService.sendRequest(destination, PUBLISH_STATE_ACTION_NAME, request, stateRequestOptions, responseHandler);
             } catch (Exception e) {
diff --git a/server/src/main/java/org/opensearch/cluster/decommission/DecommissionController.java b/server/src/main/java/org/opensearch/cluster/decommission/DecommissionController.java
index be9042e96c661..f9be3a2de5b8f 100644
--- a/server/src/main/java/org/opensearch/cluster/decommission/DecommissionController.java
+++ b/server/src/main/java/org/opensearch/cluster/decommission/DecommissionController.java
@@ -272,6 +272,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                 }
+
+                @Override
+                public NodesStatsResponse read(byte[] in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
             }
         );
     }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/ProtobufIndexNameExpressionResolver.java b/server/src/main/java/org/opensearch/cluster/metadata/ProtobufIndexNameExpressionResolver.java
deleted file mode 100644
index 27b4d4446014a..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/metadata/ProtobufIndexNameExpressionResolver.java
+++ /dev/null
@@ -1,1351 +0,0 @@
-// /*
-//  * 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.
-//  */
-
-// package org.opensearch.cluster.metadata;
-
-// import org.opensearch.OpenSearchParseException;
-// import org.opensearch.action.IndicesRequest;
-// import org.opensearch.action.support.IndicesOptions;
-// import org.opensearch.cluster.ProtobufClusterState;
-// import org.opensearch.common.Booleans;
-// import org.opensearch.common.Nullable;
-// import org.opensearch.common.Strings;
-// import org.opensearch.common.collect.ImmutableOpenMap;
-// import org.opensearch.common.collect.Tuple;
-// import org.opensearch.common.logging.DeprecationLogger;
-// import org.opensearch.common.regex.Regex;
-// import org.opensearch.common.time.DateFormatter;
-// import org.opensearch.common.time.DateMathParser;
-// import org.opensearch.common.time.DateUtils;
-// import org.opensearch.common.util.CollectionUtils;
-// import org.opensearch.common.util.concurrent.ThreadContext;
-// import org.opensearch.common.util.set.Sets;
-// import org.opensearch.index.Index;
-// import org.opensearch.index.IndexNotFoundException;
-// import org.opensearch.indices.IndexClosedException;
-// import org.opensearch.indices.InvalidIndexNameException;
-
-// import java.time.Instant;
-// import java.time.ZoneId;
-// import java.time.ZoneOffset;
-// import java.util.ArrayList;
-// import java.util.Arrays;
-// import java.util.Collection;
-// import java.util.Collections;
-// import java.util.HashMap;
-// import java.util.HashSet;
-// import java.util.List;
-// import java.util.Map;
-// import java.util.Objects;
-// import java.util.Set;
-// import java.util.SortedMap;
-// import java.util.Spliterators;
-// import java.util.function.Predicate;
-// import java.util.stream.Collectors;
-// import java.util.stream.Stream;
-// import java.util.stream.StreamSupport;
-
-// /**
-//  * Resolves index name from an expression
-//  *
-//  * @opensearch.internal
-//  */
-// public class ProtobufIndexNameExpressionResolver {
-//     private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(ProtobufIndexNameExpressionResolver.class);
-
-//     public static final String EXCLUDED_DATA_STREAMS_KEY = "opensearch.excluded_ds";
-//     public static final String SYSTEM_INDEX_ACCESS_CONTROL_HEADER_KEY = "_system_index_access_allowed";
-
-//     private final DateMathExpressionResolver dateMathExpressionResolver = new DateMathExpressionResolver();
-//     private final WildcardExpressionResolver wildcardExpressionResolver = new WildcardExpressionResolver();
-//     private final List<ExpressionResolver> expressionResolvers = List.of(dateMathExpressionResolver, wildcardExpressionResolver);
-
-//     private final ThreadContext threadContext;
-
-//     public ProtobufIndexNameExpressionResolver(ThreadContext threadContext) {
-//         this.threadContext = Objects.requireNonNull(threadContext, "Thread Context must not be null");
-//     }
-
-//     /**
-//      * Same as {@link #concreteIndexNames(ProtobufClusterState, IndicesOptions, String...)}, but the index expressions and options
-//      * are encapsulated in the specified request.
-//      */
-//     public String[] concreteIndexNames(ProtobufClusterState state, IndicesRequest request) {
-//         Context context = new Context(
-//             state,
-//             request.indicesOptions(),
-//             false,
-//             false,
-//             request.includeDataStreams(),
-//             isSystemIndexAccessAllowed()
-//         );
-//         return concreteIndexNames(context, request.indices());
-//     }
-
-//     /**
-//      * Same as {@link #concreteIndexNames(ProtobufClusterState, IndicesRequest)}, but access to system indices is always allowed.
-//      */
-//     public String[] concreteIndexNamesWithSystemIndexAccess(ProtobufClusterState state, IndicesRequest request) {
-//         Context context = new Context(state, request.indicesOptions(), false, false, request.includeDataStreams(), true);
-//         return concreteIndexNames(context, request.indices());
-//     }
-
-//     /**
-//      * Same as {@link #concreteIndices(ProtobufClusterState, IndicesOptions, String...)}, but the index expressions and options
-//      * are encapsulated in the specified request and resolves data streams.
-//      */
-//     public Index[] concreteIndices(ProtobufClusterState state, IndicesRequest request) {
-//         Context context = new Context(
-//             state,
-//             request.indicesOptions(),
-//             false,
-//             false,
-//             request.includeDataStreams(),
-//             isSystemIndexAccessAllowed()
-//         );
-//         return concreteIndices(context, request.indices());
-//     }
-
-//     /**
-//      * Translates the provided index expression into actual concrete indices, properly deduplicated.
-//      *
-//      * @param state             the cluster state containing all the data to resolve to expressions to concrete indices
-//      * @param options           defines how the aliases or indices need to be resolved to concrete indices
-//      * @param indexExpressions  expressions that can be resolved to alias or index names.
-//      * @return the resolved concrete indices based on the cluster state, indices options and index expressions
-//      * @throws IndexNotFoundException if one of the index expressions is pointing to a missing index or alias and the
-//      * provided indices options in the context don't allow such a case, or if the final result of the indices resolution
-//      * contains no indices and the indices options in the context don't allow such a case.
-//      * @throws IllegalArgumentException if one of the aliases resolve to multiple indices and the provided
-//      * indices options in the context don't allow such a case.
-//      */
-//     public String[] concreteIndexNames(ProtobufClusterState state, IndicesOptions options, String... indexExpressions) {
-//         Context context = new Context(state, options, isSystemIndexAccessAllowed());
-//         return concreteIndexNames(context, indexExpressions);
-//     }
-
-//     public String[] concreteIndexNames(
-//         ProtobufClusterState state,
-//         IndicesOptions options,
-//         boolean includeDataStreams,
-//         String... indexExpressions
-//     ) {
-//         Context context = new Context(state, options, false, false, includeDataStreams, isSystemIndexAccessAllowed());
-//         return concreteIndexNames(context, indexExpressions);
-//     }
-
-//     public String[] concreteIndexNames(ProtobufClusterState state, IndicesOptions options, IndicesRequest request) {
-//         Context context = new Context(state, options, false, false, request.includeDataStreams(), isSystemIndexAccessAllowed());
-//         return concreteIndexNames(context, request.indices());
-//     }
-
-//     public List<String> dataStreamNames(ProtobufClusterState state, IndicesOptions options, String... indexExpressions) {
-//         // Allow system index access - they'll be filtered out below as there's no such thing (yet) as system data streams
-//         Context context = new Context(state, options, false, false, true, true, true);
-//         if (indexExpressions == null || indexExpressions.length == 0) {
-//             indexExpressions = new String[] { "*" };
-//         }
-
-//         List<String> dataStreams = wildcardExpressionResolver.resolve(context, Arrays.asList(indexExpressions));
-//         return ((dataStreams == null) ? List.<String>of() : dataStreams).stream()
-//             .map(x -> state.metadata().getIndicesLookup().get(x))
-//             .filter(Objects::nonNull)
-//             .filter(ia -> ia.getType() == IndexAbstraction.Type.DATA_STREAM)
-//             .map(IndexAbstraction::getName)
-//             .collect(Collectors.toList());
-//     }
-
-//     /**
-//      * Translates the provided index expression into actual concrete indices, properly deduplicated.
-//      *
-//      * @param state             the cluster state containing all the data to resolve to expressions to concrete indices
-//      * @param options           defines how the aliases or indices need to be resolved to concrete indices
-//      * @param indexExpressions  expressions that can be resolved to alias or index names.
-//      * @return the resolved concrete indices based on the cluster state, indices options and index expressions
-//      * @throws IndexNotFoundException if one of the index expressions is pointing to a missing index or alias and the
-//      * provided indices options in the context don't allow such a case, or if the final result of the indices resolution
-//      * contains no indices and the indices options in the context don't allow such a case.
-//      * @throws IllegalArgumentException if one of the aliases resolve to multiple indices and the provided
-//      * indices options in the context don't allow such a case.
-//      */
-//     public Index[] concreteIndices(ProtobufClusterState state, IndicesOptions options, String... indexExpressions) {
-//         return concreteIndices(state, options, false, indexExpressions);
-//     }
-
-//     public Index[] concreteIndices(
-//         ProtobufClusterState state,
-//         IndicesOptions options,
-//         boolean includeDataStreams,
-//         String... indexExpressions
-//     ) {
-//         Context context = new Context(state, options, false, false, includeDataStreams, isSystemIndexAccessAllowed());
-//         return concreteIndices(context, indexExpressions);
-//     }
-
-//     /**
-//      * Translates the provided index expression into actual concrete indices, properly deduplicated.
-//      *
-//      * @param state      the cluster state containing all the data to resolve to expressions to concrete indices
-//      * @param startTime  The start of the request where concrete indices is being invoked for
-//      * @param request    request containing expressions that can be resolved to alias, index, or data stream names.
-//      * @return the resolved concrete indices based on the cluster state, indices options and index expressions
-//      * provided indices options in the context don't allow such a case, or if the final result of the indices resolution
-//      * contains no indices and the indices options in the context don't allow such a case.
-//      * @throws IllegalArgumentException if one of the aliases resolve to multiple indices and the provided
-//      * indices options in the context don't allow such a case.
-//      */
-//     public Index[] concreteIndices(ProtobufClusterState state, IndicesRequest request, long startTime) {
-//         Context context = new Context(
-//             state,
-//             request.indicesOptions(),
-//             startTime,
-//             false,
-//             false,
-//             request.includeDataStreams(),
-//             false,
-//             isSystemIndexAccessAllowed()
-//         );
-//         return concreteIndices(context, request.indices());
-//     }
-
-//     String[] concreteIndexNames(Context context, String... indexExpressions) {
-//         Index[] indexes = concreteIndices(context, indexExpressions);
-//         String[] names = new String[indexes.length];
-//         for (int i = 0; i < indexes.length; i++) {
-//             names[i] = indexes[i].getName();
-//         }
-//         return names;
-//     }
-
-//     Index[] concreteIndices(Context context, String... indexExpressions) {
-//         if (indexExpressions == null || indexExpressions.length == 0) {
-//             indexExpressions = new String[] { Metadata.ALL };
-//         }
-//         Metadata metadata = context.getState().metadata();
-//         IndicesOptions options = context.getOptions();
-//         // If only one index is specified then whether we fail a request if an index is missing depends on the allow_no_indices
-//         // option. At some point we should change this, because there shouldn't be a reason why whether a single index
-//         // or multiple indices are specified yield different behaviour.
-//         final boolean failNoIndices = indexExpressions.length == 1 ? !options.allowNoIndices() : !options.ignoreUnavailable();
-//         List<String> expressions = Arrays.asList(indexExpressions);
-//         for (ExpressionResolver expressionResolver : expressionResolvers) {
-//             expressions = expressionResolver.resolve(context, expressions);
-//         }
-
-//         if (expressions.isEmpty()) {
-//             if (!options.allowNoIndices()) {
-//                 IndexNotFoundException infe;
-//                 if (indexExpressions.length == 1) {
-//                     if (indexExpressions[0].equals(Metadata.ALL)) {
-//                         infe = new IndexNotFoundException("no indices exist", (String) null);
-//                     } else {
-//                         infe = new IndexNotFoundException((String) null);
-//                     }
-//                 } else {
-//                     infe = new IndexNotFoundException((String) null);
-//                 }
-//                 infe.setResources("index_expression", indexExpressions);
-//                 throw infe;
-//             } else {
-//                 return Index.EMPTY_ARRAY;
-//             }
-//         }
-
-//         boolean excludedDataStreams = false;
-//         final Set<Index> concreteIndices = new HashSet<>(expressions.size());
-//         for (String expression : expressions) {
-//             IndexAbstraction indexAbstraction = metadata.getIndicesLookup().get(expression);
-//             if (indexAbstraction == null) {
-//                 if (failNoIndices) {
-//                     IndexNotFoundException infe;
-//                     if (expression.equals(Metadata.ALL)) {
-//                         infe = new IndexNotFoundException("no indices exist", expression);
-//                     } else {
-//                         infe = new IndexNotFoundException(expression);
-//                     }
-//                     infe.setResources("index_expression", expression);
-//                     throw infe;
-//                 } else {
-//                     continue;
-//                 }
-//             } else if (indexAbstraction.getType() == IndexAbstraction.Type.ALIAS && context.getOptions().ignoreAliases()) {
-//                 if (failNoIndices) {
-//                     throw aliasesNotSupportedException(expression);
-//                 } else {
-//                     continue;
-//                 }
-//             } else if (indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM && context.includeDataStreams() == false) {
-//                 excludedDataStreams = true;
-//                 continue;
-//             }
-
-//             if (indexAbstraction.getType() == IndexAbstraction.Type.ALIAS && context.isResolveToWriteIndex()) {
-//                 IndexMetadata writeIndex = indexAbstraction.getWriteIndex();
-//                 if (writeIndex == null) {
-//                     throw new IllegalArgumentException(
-//                         "no write index is defined for alias ["
-//                             + indexAbstraction.getName()
-//                             + "]."
-//                             + " The write index may be explicitly disabled using is_write_index=false or the alias points to multiple"
-//                             + " indices without one being designated as a write index"
-//                     );
-//                 }
-//                 if (addIndex(writeIndex, context)) {
-//                     concreteIndices.add(writeIndex.getIndex());
-//                 }
-//             } else if (indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM && context.isResolveToWriteIndex()) {
-//                 IndexMetadata writeIndex = indexAbstraction.getWriteIndex();
-//                 if (addIndex(writeIndex, context)) {
-//                     concreteIndices.add(writeIndex.getIndex());
-//                 }
-//             } else {
-//                 if (indexAbstraction.getIndices().size() > 1 && !options.allowAliasesToMultipleIndices()) {
-//                     String[] indexNames = new String[indexAbstraction.getIndices().size()];
-//                     int i = 0;
-//                     for (IndexMetadata indexMetadata : indexAbstraction.getIndices()) {
-//                         indexNames[i++] = indexMetadata.getIndex().getName();
-//                     }
-//                     throw new IllegalArgumentException(
-//                         indexAbstraction.getType().getDisplayName()
-//                             + " ["
-//                             + expression
-//                             + "] has more than one index associated with it "
-//                             + Arrays.toString(indexNames)
-//                             + ", can't execute a single index op"
-//                     );
-//                 }
-
-//                 for (IndexMetadata index : indexAbstraction.getIndices()) {
-//                     if (shouldTrackConcreteIndex(context, options, index)) {
-//                         concreteIndices.add(index.getIndex());
-//                     }
-//                 }
-//             }
-//         }
-
-//         if (options.allowNoIndices() == false && concreteIndices.isEmpty()) {
-//             IndexNotFoundException infe = new IndexNotFoundException((String) null);
-//             infe.setResources("index_expression", indexExpressions);
-//             if (excludedDataStreams) {
-//                 // Allows callers to handle IndexNotFoundException differently based on whether data streams were excluded.
-//                 infe.addMetadata(EXCLUDED_DATA_STREAMS_KEY, "true");
-//             }
-//             throw infe;
-//         }
-//         checkSystemIndexAccess(context, metadata, concreteIndices, indexExpressions);
-//         return concreteIndices.toArray(new Index[0]);
-//     }
-
-//     private void checkSystemIndexAccess(Context context, Metadata metadata, Set<Index> concreteIndices, String[] originalPatterns) {
-//         if (context.isSystemIndexAccessAllowed() == false) {
-//             final List<String> resolvedSystemIndices = concreteIndices.stream()
-//                 .map(metadata::index)
-//                 .filter(IndexMetadata::isSystem)
-//                 .map(i -> i.getIndex().getName())
-//                 .sorted() // reliable order for testing
-//                 .collect(Collectors.toList());
-//             if (resolvedSystemIndices.isEmpty() == false) {
-//                 resolvedSystemIndices.forEach(
-//                     systemIndexName -> deprecationLogger.deprecate(
-//                         "open_system_index_access_" + systemIndexName,
-//                         "this request accesses system indices: [{}], but in a future major version, direct access to system "
-//                             + "indices will be prevented by default",
-//                         systemIndexName
-//                     )
-//                 );
-//             }
-//         }
-//     }
-
-//     private static boolean shouldTrackConcreteIndex(Context context, IndicesOptions options, IndexMetadata index) {
-//         if (index.getState() == IndexMetadata.State.CLOSE) {
-//             if (options.forbidClosedIndices() && options.ignoreUnavailable() == false) {
-//                 throw new IndexClosedException(index.getIndex());
-//             } else {
-//                 return options.forbidClosedIndices() == false && addIndex(index, context);
-//             }
-//         } else if (index.getState() == IndexMetadata.State.OPEN) {
-//             return addIndex(index, context);
-//         } else {
-//             throw new IllegalStateException("index state [" + index.getState() + "] not supported");
-//         }
-//     }
-
-//     private static boolean addIndex(IndexMetadata metadata, Context context) {
-//         // This used to check the `index.search.throttled` setting, but we eventually decided that it was
-//         // trappy to hide throttled indices by default. In order to avoid breaking backward compatibility,
-//         // we changed it to look at the `index.frozen` setting instead, since frozen indices were the only
-//         // type of index to use the `search_throttled` threadpool at that time.
-//         // NOTE: The Setting object was defined in an external plugin prior to OpenSearch fork.
-//         return (context.options.ignoreThrottled() && metadata.getSettings().getAsBoolean("index.frozen", false)) == false;
-//     }
-
-//     private static IllegalArgumentException aliasesNotSupportedException(String expression) {
-//         return new IllegalArgumentException(
-//             "The provided expression [" + expression + "] matches an " + "alias, specify the corresponding concrete indices instead."
-//         );
-//     }
-
-//     /**
-//      * Utility method that allows to resolve an index expression to its corresponding single concrete index.
-//      * Callers should make sure they provide proper {@link org.opensearch.action.support.IndicesOptions}
-//      * that require a single index as a result. The indices resolution must in fact return a single index when
-//      * using this method, an {@link IllegalArgumentException} gets thrown otherwise.
-//      *
-//      * @param state             the cluster state containing all the data to resolve to expression to a concrete index
-//      * @param request           The request that defines how the an alias or an index need to be resolved to a concrete index
-//      *                          and the expression that can be resolved to an alias or an index name.
-//      * @throws IllegalArgumentException if the index resolution lead to more than one index
-//      * @return the concrete index obtained as a result of the index resolution
-//      */
-//     public Index concreteSingleIndex(ProtobufClusterState state, IndicesRequest request) {
-//         String indexExpression = CollectionUtils.isEmpty(request.indices()) ? null : request.indices()[0];
-//         Index[] indices = concreteIndices(state, request.indicesOptions(), indexExpression);
-//         if (indices.length != 1) {
-//             throw new IllegalArgumentException(
-//                 "unable to return a single index as the index and options" + " provided got resolved to multiple indices"
-//             );
-//         }
-//         return indices[0];
-//     }
-
-//     /**
-//      * Utility method that allows to resolve an index expression to its corresponding single write index.
-//      *
-//      * @param state             the cluster state containing all the data to resolve to expression to a concrete index
-//      * @param request           The request that defines how the an alias or an index need to be resolved to a concrete index
-//      *                          and the expression that can be resolved to an alias or an index name.
-//      * @throws IllegalArgumentException if the index resolution does not lead to an index, or leads to more than one index
-//      * @return the write index obtained as a result of the index resolution
-//      */
-//     public Index concreteWriteIndex(ProtobufClusterState state, IndicesRequest request) {
-//         if (request.indices() == null || (request.indices() != null && request.indices().length != 1)) {
-//             throw new IllegalArgumentException("indices request must specify a single index expression");
-//         }
-//         return concreteWriteIndex(state, request.indicesOptions(), request.indices()[0], false, request.includeDataStreams());
-//     }
-
-//     /**
-//      * Utility method that allows to resolve an index expression to its corresponding single write index.
-//      *
-//      * @param state             the cluster state containing all the data to resolve to expression to a concrete index
-//      * @param options           defines how the aliases or indices need to be resolved to concrete indices
-//      * @param index             index that can be resolved to alias or index name.
-//      * @param allowNoIndices    whether to allow resolve to no index
-//      * @param includeDataStreams Whether data streams should be included in the evaluation.
-//      * @throws IllegalArgumentException if the index resolution does not lead to an index, or leads to more than one index
-//      * @return the write index obtained as a result of the index resolution or null if no index
-//      */
-//     public Index concreteWriteIndex(
-//         ProtobufClusterState state,
-//         IndicesOptions options,
-//         String index,
-//         boolean allowNoIndices,
-//         boolean includeDataStreams
-//     ) {
-//         IndicesOptions combinedOptions = IndicesOptions.fromOptions(
-//             options.ignoreUnavailable(),
-//             allowNoIndices,
-//             options.expandWildcardsOpen(),
-//             options.expandWildcardsClosed(),
-//             options.expandWildcardsHidden(),
-//             options.allowAliasesToMultipleIndices(),
-//             options.forbidClosedIndices(),
-//             options.ignoreAliases(),
-//             options.ignoreThrottled()
-//         );
-
-//         Context context = new Context(state, combinedOptions, false, true, includeDataStreams, isSystemIndexAccessAllowed());
-//         Index[] indices = concreteIndices(context, index);
-//         if (allowNoIndices && indices.length == 0) {
-//             return null;
-//         }
-//         if (indices.length != 1) {
-//             throw new IllegalArgumentException(
-//                 "The index expression [" + index + "] and options provided did not point to a single write-index"
-//             );
-//         }
-//         return indices[0];
-//     }
-
-//     /**
-//      * @return whether the specified index, data stream or alias exists.
-//      *         If the data stream, index or alias contains date math then that is resolved too.
-//      */
-//     public boolean hasIndexAbstraction(String indexAbstraction, ProtobufClusterState state) {
-//         Context context = new Context(state, IndicesOptions.lenientExpandOpen(), false, false, true, isSystemIndexAccessAllowed());
-//         String resolvedAliasOrIndex = dateMathExpressionResolver.resolveExpression(indexAbstraction, context);
-//         return state.metadata().getIndicesLookup().containsKey(resolvedAliasOrIndex);
-//     }
-
-//     /**
-//      * @return If the specified string is data math expression then this method returns the resolved expression.
-//      */
-//     public String resolveDateMathExpression(String dateExpression) {
-//         // The data math expression resolver doesn't rely on cluster state or indices options, because
-//         // it just resolves the date math to an actual date.
-//         return dateMathExpressionResolver.resolveExpression(dateExpression, new Context(null, null, isSystemIndexAccessAllowed()));
-//     }
-
-//     /**
-//      * Resolve an array of expressions to the set of indices and aliases that these expressions match.
-//      */
-//     public Set<String> resolveExpressions(ProtobufClusterState state, String... expressions) {
-//         Context context = new Context(state, IndicesOptions.lenientExpandOpen(), true, false, true, isSystemIndexAccessAllowed());
-//         List<String> resolvedExpressions = Arrays.asList(expressions);
-//         for (ExpressionResolver expressionResolver : expressionResolvers) {
-//             resolvedExpressions = expressionResolver.resolve(context, resolvedExpressions);
-//         }
-//         return Collections.unmodifiableSet(new HashSet<>(resolvedExpressions));
-//     }
-
-//     /**
-//      * Iterates through the list of indices and selects the effective list of filtering aliases for the
-//      * given index.
-//      * <p>Only aliases with filters are returned. If the indices list contains a non-filtering reference to
-//      * the index itself - null is returned. Returns {@code null} if no filtering is required.
-//      * <b>NOTE</b>: The provided expressions must have been resolved already via {@link #resolveExpressions}.
-//      */
-//     public String[] filteringAliases(ProtobufClusterState state, String index, Set<String> resolvedExpressions) {
-//         return indexAliases(state, index, AliasMetadata::filteringRequired, false, resolvedExpressions);
-//     }
-
-//     /**
-//      * Whether to generate the candidate set from index aliases, or from the set of resolved expressions.
-//      * @param indexAliasesSize        the number of aliases of the index
-//      * @param resolvedExpressionsSize the number of resolved expressions
-//      */
-//     // pkg-private for testing
-//     boolean iterateIndexAliases(int indexAliasesSize, int resolvedExpressionsSize) {
-//         return indexAliasesSize <= resolvedExpressionsSize;
-//     }
-
-//     /**
-//      * Iterates through the list of indices and selects the effective list of required aliases for the given index.
-//      * <p>Only aliases where the given predicate tests successfully are returned. If the indices list contains a non-required reference to
-//      * the index itself - null is returned. Returns {@code null} if no filtering is required.
-//      * <p><b>NOTE</b>: the provided expressions must have been resolved already via {@link #resolveExpressions}.
-//      */
-//     public String[] indexAliases(
-//         ProtobufClusterState state,
-//         String index,
-//         Predicate<AliasMetadata> requiredAlias,
-//         boolean skipIdentity,
-//         Set<String> resolvedExpressions
-//     ) {
-//         if (isAllIndices(resolvedExpressions)) {
-//             return null;
-//         }
-
-//         final IndexMetadata indexMetadata = state.metadata().getIndices().get(index);
-//         if (indexMetadata == null) {
-//             // Shouldn't happen
-//             throw new IndexNotFoundException(index);
-//         }
-
-//         if (skipIdentity == false && resolvedExpressions.contains(index)) {
-//             return null;
-//         }
-
-//         final ImmutableOpenMap<String, AliasMetadata> indexAliases = indexMetadata.getAliases();
-//         final AliasMetadata[] aliasCandidates;
-//         if (iterateIndexAliases(indexAliases.size(), resolvedExpressions.size())) {
-//             // faster to iterate indexAliases
-//             aliasCandidates = StreamSupport.stream(Spliterators.spliteratorUnknownSize(indexAliases.values().iterator(), 0), false)
-//                 .map(cursor -> cursor.value)
-//                 .filter(aliasMetadata -> resolvedExpressions.contains(aliasMetadata.alias()))
-//                 .toArray(AliasMetadata[]::new);
-//         } else {
-//             // faster to iterate resolvedExpressions
-//             aliasCandidates = resolvedExpressions.stream().map(indexAliases::get).filter(Objects::nonNull).toArray(AliasMetadata[]::new);
-//         }
-
-//         List<String> aliases = null;
-//         for (AliasMetadata aliasMetadata : aliasCandidates) {
-//             if (requiredAlias.test(aliasMetadata)) {
-//                 // If required - add it to the list of aliases
-//                 if (aliases == null) {
-//                     aliases = new ArrayList<>();
-//                 }
-//                 aliases.add(aliasMetadata.alias());
-//             } else {
-//                 // If not, we have a non required alias for this index - no further checking needed
-//                 return null;
-//             }
-//         }
-//         if (aliases == null) {
-//             return null;
-//         }
-//         return aliases.toArray(new String[0]);
-//     }
-
-//     /**
-//      * Resolves the search routing if in the expression aliases are used. If expressions point to concrete indices
-//      * or aliases with no routing defined the specified routing is used.
-//      *
-//      * @return routing values grouped by concrete index
-//      */
-//     public Map<String, Set<String>> resolveSearchRouting(ProtobufClusterState state, @Nullable String routing, String... expressions) {
-//         List<String> resolvedExpressions = expressions != null ? Arrays.asList(expressions) : Collections.emptyList();
-//         Context context = new Context(state, IndicesOptions.lenientExpandOpen(), false, false, true, isSystemIndexAccessAllowed());
-//         for (ExpressionResolver expressionResolver : expressionResolvers) {
-//             resolvedExpressions = expressionResolver.resolve(context, resolvedExpressions);
-//         }
-
-//         // TODO: it appears that this can never be true?
-//         if (isAllIndices(resolvedExpressions)) {
-//             return resolveSearchRoutingAllIndices(state.metadata(), routing);
-//         }
-
-//         Map<String, Set<String>> routings = null;
-//         Set<String> paramRouting = null;
-//         // List of indices that don't require any routing
-//         Set<String> norouting = new HashSet<>();
-//         if (routing != null) {
-//             paramRouting = Sets.newHashSet(Strings.splitStringByCommaToArray(routing));
-//         }
-
-//         for (String expression : resolvedExpressions) {
-//             IndexAbstraction indexAbstraction = state.metadata().getIndicesLookup().get(expression);
-//             if (indexAbstraction != null && indexAbstraction.getType() == IndexAbstraction.Type.ALIAS) {
-//                 IndexAbstraction.Alias alias = (IndexAbstraction.Alias) indexAbstraction;
-//                 for (Tuple<String, AliasMetadata> item : alias.getConcreteIndexAndAliasMetadatas()) {
-//                     String concreteIndex = item.v1();
-//                     AliasMetadata aliasMetadata = item.v2();
-//                     if (!norouting.contains(concreteIndex)) {
-//                         if (!aliasMetadata.searchRoutingValues().isEmpty()) {
-//                             // Routing alias
-//                             if (routings == null) {
-//                                 routings = new HashMap<>();
-//                             }
-//                             Set<String> r = routings.get(concreteIndex);
-//                             if (r == null) {
-//                                 r = new HashSet<>();
-//                                 routings.put(concreteIndex, r);
-//                             }
-//                             r.addAll(aliasMetadata.searchRoutingValues());
-//                             if (paramRouting != null) {
-//                                 r.retainAll(paramRouting);
-//                             }
-//                             if (r.isEmpty()) {
-//                                 routings.remove(concreteIndex);
-//                             }
-//                         } else {
-//                             // Non-routing alias
-//                             if (!norouting.contains(concreteIndex)) {
-//                                 norouting.add(concreteIndex);
-//                                 if (paramRouting != null) {
-//                                     Set<String> r = new HashSet<>(paramRouting);
-//                                     if (routings == null) {
-//                                         routings = new HashMap<>();
-//                                     }
-//                                     routings.put(concreteIndex, r);
-//                                 } else {
-//                                     if (routings != null) {
-//                                         routings.remove(concreteIndex);
-//                                     }
-//                                 }
-//                             }
-//                         }
-//                     }
-//                 }
-//             } else {
-//                 // Index
-//                 if (!norouting.contains(expression)) {
-//                     norouting.add(expression);
-//                     if (paramRouting != null) {
-//                         Set<String> r = new HashSet<>(paramRouting);
-//                         if (routings == null) {
-//                             routings = new HashMap<>();
-//                         }
-//                         routings.put(expression, r);
-//                     } else {
-//                         if (routings != null) {
-//                             routings.remove(expression);
-//                         }
-//                     }
-//                 }
-//             }
-
-//         }
-//         if (routings == null || routings.isEmpty()) {
-//             return null;
-//         }
-//         return routings;
-//     }
-
-//     /**
-//      * Sets the same routing for all indices
-//      */
-//     public Map<String, Set<String>> resolveSearchRoutingAllIndices(Metadata metadata, String routing) {
-//         if (routing != null) {
-//             Set<String> r = Sets.newHashSet(Strings.splitStringByCommaToArray(routing));
-//             Map<String, Set<String>> routings = new HashMap<>();
-//             String[] concreteIndices = metadata.getConcreteAllIndices();
-//             for (String index : concreteIndices) {
-//                 routings.put(index, r);
-//             }
-//             return routings;
-//         }
-//         return null;
-//     }
-
-//     /**
-//      * Identifies whether the array containing index names given as argument refers to all indices
-//      * The empty or null array identifies all indices
-//      *
-//      * @param aliasesOrIndices the array containing index names
-//      * @return true if the provided array maps to all indices, false otherwise
-//      */
-//     public static boolean isAllIndices(Collection<String> aliasesOrIndices) {
-//         return aliasesOrIndices == null || aliasesOrIndices.isEmpty() || isExplicitAllPattern(aliasesOrIndices);
-//     }
-
-//     /**
-//      * Identifies whether the array containing index names given as argument explicitly refers to all indices
-//      * The empty or null array doesn't explicitly map to all indices
-//      *
-//      * @param aliasesOrIndices the array containing index names
-//      * @return true if the provided array explicitly maps to all indices, false otherwise
-//      */
-//     static boolean isExplicitAllPattern(Collection<String> aliasesOrIndices) {
-//         return aliasesOrIndices != null && aliasesOrIndices.size() == 1 && Metadata.ALL.equals(aliasesOrIndices.iterator().next());
-//     }
-
-//     /**
-//      * Identifies whether the first argument (an array containing index names) is a pattern that matches all indices
-//      *
-//      * @param indicesOrAliases the array containing index names
-//      * @param concreteIndices  array containing the concrete indices that the first argument refers to
-//      * @return true if the first argument is a pattern that maps to all available indices, false otherwise
-//      */
-//     boolean isPatternMatchingAllIndices(Metadata metadata, String[] indicesOrAliases, String[] concreteIndices) {
-//         // if we end up matching on all indices, check, if its a wildcard parameter, or a "-something" structure
-//         if (concreteIndices.length == metadata.getConcreteAllIndices().length && indicesOrAliases.length > 0) {
-
-//             // we might have something like /-test1,+test1 that would identify all indices
-//             // or something like /-test1 with test1 index missing and IndicesOptions.lenient()
-//             if (indicesOrAliases[0].charAt(0) == '-') {
-//                 return true;
-//             }
-
-//             // otherwise we check if there's any simple regex
-//             for (String indexOrAlias : indicesOrAliases) {
-//                 if (Regex.isSimpleMatchPattern(indexOrAlias)) {
-//                     return true;
-//                 }
-//             }
-//         }
-//         return false;
-//     }
-
-//     /**
-//      * Determines whether or not system index access should be allowed in the current context.
-//      *
-//      * @return True if system index access should be allowed, false otherwise.
-//      */
-//     public boolean isSystemIndexAccessAllowed() {
-//         return Booleans.parseBoolean(threadContext.getHeader(SYSTEM_INDEX_ACCESS_CONTROL_HEADER_KEY), true);
-//     }
-
-//     /**
-//      * Context for the resolver.
-//      *
-//      * @opensearch.internal
-//      */
-//     public static class Context {
-
-//         private final ProtobufClusterState state;
-//         private final IndicesOptions options;
-//         private final long startTime;
-//         private final boolean preserveAliases;
-//         private final boolean resolveToWriteIndex;
-//         private final boolean includeDataStreams;
-//         private final boolean preserveDataStreams;
-//         private final boolean isSystemIndexAccessAllowed;
-
-//         Context(ProtobufClusterState state, IndicesOptions options, boolean isSystemIndexAccessAllowed) {
-//             this(state, options, System.currentTimeMillis(), isSystemIndexAccessAllowed);
-//         }
-
-//         Context(
-//             ProtobufClusterState state,
-//             IndicesOptions options,
-//             boolean preserveAliases,
-//             boolean resolveToWriteIndex,
-//             boolean includeDataStreams,
-//             boolean isSystemIndexAccessAllowed
-//         ) {
-//             this(
-//                 state,
-//                 options,
-//                 System.currentTimeMillis(),
-//                 preserveAliases,
-//                 resolveToWriteIndex,
-//                 includeDataStreams,
-//                 false,
-//                 isSystemIndexAccessAllowed
-//             );
-//         }
-
-//         Context(
-//             ProtobufClusterState state,
-//             IndicesOptions options,
-//             boolean preserveAliases,
-//             boolean resolveToWriteIndex,
-//             boolean includeDataStreams,
-//             boolean preserveDataStreams,
-//             boolean isSystemIndexAccessAllowed
-//         ) {
-//             this(
-//                 state,
-//                 options,
-//                 System.currentTimeMillis(),
-//                 preserveAliases,
-//                 resolveToWriteIndex,
-//                 includeDataStreams,
-//                 preserveDataStreams,
-//                 isSystemIndexAccessAllowed
-//             );
-//         }
-
-//         Context(ProtobufClusterState state, IndicesOptions options, long startTime, boolean isSystemIndexAccessAllowed) {
-//             this(state, options, startTime, false, false, false, false, isSystemIndexAccessAllowed);
-//         }
-
-//         protected Context(
-//             ProtobufClusterState state,
-//             IndicesOptions options,
-//             long startTime,
-//             boolean preserveAliases,
-//             boolean resolveToWriteIndex,
-//             boolean includeDataStreams,
-//             boolean preserveDataStreams,
-//             boolean isSystemIndexAccessAllowed
-//         ) {
-//             this.state = state;
-//             this.options = options;
-//             this.startTime = startTime;
-//             this.preserveAliases = preserveAliases;
-//             this.resolveToWriteIndex = resolveToWriteIndex;
-//             this.includeDataStreams = includeDataStreams;
-//             this.preserveDataStreams = preserveDataStreams;
-//             this.isSystemIndexAccessAllowed = isSystemIndexAccessAllowed;
-//         }
-
-//         public ProtobufClusterState getState() {
-//             return state;
-//         }
-
-//         public IndicesOptions getOptions() {
-//             return options;
-//         }
-
-//         public long getStartTime() {
-//             return startTime;
-//         }
-
-//         /**
-//          * This is used to prevent resolving aliases to concrete indices but this also means
-//          * that we might return aliases that point to a closed index. This is currently only used
-//          * by {@link #filteringAliases(ProtobufClusterState, String, Set)} since it's the only one that needs aliases
-//          */
-//         boolean isPreserveAliases() {
-//             return preserveAliases;
-//         }
-
-//         /**
-//          * This is used to require that aliases resolve to their write-index. It is currently not used in conjunction
-//          * with <code>preserveAliases</code>.
-//          */
-//         boolean isResolveToWriteIndex() {
-//             return resolveToWriteIndex;
-//         }
-
-//         public boolean includeDataStreams() {
-//             return includeDataStreams;
-//         }
-
-//         public boolean isPreserveDataStreams() {
-//             return preserveDataStreams;
-//         }
-
-//         /**
-//          * Used to determine if it is allowed to access system indices in this context (e.g. for this request).
-//          */
-//         public boolean isSystemIndexAccessAllowed() {
-//             return isSystemIndexAccessAllowed;
-//         }
-//     }
-
-//     private interface ExpressionResolver {
-
-//         /**
-//          * Resolves the list of expressions into other expressions if possible (possible concrete indices and aliases, but
-//          * that isn't required). The provided implementations can also be left untouched.
-//          *
-//          * @return a new list with expressions based on the provided expressions
-//          */
-//         List<String> resolve(Context context, List<String> expressions);
-
-//     }
-
-//     /**
-//      * Resolves alias/index name expressions with wildcards into the corresponding concrete indices/aliases
-//      *
-//      * @opensearch.internal
-//      */
-//     static final class WildcardExpressionResolver implements ExpressionResolver {
-
-//         @Override
-//         public List<String> resolve(Context context, List<String> expressions) {
-//             IndicesOptions options = context.getOptions();
-//             Metadata metadata = context.getState().metadata();
-//             // only check open/closed since if we do not expand to open or closed it doesn't make sense to
-//             // expand to hidden
-//             if (options.expandWildcardsClosed() == false && options.expandWildcardsOpen() == false) {
-//                 return expressions;
-//             }
-
-//             if (isEmptyOrTrivialWildcard(expressions)) {
-//                 List<String> resolvedExpressions = resolveEmptyOrTrivialWildcard(options, metadata);
-//                 if (context.includeDataStreams()) {
-//                     final IndexMetadata.State excludeState = excludeState(options);
-//                     final Map<String, IndexAbstraction> dataStreamsAbstractions = metadata.getIndicesLookup()
-//                         .entrySet()
-//                         .stream()
-//                         .filter(entry -> entry.getValue().getType() == IndexAbstraction.Type.DATA_STREAM)
-//                         .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
-//                     // dedup backing indices if expand hidden indices option is true
-//                     Set<String> resolvedIncludingDataStreams = new HashSet<>(resolvedExpressions);
-//                     resolvedIncludingDataStreams.addAll(
-//                         expand(
-//                             context,
-//                             excludeState,
-//                             dataStreamsAbstractions,
-//                             expressions.isEmpty() ? "_all" : expressions.get(0),
-//                             options.expandWildcardsHidden()
-//                         )
-//                     );
-//                     return new ArrayList<>(resolvedIncludingDataStreams);
-//                 }
-//                 return resolvedExpressions;
-//             }
-
-//             Set<String> result = innerResolve(context, expressions, options, metadata);
-
-//             if (result == null) {
-//                 return expressions;
-//             }
-//             if (result.isEmpty() && !options.allowNoIndices()) {
-//                 IndexNotFoundException infe = new IndexNotFoundException((String) null);
-//                 infe.setResources("index_or_alias", expressions.toArray(new String[0]));
-//                 throw infe;
-//             }
-//             return new ArrayList<>(result);
-//         }
-
-//         private Set<String> innerResolve(Context context, List<String> expressions, IndicesOptions options, Metadata metadata) {
-//             Set<String> result = null;
-//             boolean wildcardSeen = false;
-//             for (int i = 0; i < expressions.size(); i++) {
-//                 String expression = expressions.get(i);
-//                 if (Strings.isEmpty(expression)) {
-//                     throw indexNotFoundException(expression);
-//                 }
-//                 validateAliasOrIndex(expression);
-//                 if (aliasOrIndexExists(context, options, metadata, expression)) {
-//                     if (result != null) {
-//                         result.add(expression);
-//                     }
-//                     continue;
-//                 }
-//                 final boolean add;
-//                 if (expression.charAt(0) == '-' && wildcardSeen) {
-//                     add = false;
-//                     expression = expression.substring(1);
-//                 } else {
-//                     add = true;
-//                 }
-//                 if (result == null) {
-//                     // add all the previous ones...
-//                     result = new HashSet<>(expressions.subList(0, i));
-//                 }
-//                 if (Regex.isSimpleMatchPattern(expression) == false) {
-//                     // TODO why does wildcard resolver throw exceptions regarding non wildcarded expressions? This should not be done here.
-//                     if (options.ignoreUnavailable() == false) {
-//                         IndexAbstraction indexAbstraction = metadata.getIndicesLookup().get(expression);
-//                         if (indexAbstraction == null) {
-//                             throw indexNotFoundException(expression);
-//                         } else if (indexAbstraction.getType() == IndexAbstraction.Type.ALIAS && options.ignoreAliases()) {
-//                             throw aliasesNotSupportedException(expression);
-//                         } else if (indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM
-//                             && context.includeDataStreams() == false) {
-//                                 throw indexNotFoundException(expression);
-//                             }
-//                     }
-//                     if (add) {
-//                         result.add(expression);
-//                     } else {
-//                         result.remove(expression);
-//                     }
-//                     continue;
-//                 }
-
-//                 final IndexMetadata.State excludeState = excludeState(options);
-//                 final Map<String, IndexAbstraction> matches = matches(context, metadata, expression);
-//                 Set<String> expand = expand(context, excludeState, matches, expression, options.expandWildcardsHidden());
-//                 if (add) {
-//                     result.addAll(expand);
-//                 } else {
-//                     result.removeAll(expand);
-//                 }
-//                 if (options.allowNoIndices() == false && matches.isEmpty()) {
-//                     throw indexNotFoundException(expression);
-//                 }
-//                 if (Regex.isSimpleMatchPattern(expression)) {
-//                     wildcardSeen = true;
-//                 }
-//             }
-//             return result;
-//         }
-
-//         private static void validateAliasOrIndex(String expression) {
-//             // Expressions can not start with an underscore. This is reserved for APIs. If the check gets here, the API
-//             // does not exist and the path is interpreted as an expression. If the expression begins with an underscore,
-//             // throw a specific error that is different from the [[IndexNotFoundException]], which is typically thrown
-//             // if the expression can't be found.
-//             if (expression.charAt(0) == '_') {
-//                 throw new InvalidIndexNameException(expression, "must not start with '_'.");
-//             }
-//         }
-
-//         private static boolean aliasOrIndexExists(Context context, IndicesOptions options, Metadata metadata, String expression) {
-//             IndexAbstraction indexAbstraction = metadata.getIndicesLookup().get(expression);
-//             if (indexAbstraction == null) {
-//                 return false;
-//             }
-
-//             // treat aliases as unavailable indices when ignoreAliases is set to true (e.g. delete index and update aliases api)
-//             if (indexAbstraction.getType() == IndexAbstraction.Type.ALIAS && options.ignoreAliases()) {
-//                 return false;
-//             }
-
-//             if (indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM && context.includeDataStreams() == false) {
-//                 return false;
-//             }
-
-//             return true;
-//         }
-
-//         private static IndexNotFoundException indexNotFoundException(String expression) {
-//             IndexNotFoundException infe = new IndexNotFoundException(expression);
-//             infe.setResources("index_or_alias", expression);
-//             return infe;
-//         }
-
-//         private static IndexMetadata.State excludeState(IndicesOptions options) {
-//             final IndexMetadata.State excludeState;
-//             if (options.expandWildcardsOpen() && options.expandWildcardsClosed()) {
-//                 excludeState = null;
-//             } else if (options.expandWildcardsOpen() && options.expandWildcardsClosed() == false) {
-//                 excludeState = IndexMetadata.State.CLOSE;
-//             } else if (options.expandWildcardsClosed() && options.expandWildcardsOpen() == false) {
-//                 excludeState = IndexMetadata.State.OPEN;
-//             } else {
-//                 assert false : "this shouldn't get called if wildcards expand to none";
-//                 excludeState = null;
-//             }
-//             return excludeState;
-//         }
-
-//         public static Map<String, IndexAbstraction> matches(Context context, Metadata metadata, String expression) {
-//             if (Regex.isMatchAllPattern(expression)) {
-//                 return filterIndicesLookup(context, metadata.getIndicesLookup(), null, context.getOptions());
-//             } else if (expression.indexOf("*") == expression.length() - 1) {
-//                 return suffixWildcard(context, metadata, expression);
-//             } else {
-//                 return otherWildcard(context, metadata, expression);
-//             }
-//         }
-
-//         private static Map<String, IndexAbstraction> suffixWildcard(Context context, Metadata metadata, String expression) {
-//             assert expression.length() >= 2 : "expression [" + expression + "] should have at least a length of 2";
-//             String fromPrefix = expression.substring(0, expression.length() - 1);
-//             char[] toPrefixCharArr = fromPrefix.toCharArray();
-//             toPrefixCharArr[toPrefixCharArr.length - 1]++;
-//             String toPrefix = new String(toPrefixCharArr);
-//             SortedMap<String, IndexAbstraction> subMap = metadata.getIndicesLookup().subMap(fromPrefix, toPrefix);
-//             return filterIndicesLookup(context, subMap, null, context.getOptions());
-//         }
-
-//         private static Map<String, IndexAbstraction> otherWildcard(Context context, Metadata metadata, String expression) {
-//             final String pattern = expression;
-//             return filterIndicesLookup(
-//                 context,
-//                 metadata.getIndicesLookup(),
-//                 e -> Regex.simpleMatch(pattern, e.getKey()),
-//                 context.getOptions()
-//             );
-//         }
-
-//         private static Map<String, IndexAbstraction> filterIndicesLookup(
-//             Context context,
-//             SortedMap<String, IndexAbstraction> indicesLookup,
-//             Predicate<? super Map.Entry<String, IndexAbstraction>> filter,
-//             IndicesOptions options
-//         ) {
-//             boolean shouldConsumeStream = false;
-//             Stream<Map.Entry<String, IndexAbstraction>> stream = indicesLookup.entrySet().stream();
-//             if (options.ignoreAliases()) {
-//                 shouldConsumeStream = true;
-//                 stream = stream.filter(e -> e.getValue().getType() != IndexAbstraction.Type.ALIAS);
-//             }
-//             if (filter != null) {
-//                 shouldConsumeStream = true;
-//                 stream = stream.filter(filter);
-//             }
-//             if (context.includeDataStreams() == false) {
-//                 shouldConsumeStream = true;
-//                 stream = stream.filter(e -> e.getValue().getType() != IndexAbstraction.Type.DATA_STREAM);
-//             }
-//             if (shouldConsumeStream) {
-//                 return stream.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
-//             } else {
-//                 return indicesLookup;
-//             }
-//         }
-
-//         private static Set<String> expand(
-//             Context context,
-//             IndexMetadata.State excludeState,
-//             Map<String, IndexAbstraction> matches,
-//             String expression,
-//             boolean includeHidden
-//         ) {
-//             Set<String> expand = new HashSet<>();
-//             for (Map.Entry<String, IndexAbstraction> entry : matches.entrySet()) {
-//                 String aliasOrIndexName = entry.getKey();
-//                 IndexAbstraction indexAbstraction = entry.getValue();
-
-//                 if (indexAbstraction.isHidden() == false || includeHidden || implicitHiddenMatch(aliasOrIndexName, expression)) {
-//                     if (context.isPreserveAliases() && indexAbstraction.getType() == IndexAbstraction.Type.ALIAS) {
-//                         expand.add(aliasOrIndexName);
-//                     } else {
-//                         for (IndexMetadata meta : indexAbstraction.getIndices()) {
-//                             if (excludeState == null || meta.getState() != excludeState) {
-//                                 expand.add(meta.getIndex().getName());
-//                             }
-//                         }
-//                         if (context.isPreserveDataStreams() && indexAbstraction.getType() == IndexAbstraction.Type.DATA_STREAM) {
-//                             expand.add(indexAbstraction.getName());
-//                         }
-//                     }
-//                 }
-//             }
-//             return expand;
-//         }
-
-//         private static boolean implicitHiddenMatch(String itemName, String expression) {
-//             return itemName.startsWith(".") && expression.startsWith(".") && Regex.isSimpleMatchPattern(expression);
-//         }
-
-//         private boolean isEmptyOrTrivialWildcard(List<String> expressions) {
-//             return expressions.isEmpty()
-//                 || (expressions.size() == 1 && (Metadata.ALL.equals(expressions.get(0)) || Regex.isMatchAllPattern(expressions.get(0))));
-//         }
-
-//         private static List<String> resolveEmptyOrTrivialWildcard(IndicesOptions options, Metadata metadata) {
-//             if (options.expandWildcardsOpen() && options.expandWildcardsClosed() && options.expandWildcardsHidden()) {
-//                 return Arrays.asList(metadata.getConcreteAllIndices());
-//             } else if (options.expandWildcardsOpen() && options.expandWildcardsClosed()) {
-//                 return Arrays.asList(metadata.getConcreteVisibleIndices());
-//             } else if (options.expandWildcardsOpen() && options.expandWildcardsHidden()) {
-//                 return Arrays.asList(metadata.getConcreteAllOpenIndices());
-//             } else if (options.expandWildcardsOpen()) {
-//                 return Arrays.asList(metadata.getConcreteVisibleOpenIndices());
-//             } else if (options.expandWildcardsClosed() && options.expandWildcardsHidden()) {
-//                 return Arrays.asList(metadata.getConcreteAllClosedIndices());
-//             } else if (options.expandWildcardsClosed()) {
-//                 return Arrays.asList(metadata.getConcreteVisibleClosedIndices());
-//             } else {
-//                 return Collections.emptyList();
-//             }
-//         }
-//     }
-
-//     /**
-//      * A date math expression resolver.
-//      *
-//      * @opensearch.internal
-//      */
-//     public static final class DateMathExpressionResolver implements ExpressionResolver {
-
-//         private static final DateFormatter DEFAULT_DATE_FORMATTER = DateFormatter.forPattern("uuuu.MM.dd");
-//         private static final String EXPRESSION_LEFT_BOUND = "<";
-//         private static final String EXPRESSION_RIGHT_BOUND = ">";
-//         private static final char LEFT_BOUND = '{';
-//         private static final char RIGHT_BOUND = '}';
-//         private static final char ESCAPE_CHAR = '\\';
-//         private static final char TIME_ZONE_BOUND = '|';
-
-//         @Override
-//         public List<String> resolve(final Context context, List<String> expressions) {
-//             List<String> result = new ArrayList<>(expressions.size());
-//             for (String expression : expressions) {
-//                 result.add(resolveExpression(expression, context));
-//             }
-//             return result;
-//         }
-
-//         @SuppressWarnings("fallthrough")
-//         String resolveExpression(String expression, final Context context) {
-//             if (expression.startsWith(EXPRESSION_LEFT_BOUND) == false || expression.endsWith(EXPRESSION_RIGHT_BOUND) == false) {
-//                 return expression;
-//             }
-
-//             boolean escape = false;
-//             boolean inDateFormat = false;
-//             boolean inPlaceHolder = false;
-//             final StringBuilder beforePlaceHolderSb = new StringBuilder();
-//             StringBuilder inPlaceHolderSb = new StringBuilder();
-//             final char[] text = expression.toCharArray();
-//             final int from = 1;
-//             final int length = text.length - 1;
-//             for (int i = from; i < length; i++) {
-//                 boolean escapedChar = escape;
-//                 if (escape) {
-//                     escape = false;
-//                 }
-
-//                 char c = text[i];
-//                 if (c == ESCAPE_CHAR) {
-//                     if (escapedChar) {
-//                         beforePlaceHolderSb.append(c);
-//                         escape = false;
-//                     } else {
-//                         escape = true;
-//                     }
-//                     continue;
-//                 }
-//                 if (inPlaceHolder) {
-//                     switch (c) {
-//                         case LEFT_BOUND:
-//                             if (inDateFormat && escapedChar) {
-//                                 inPlaceHolderSb.append(c);
-//                             } else if (!inDateFormat) {
-//                                 inDateFormat = true;
-//                                 inPlaceHolderSb.append(c);
-//                             } else {
-//                                 throw new OpenSearchParseException(
-//                                     "invalid dynamic name expression [{}]." + " invalid character in placeholder at position [{}]",
-//                                     new String(text, from, length),
-//                                     i
-//                                 );
-//                             }
-//                             break;
-
-//                         case RIGHT_BOUND:
-//                             if (inDateFormat && escapedChar) {
-//                                 inPlaceHolderSb.append(c);
-//                             } else if (inDateFormat) {
-//                                 inDateFormat = false;
-//                                 inPlaceHolderSb.append(c);
-//                             } else {
-//                                 String inPlaceHolderString = inPlaceHolderSb.toString();
-//                                 int dateTimeFormatLeftBoundIndex = inPlaceHolderString.indexOf(LEFT_BOUND);
-//                                 String mathExpression;
-//                                 String dateFormatterPattern;
-//                                 DateFormatter dateFormatter;
-//                                 final ZoneId timeZone;
-//                                 if (dateTimeFormatLeftBoundIndex < 0) {
-//                                     mathExpression = inPlaceHolderString;
-//                                     dateFormatter = DEFAULT_DATE_FORMATTER;
-//                                     timeZone = ZoneOffset.UTC;
-//                                 } else {
-//                                     if (inPlaceHolderString.lastIndexOf(RIGHT_BOUND) != inPlaceHolderString.length() - 1) {
-//                                         throw new OpenSearchParseException(
-//                                             "invalid dynamic name expression [{}]. missing closing `}`" + " for date math format",
-//                                             inPlaceHolderString
-//                                         );
-//                                     }
-//                                     if (dateTimeFormatLeftBoundIndex == inPlaceHolderString.length() - 2) {
-//                                         throw new OpenSearchParseException(
-//                                             "invalid dynamic name expression [{}]. missing date format",
-//                                             inPlaceHolderString
-//                                         );
-//                                     }
-//                                     mathExpression = inPlaceHolderString.substring(0, dateTimeFormatLeftBoundIndex);
-//                                     String patternAndTZid = inPlaceHolderString.substring(
-//                                         dateTimeFormatLeftBoundIndex + 1,
-//                                         inPlaceHolderString.length() - 1
-//                                     );
-//                                     int formatPatternTimeZoneSeparatorIndex = patternAndTZid.indexOf(TIME_ZONE_BOUND);
-//                                     if (formatPatternTimeZoneSeparatorIndex != -1) {
-//                                         dateFormatterPattern = patternAndTZid.substring(0, formatPatternTimeZoneSeparatorIndex);
-//                                         timeZone = DateUtils.of(patternAndTZid.substring(formatPatternTimeZoneSeparatorIndex + 1));
-//                                     } else {
-//                                         dateFormatterPattern = patternAndTZid;
-//                                         timeZone = ZoneOffset.UTC;
-//                                     }
-//                                     dateFormatter = DateFormatter.forPattern(dateFormatterPattern);
-//                                 }
-
-//                                 DateFormatter formatter = dateFormatter.withZone(timeZone);
-//                                 DateMathParser dateMathParser = formatter.toDateMathParser();
-//                                 Instant instant = dateMathParser.parse(mathExpression, context::getStartTime, false, timeZone);
-
-//                                 String time = formatter.format(instant);
-//                                 beforePlaceHolderSb.append(time);
-//                                 inPlaceHolderSb = new StringBuilder();
-//                                 inPlaceHolder = false;
-//                             }
-//                             break;
-
-//                         default:
-//                             inPlaceHolderSb.append(c);
-//                     }
-//                 } else {
-//                     switch (c) {
-//                         case LEFT_BOUND:
-//                             if (escapedChar) {
-//                                 beforePlaceHolderSb.append(c);
-//                             } else {
-//                                 inPlaceHolder = true;
-//                             }
-//                             break;
-
-//                         case RIGHT_BOUND:
-//                             if (!escapedChar) {
-//                                 throw new OpenSearchParseException(
-//                                     "invalid dynamic name expression [{}]."
-//                                         + " invalid character at position [{}]. `{` and `}` are reserved characters and"
-//                                         + " should be escaped when used as part of the index name using `\\` (e.g. `\\{text\\}`)",
-//                                     new String(text, from, length),
-//                                     i
-//                                 );
-//                             }
-//                         default:
-//                             beforePlaceHolderSb.append(c);
-//                     }
-//                 }
-//             }
-
-//             if (inPlaceHolder) {
-//                 throw new OpenSearchParseException(
-//                     "invalid dynamic name expression [{}]. date math placeholder is open ended",
-//                     new String(text, from, length)
-//                 );
-//             }
-//             if (beforePlaceHolderSb.length() == 0) {
-//                 throw new OpenSearchParseException("nothing captured");
-//             }
-//             return beforePlaceHolderSb.toString();
-//         }
-//     }
-// }
diff --git a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
index 471779a65587d..3b46495e443fc 100644
--- a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
+++ b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
@@ -42,7 +42,6 @@
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
@@ -366,8 +365,6 @@ public DiscoveryNode(CodedInputStream in) throws IOException {
         this.ephemeralId = in.readString();
         this.hostName = in.readString();
         this.hostAddress = in.readString();
-        // ProtobufTransportAddress protobufTransportAddress = new ProtobufTransportAddress(in);
-        // this.address = new TransportAddress(protobufTransportAddress.address());
         this.address = new TransportAddress(in);
         int size = in.readInt32();
         this.attributes = new HashMap<>(size);
@@ -432,8 +429,6 @@ public void writeTo(CodedOutputStream out) throws IOException {
         out.writeStringNoTag(ephemeralId);
         out.writeStringNoTag(hostName);
         out.writeStringNoTag(hostAddress);
-        // ProtobufTransportAddress protobufTransportAddress = new ProtobufTransportAddress(address.address());
-        // protobufTransportAddress.writeTo(out);
         address.writeTo(out);
         out.writeInt32NoTag(attributes.size());
         for (Map.Entry<String, String> entry : attributes.entrySet()) {
@@ -457,13 +452,6 @@ public TransportAddress getAddress() {
         return address;
     }
 
-    // /**
-    //  * The address that the node can be communicated with.
-    //  */
-    // public ProtobufTransportAddress getProtobufAddress() {
-    //     return new ProtobufTransportAddress(address.address());
-    // }
-
     /**
      * The unique id of the node.
      */
@@ -632,7 +620,7 @@ private static Map<String, DiscoveryNodeRole> rolesToMap(final Stream<DiscoveryN
         return Collections.unmodifiableMap(roles.collect(Collectors.toMap(DiscoveryNodeRole::roleName, Function.identity())));
     }
 
-    private static Map<String, DiscoveryNodeRole> roleMap = rolesToMap(DiscoveryNodeRole.BUILT_IN_ROLES.stream());
+    public static Map<String, DiscoveryNodeRole> roleMap = rolesToMap(DiscoveryNodeRole.BUILT_IN_ROLES.stream());
 
     public static DiscoveryNodeRole getRoleFromRoleName(final String roleName) {
         // As we are supporting dynamic role, should make role name case-insensitive to avoid confusion of role name like "Data"/"DATA"
diff --git a/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java b/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java
deleted file mode 100644
index b4fe824b933e2..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/node/ProtobufDiscoveryNodes.java
+++ /dev/null
@@ -1,885 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.cluster.node;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import com.carrotsearch.hppc.ObjectHashSet;
-import com.carrotsearch.hppc.cursors.ObjectCursor;
-import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
-import org.opensearch.Version;
-import org.opensearch.cluster.ProtobufAbstractDiffable;
-import org.opensearch.cluster.ProtobufDiff;
-import org.opensearch.cluster.ProtobufAbstractDiffable;
-import org.opensearch.common.Booleans;
-import org.opensearch.common.Nullable;
-import org.opensearch.common.Strings;
-import org.opensearch.common.collect.ImmutableOpenMap;
-import org.opensearch.common.regex.Regex;
-import org.opensearch.common.transport.TransportAddress;
-import org.opensearch.common.util.set.Sets;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-import java.util.stream.StreamSupport;
-
-/** not used
- * This class holds all {@link DiscoveryNode} in the cluster and provides convenience methods to
-* access, modify merge / diff discovery nodes.
-*
-* @opensearch.internal
-*/
-public class ProtobufDiscoveryNodes extends ProtobufAbstractDiffable<ProtobufDiscoveryNodes> implements Iterable<DiscoveryNode> {
-
-    public static final ProtobufDiscoveryNodes EMPTY_NODES = builder().build();
-
-    private final ImmutableOpenMap<String, DiscoveryNode> nodes;
-    private final ImmutableOpenMap<String, DiscoveryNode> dataNodes;
-    private final ImmutableOpenMap<String, DiscoveryNode> clusterManagerNodes;
-    private final ImmutableOpenMap<String, DiscoveryNode> ingestNodes;
-
-    private final String clusterManagerNodeId;
-    private final String localNodeId;
-    private final Version minNonClientNodeVersion;
-    private final Version maxNonClientNodeVersion;
-    private final Version maxNodeVersion;
-    private final Version minNodeVersion;
-
-    private ProtobufDiscoveryNodes(
-        ImmutableOpenMap<String, DiscoveryNode> nodes,
-        ImmutableOpenMap<String, DiscoveryNode> dataNodes,
-        ImmutableOpenMap<String, DiscoveryNode> clusterManagerNodes,
-        ImmutableOpenMap<String, DiscoveryNode> ingestNodes,
-        String clusterManagerNodeId,
-        String localNodeId,
-        Version minNonClientNodeVersion,
-        Version maxNonClientNodeVersion,
-        Version maxNodeVersion,
-        Version minNodeVersion
-    ) {
-        this.nodes = nodes;
-        this.dataNodes = dataNodes;
-        this.clusterManagerNodes = clusterManagerNodes;
-        this.ingestNodes = ingestNodes;
-        this.clusterManagerNodeId = clusterManagerNodeId;
-        this.localNodeId = localNodeId;
-        this.minNonClientNodeVersion = minNonClientNodeVersion;
-        this.maxNonClientNodeVersion = maxNonClientNodeVersion;
-        this.minNodeVersion = minNodeVersion;
-        this.maxNodeVersion = maxNodeVersion;
-    }
-
-    @Override
-    public Iterator<DiscoveryNode> iterator() {
-        return nodes.valuesIt();
-    }
-
-    /**
-     * Returns {@code true} if the local node is the elected cluster-manager node.
-    */
-    public boolean isLocalNodeElectedClusterManager() {
-        if (localNodeId == null) {
-            // we don't know yet the local node id, return false
-            return false;
-        }
-        return localNodeId.equals(clusterManagerNodeId);
-    }
-
-    /**
-     * Returns {@code true} if the local node is the elected cluster-manager node.
-    *
-    * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #isLocalNodeElectedClusterManager()}
-    */
-    @Deprecated
-    public boolean isLocalNodeElectedMaster() {
-        return isLocalNodeElectedClusterManager();
-    }
-
-    /**
-     * Get the number of known nodes
-    *
-    * @return number of nodes
-    */
-    public int getSize() {
-        return nodes.size();
-    }
-
-    /**
-     * Get a {@link Map} of the discovered nodes arranged by their ids
-    *
-    * @return {@link Map} of the discovered nodes arranged by their ids
-    */
-    public ImmutableOpenMap<String, DiscoveryNode> getNodes() {
-        return this.nodes;
-    }
-
-    /**
-     * Get a {@link Map} of the discovered data nodes arranged by their ids
-    *
-    * @return {@link Map} of the discovered data nodes arranged by their ids
-    */
-    public ImmutableOpenMap<String, DiscoveryNode> getDataNodes() {
-        return this.dataNodes;
-    }
-
-    /**
-     * Get a {@link Map} of the discovered cluster-manager nodes arranged by their ids
-    *
-    * @return {@link Map} of the discovered cluster-manager nodes arranged by their ids
-    */
-    public ImmutableOpenMap<String, DiscoveryNode> getClusterManagerNodes() {
-        return this.clusterManagerNodes;
-    }
-
-    /**
-     * Get a {@link Map} of the discovered cluster-manager nodes arranged by their ids
-    *
-    * @return {@link Map} of the discovered cluster-manager nodes arranged by their ids
-    * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #getClusterManagerNodes()}
-    */
-    @Deprecated
-    public ImmutableOpenMap<String, DiscoveryNode> getMasterNodes() {
-        return getClusterManagerNodes();
-    }
-
-    /**
-     * @return All the ingest nodes arranged by their ids
-    */
-    public ImmutableOpenMap<String, DiscoveryNode> getIngestNodes() {
-        return ingestNodes;
-    }
-
-    /**
-     * Get a {@link Map} of the discovered cluster-manager and data nodes arranged by their ids
-    *
-    * @return {@link Map} of the discovered cluster-manager and data nodes arranged by their ids
-    */
-    public ImmutableOpenMap<String, DiscoveryNode> getClusterManagerAndDataNodes() {
-        ImmutableOpenMap.Builder<String, DiscoveryNode> nodes = ImmutableOpenMap.builder(dataNodes);
-        nodes.putAll(clusterManagerNodes);
-        return nodes.build();
-    }
-
-    /**
-     * Get a {@link Map} of the discovered cluster-manager and data nodes arranged by their ids
-    *
-    * @return {@link Map} of the discovered cluster-manager and data nodes arranged by their ids
-    * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #getClusterManagerAndDataNodes()}
-    */
-    @Deprecated
-    public ImmutableOpenMap<String, DiscoveryNode> getMasterAndDataNodes() {
-        return getClusterManagerAndDataNodes();
-    }
-
-    /**
-     * Get a {@link Map} of the coordinating only nodes (nodes which are neither cluster-manager, nor data, nor ingest nodes) arranged by their ids
-    *
-    * @return {@link Map} of the coordinating only nodes arranged by their ids
-    */
-    public ImmutableOpenMap<String, DiscoveryNode> getCoordinatingOnlyNodes() {
-        ImmutableOpenMap.Builder<String, DiscoveryNode> nodes = ImmutableOpenMap.builder(this.nodes);
-        nodes.removeAll(clusterManagerNodes.keys());
-        nodes.removeAll(dataNodes.keys());
-        nodes.removeAll(ingestNodes.keys());
-        return nodes.build();
-    }
-
-    /**
-     * Returns a stream of all nodes, with cluster-manager nodes at the front
-    */
-    public Stream<DiscoveryNode> clusterManagersFirstStream() {
-        return Stream.concat(
-            StreamSupport.stream(clusterManagerNodes.spliterator(), false).map(cur -> cur.value),
-            StreamSupport.stream(this.spliterator(), false).filter(n -> n.isClusterManagerNode() == false)
-        );
-    }
-
-    /**
-     * Returns a stream of all nodes, with cluster-manager nodes at the front
-    *
-    * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #clusterManagersFirstStream()}
-    */
-    @Deprecated
-    public Stream<DiscoveryNode> mastersFirstStream() {
-        return clusterManagersFirstStream();
-    }
-
-    /**
-     * Get a node by its id
-    *
-    * @param nodeId id of the wanted node
-    * @return wanted node if it exists. Otherwise <code>null</code>
-    */
-    public DiscoveryNode get(String nodeId) {
-        return nodes.get(nodeId);
-    }
-
-    /**
-     * Determine if a given node id exists
-    *
-    * @param nodeId id of the node which existence should be verified
-    * @return <code>true</code> if the node exists. Otherwise <code>false</code>
-    */
-    public boolean nodeExists(String nodeId) {
-        return nodes.containsKey(nodeId);
-    }
-
-    /**
-     * Determine if a given node exists
-    *
-    * @param node of the node which existence should be verified
-    * @return <code>true</code> if the node exists. Otherwise <code>false</code>
-    */
-    public boolean nodeExists(DiscoveryNode node) {
-        DiscoveryNode existing = nodes.get(node.getId());
-        return existing != null && existing.equals(node);
-    }
-
-    /**
-     * Determine if the given node exists and has the right roles. Supported roles vary by version, and our local cluster state might
-    * have come via an older cluster-manager, so the roles may differ even if the node is otherwise identical.
-    */
-    public boolean nodeExistsWithSameRoles(DiscoveryNode discoveryNode) {
-        final DiscoveryNode existing = nodes.get(discoveryNode.getId());
-        return existing != null && existing.equals(discoveryNode) && existing.getRoles().equals(discoveryNode.getRoles());
-    }
-
-    /**
-     * Get the id of the cluster-manager node
-    *
-    * @return id of the cluster-manager
-    */
-    public String getClusterManagerNodeId() {
-        return this.clusterManagerNodeId;
-    }
-
-    /**
-     * Get the id of the cluster-manager node
-    *
-    * @return id of the cluster-manager
-    * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #getClusterManagerNodeId()}
-    */
-    @Deprecated
-    public String getMasterNodeId() {
-        return getClusterManagerNodeId();
-    }
-
-    /**
-     * Get the id of the local node
-    *
-    * @return id of the local node
-    */
-    public String getLocalNodeId() {
-        return this.localNodeId;
-    }
-
-    /**
-     * Get the local node
-    *
-    * @return local node
-    */
-    public DiscoveryNode getLocalNode() {
-        return nodes.get(localNodeId);
-    }
-
-    /**
-     * Returns the cluster-manager node, or {@code null} if there is no cluster-manager node
-    */
-    @Nullable
-    public DiscoveryNode getClusterManagerNode() {
-        if (clusterManagerNodeId != null) {
-            return nodes.get(clusterManagerNodeId);
-        }
-        return null;
-    }
-
-    /**
-     * Returns the cluster-manager node, or {@code null} if there is no cluster-manager node
-    *
-    * @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #getClusterManagerNode()}
-    */
-    @Deprecated
-    @Nullable
-    public DiscoveryNode getMasterNode() {
-        return getClusterManagerNode();
-    }
-
-    /**
-     * Get a node by its address
-    *
-    * @param address {@link TransportAddress} of the wanted node
-    * @return node identified by the given address or <code>null</code> if no such node exists
-    */
-    public DiscoveryNode findByAddress(TransportAddress address) {
-        for (ObjectCursor<DiscoveryNode> cursor : nodes.values()) {
-            DiscoveryNode node = cursor.value;
-            if (node.getAddress().equals(address)) {
-                return node;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Returns the version of the node with the oldest version in the cluster that is not a client node
-    *
-    * If there are no non-client nodes, Version.CURRENT will be returned.
-    *
-    * @return the oldest version in the cluster
-    */
-    public Version getSmallestNonClientNodeVersion() {
-        return minNonClientNodeVersion;
-    }
-
-    /**
-     * Returns the version of the node with the youngest version in the cluster that is not a client node.
-    *
-    * If there are no non-client nodes, Version.CURRENT will be returned.
-    *
-    * @return the youngest version in the cluster
-    */
-    public Version getLargestNonClientNodeVersion() {
-        return maxNonClientNodeVersion;
-    }
-
-    /**
-     * Returns the version of the node with the oldest version in the cluster.
-    *
-    * @return the oldest version in the cluster
-    */
-    public Version getMinNodeVersion() {
-        return minNodeVersion;
-    }
-
-    /**
-     * Returns the version of the node with the youngest version in the cluster
-    *
-    * @return the youngest version in the cluster
-    */
-    public Version getMaxNodeVersion() {
-        return maxNodeVersion;
-    }
-
-    /**
-     * Resolve a node with a given id
-    *
-    * @param node id of the node to discover
-    * @return discovered node matching the given id
-    * @throws IllegalArgumentException if more than one node matches the request or no nodes have been resolved
-    */
-    public DiscoveryNode resolveNode(String node) {
-        String[] resolvedNodeIds = resolveNodes(node);
-        if (resolvedNodeIds.length > 1) {
-            throw new IllegalArgumentException(
-                "resolved [" + node + "] into [" + resolvedNodeIds.length + "] nodes, where expected to be resolved to a single node"
-            );
-        }
-        if (resolvedNodeIds.length == 0) {
-            throw new IllegalArgumentException("failed to resolve [" + node + "], no matching nodes");
-        }
-        return nodes.get(resolvedNodeIds[0]);
-    }
-
-    /**
-     * Resolves a set of nodes according to the given sequence of node specifications. Implements the logic in various APIs that allow the
-    * user to run the action on a subset of the nodes in the cluster. See [Node specification] in the reference manual for full details.
-    *
-    * Works by tracking the current set of nodes and applying each node specification in sequence. The set starts out empty and each node
-    * specification may either add or remove nodes. For instance:
-    *
-    * - _local, _cluster_manager (_master) and _all respectively add to the subset the local node, the currently-elected cluster_manager, and all the nodes
-    * - node IDs, names, hostnames and IP addresses all add to the subset any nodes which match
-    * - a wildcard-based pattern of the form "attr*:value*" adds to the subset all nodes with a matching attribute with a matching value
-    * - role:true adds to the subset all nodes with a matching role
-    * - role:false removes from the subset all nodes with a matching role.
-    *
-    * An empty sequence of node specifications returns all nodes, since the corresponding actions run on all nodes by default.
-    */
-    public String[] resolveNodes(String... nodes) {
-        if (nodes == null || nodes.length == 0) {
-            return StreamSupport.stream(this.spliterator(), false).map(DiscoveryNode::getId).toArray(String[]::new);
-        } else {
-            ObjectHashSet<String> resolvedNodesIds = new ObjectHashSet<>(nodes.length);
-            for (String nodeId : nodes) {
-                if (nodeId == null) {
-                    // don't silence the underlying issue, it is a bug, so lets fail if assertions are enabled
-                    assert nodeId != null : "nodeId should not be null";
-                    continue;
-                } else if (nodeId.equals("_local")) {
-                    String localNodeId = getLocalNodeId();
-                    if (localNodeId != null) {
-                        resolvedNodesIds.add(localNodeId);
-                    }
-                } else if (nodeId.equals("_master") || nodeId.equals("_cluster_manager")) {
-                    String clusterManagerNodeId = getClusterManagerNodeId();
-                    if (clusterManagerNodeId != null) {
-                        resolvedNodesIds.add(clusterManagerNodeId);
-                    }
-                } else if (nodeExists(nodeId)) {
-                    resolvedNodesIds.add(nodeId);
-                } else {
-                    for (DiscoveryNode node : this) {
-                        if ("_all".equals(nodeId)
-                            || Regex.simpleMatch(nodeId, node.getName())
-                            || Regex.simpleMatch(nodeId, node.getHostAddress())
-                            || Regex.simpleMatch(nodeId, node.getHostName())) {
-                            resolvedNodesIds.add(node.getId());
-                        }
-                    }
-                    int index = nodeId.indexOf(':');
-                    if (index != -1) {
-                        String matchAttrName = nodeId.substring(0, index);
-                        String matchAttrValue = nodeId.substring(index + 1);
-                        if (DiscoveryNodeRole.DATA_ROLE.roleName().equals(matchAttrName)) {
-                            if (Booleans.parseBoolean(matchAttrValue, true)) {
-                                resolvedNodesIds.addAll(dataNodes.keys());
-                            } else {
-                                resolvedNodesIds.removeAll(dataNodes.keys());
-                            }
-                        } else if (roleNameIsClusterManager(matchAttrName)) {
-                            if (Booleans.parseBoolean(matchAttrValue, true)) {
-                                resolvedNodesIds.addAll(clusterManagerNodes.keys());
-                            } else {
-                                resolvedNodesIds.removeAll(clusterManagerNodes.keys());
-                            }
-                        } else if (DiscoveryNodeRole.INGEST_ROLE.roleName().equals(matchAttrName)) {
-                            if (Booleans.parseBoolean(matchAttrValue, true)) {
-                                resolvedNodesIds.addAll(ingestNodes.keys());
-                            } else {
-                                resolvedNodesIds.removeAll(ingestNodes.keys());
-                            }
-                        } else if (DiscoveryNode.COORDINATING_ONLY.equals(matchAttrName)) {
-                            if (Booleans.parseBoolean(matchAttrValue, true)) {
-                                resolvedNodesIds.addAll(getCoordinatingOnlyNodes().keys());
-                            } else {
-                                resolvedNodesIds.removeAll(getCoordinatingOnlyNodes().keys());
-                            }
-                        } else {
-                            for (DiscoveryNode node : this) {
-                                for (DiscoveryNodeRole role : Sets.difference(node.getRoles(), DiscoveryNodeRole.BUILT_IN_ROLES)) {
-                                    if (role.roleName().equals(matchAttrName)) {
-                                        if (Booleans.parseBoolean(matchAttrValue, true)) {
-                                            resolvedNodesIds.add(node.getId());
-                                        } else {
-                                            resolvedNodesIds.remove(node.getId());
-                                        }
-                                    }
-                                }
-                            }
-                            for (DiscoveryNode node : this) {
-                                for (Map.Entry<String, String> entry : node.getAttributes().entrySet()) {
-                                    String attrName = entry.getKey();
-                                    String attrValue = entry.getValue();
-                                    if (Regex.simpleMatch(matchAttrName, attrName) && Regex.simpleMatch(matchAttrValue, attrValue)) {
-                                        resolvedNodesIds.add(node.getId());
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            return resolvedNodesIds.toArray(String.class);
-        }
-    }
-
-    public ProtobufDiscoveryNodes newNode(DiscoveryNode node) {
-        return new Builder(this).add(node).build();
-    }
-
-    /**
-     * Returns the changes comparing this nodes to the provided nodes.
-    */
-    public Delta delta(ProtobufDiscoveryNodes other) {
-        final List<DiscoveryNode> removed = new ArrayList<>();
-        final List<DiscoveryNode> added = new ArrayList<>();
-        for (DiscoveryNode node : other) {
-            if (this.nodeExists(node) == false) {
-                removed.add(node);
-            }
-        }
-        for (DiscoveryNode node : this) {
-            if (other.nodeExists(node) == false) {
-                added.add(node);
-            }
-        }
-
-        return new Delta(
-            other.getClusterManagerNode(),
-            getClusterManagerNode(),
-            localNodeId,
-            Collections.unmodifiableList(removed),
-            Collections.unmodifiableList(added)
-        );
-    }
-
-    @Override
-    public String toString() {
-        StringBuilder sb = new StringBuilder();
-        sb.append("nodes: \n");
-        for (DiscoveryNode node : this) {
-            sb.append("   ").append(node);
-            if (node == getLocalNode()) {
-                sb.append(", local");
-            }
-            if (node == getClusterManagerNode()) {
-                sb.append(", cluster-manager");
-            }
-            sb.append("\n");
-        }
-        return sb.toString();
-    }
-
-    /**
-     * Delta between nodes.
-    *
-    * @opensearch.internal
-    */
-    public static class Delta {
-
-        private final String localNodeId;
-        @Nullable
-        private final DiscoveryNode previousClusterManagerNode;
-        @Nullable
-        private final DiscoveryNode newClusterManagerNode;
-        private final List<DiscoveryNode> removed;
-        private final List<DiscoveryNode> added;
-
-        private Delta(
-            @Nullable DiscoveryNode previousClusterManagerNode,
-            @Nullable DiscoveryNode newClusterManagerNode,
-            String localNodeId,
-            List<DiscoveryNode> removed,
-            List<DiscoveryNode> added
-        ) {
-            this.previousClusterManagerNode = previousClusterManagerNode;
-            this.newClusterManagerNode = newClusterManagerNode;
-            this.localNodeId = localNodeId;
-            this.removed = removed;
-            this.added = added;
-        }
-
-        public boolean hasChanges() {
-            return clusterManagerNodeChanged() || !removed.isEmpty() || !added.isEmpty();
-        }
-
-        public boolean clusterManagerNodeChanged() {
-            return Objects.equals(newClusterManagerNode, previousClusterManagerNode) == false;
-        }
-
-        /** @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #clusterManagerNodeChanged()} */
-        @Deprecated
-        public boolean masterNodeChanged() {
-            return clusterManagerNodeChanged();
-        }
-
-        @Nullable
-        public DiscoveryNode previousClusterManagerNode() {
-            return previousClusterManagerNode;
-        }
-
-        /** @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #previousClusterManagerNode()} */
-        @Deprecated
-        @Nullable
-        public DiscoveryNode previousMasterNode() {
-            return previousClusterManagerNode();
-        }
-
-        @Nullable
-        public DiscoveryNode newClusterManagerNode() {
-            return newClusterManagerNode;
-        }
-
-        /** @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #newClusterManagerNode()} */
-        @Deprecated
-        @Nullable
-        public DiscoveryNode newMasterNode() {
-            return newClusterManagerNode();
-        }
-
-        public boolean removed() {
-            return !removed.isEmpty();
-        }
-
-        public List<DiscoveryNode> removedNodes() {
-            return removed;
-        }
-
-        public boolean added() {
-            return !added.isEmpty();
-        }
-
-        public List<DiscoveryNode> addedNodes() {
-            return added;
-        }
-
-        public String shortSummary() {
-            final StringBuilder summary = new StringBuilder();
-            if (clusterManagerNodeChanged()) {
-                summary.append("cluster-manager node changed {previous [");
-                if (previousClusterManagerNode() != null) {
-                    summary.append(previousClusterManagerNode());
-                }
-                summary.append("], current [");
-                if (newClusterManagerNode() != null) {
-                    summary.append(newClusterManagerNode());
-                }
-                summary.append("]}");
-            }
-            if (removed()) {
-                if (summary.length() > 0) {
-                    summary.append(", ");
-                }
-                summary.append("removed {").append(Strings.collectionToCommaDelimitedString(removedNodes())).append('}');
-            }
-            if (added()) {
-                final String addedNodesExceptLocalNode = addedNodes().stream()
-                    .filter(node -> node.getId().equals(localNodeId) == false)
-                    .map(DiscoveryNode::toString)
-                    .collect(Collectors.joining(","));
-                if (addedNodesExceptLocalNode.length() > 0) {
-                    // ignore ourselves when reporting on nodes being added
-                    if (summary.length() > 0) {
-                        summary.append(", ");
-                    }
-                    summary.append("added {").append(addedNodesExceptLocalNode).append('}');
-                }
-            }
-            return summary.toString();
-        }
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        if (clusterManagerNodeId == null) {
-            out.writeBoolNoTag(false);
-        } else {
-            out.writeBoolNoTag(true);
-            out.writeStringNoTag(clusterManagerNodeId);
-        }
-        out.writeInt32NoTag(nodes.size());
-        for (DiscoveryNode node : this) {
-            node.writeTo(out);
-        }
-    }
-
-    public static ProtobufDiscoveryNodes readFrom(CodedInputStream in, DiscoveryNode localNode) throws IOException {
-        Builder builder = new Builder();
-        if (in.readBool()) {
-            builder.clusterManagerNodeId(in.readString());
-        }
-        if (localNode != null) {
-            builder.localNodeId(localNode.getId());
-        }
-        int size = in.readInt32();
-        for (int i = 0; i < size; i++) {
-            DiscoveryNode node = new DiscoveryNode(in);
-            if (localNode != null && node.getId().equals(localNode.getId())) {
-                // reuse the same instance of our address and local node id for faster equality
-                node = localNode;
-            }
-            // some one already built this and validated it's OK, skip the n2 scans
-            assert builder.validateAdd(node) == null : "building disco nodes from network doesn't pass preflight: "
-                + builder.validateAdd(node);
-            builder.putUnsafe(node);
-        }
-        return builder.build();
-    }
-
-    public static ProtobufDiff<ProtobufDiscoveryNodes> readDiffFrom(CodedInputStream in, DiscoveryNode localNode) throws IOException {
-        return ProtobufAbstractDiffable.readDiffFrom(in1 -> readFrom(in1, localNode), in);
-    }
-
-    public static Builder builder() {
-        return new Builder();
-    }
-
-    public static Builder builder(ProtobufDiscoveryNodes nodes) {
-        return new Builder(nodes);
-    }
-
-    /**
-     * Builder of a map of discovery nodes.
-    *
-    * @opensearch.internal
-    */
-    public static class Builder {
-
-        private final ImmutableOpenMap.Builder<String, DiscoveryNode> nodes;
-        private String clusterManagerNodeId;
-        private String localNodeId;
-
-        public Builder() {
-            nodes = ImmutableOpenMap.builder();
-        }
-
-        public Builder(ProtobufDiscoveryNodes nodes) {
-            this.clusterManagerNodeId = nodes.getClusterManagerNodeId();
-            this.localNodeId = nodes.getLocalNodeId();
-            this.nodes = ImmutableOpenMap.builder(nodes.getNodes());
-        }
-
-        /**
-         * adds a disco node to the builder. Will throw an {@link IllegalArgumentException} if
-        * the supplied node doesn't pass the pre-flight checks performed by {@link #validateAdd(DiscoveryNode)}
-        */
-        public Builder add(DiscoveryNode node) {
-            final String preflight = validateAdd(node);
-            if (preflight != null) {
-                throw new IllegalArgumentException(preflight);
-            }
-            putUnsafe(node);
-            return this;
-        }
-
-        /**
-         * Get a node by its id
-        *
-        * @param nodeId id of the wanted node
-        * @return wanted node if it exists. Otherwise <code>null</code>
-        */
-        @Nullable
-        public DiscoveryNode get(String nodeId) {
-            return nodes.get(nodeId);
-        }
-
-        private void putUnsafe(DiscoveryNode node) {
-            nodes.put(node.getId(), node);
-        }
-
-        public Builder remove(String nodeId) {
-            nodes.remove(nodeId);
-            return this;
-        }
-
-        public Builder remove(DiscoveryNode node) {
-            if (node.equals(nodes.get(node.getId()))) {
-                nodes.remove(node.getId());
-            }
-            return this;
-        }
-
-        public Builder clusterManagerNodeId(String clusterManagerNodeId) {
-            this.clusterManagerNodeId = clusterManagerNodeId;
-            return this;
-        }
-
-        /** @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #clusterManagerNodeId} */
-        @Deprecated
-        public Builder masterNodeId(String clusterManagerNodeId) {
-            return clusterManagerNodeId(clusterManagerNodeId);
-        }
-
-        public Builder localNodeId(String localNodeId) {
-            this.localNodeId = localNodeId;
-            return this;
-        }
-
-        /**
-         * Checks that a node can be safely added to this node collection.
-        *
-        * @return null if all is OK or an error message explaining why a node can not be added.
-        *
-        * Note: if this method returns a non-null value, calling {@link #add(DiscoveryNode)} will fail with an
-        * exception
-        */
-        private String validateAdd(DiscoveryNode node) {
-            for (ObjectCursor<DiscoveryNode> cursor : nodes.values()) {
-                final DiscoveryNode existingNode = cursor.value;
-                if (node.getAddress().equals(existingNode.getAddress()) && node.getId().equals(existingNode.getId()) == false) {
-                    return "can't add node " + node + ", found existing node " + existingNode + " with same address";
-                }
-                if (node.getId().equals(existingNode.getId()) && node.equals(existingNode) == false) {
-                    return "can't add node "
-                        + node
-                        + ", found existing node "
-                        + existingNode
-                        + " with the same id but is a different node instance";
-                }
-            }
-            return null;
-        }
-
-        public ProtobufDiscoveryNodes build() {
-            ImmutableOpenMap.Builder<String, DiscoveryNode> dataNodesBuilder = ImmutableOpenMap.builder();
-            ImmutableOpenMap.Builder<String, DiscoveryNode> clusterManagerNodesBuilder = ImmutableOpenMap.builder();
-            ImmutableOpenMap.Builder<String, DiscoveryNode> ingestNodesBuilder = ImmutableOpenMap.builder();
-            Version minNodeVersion = null;
-            Version maxNodeVersion = null;
-            Version minNonClientNodeVersion = null;
-            Version maxNonClientNodeVersion = null;
-            for (ObjectObjectCursor<String, DiscoveryNode> nodeEntry : nodes) {
-                if (nodeEntry.value.isDataNode()) {
-                    dataNodesBuilder.put(nodeEntry.key, nodeEntry.value);
-                }
-                if (nodeEntry.value.isClusterManagerNode()) {
-                    clusterManagerNodesBuilder.put(nodeEntry.key, nodeEntry.value);
-                }
-                final Version version = nodeEntry.value.getVersion();
-                if (nodeEntry.value.isDataNode() || nodeEntry.value.isClusterManagerNode()) {
-                    if (minNonClientNodeVersion == null) {
-                        minNonClientNodeVersion = version;
-                        maxNonClientNodeVersion = version;
-                    } else {
-                        minNonClientNodeVersion = Version.min(minNonClientNodeVersion, version);
-                        maxNonClientNodeVersion = Version.max(maxNonClientNodeVersion, version);
-                    }
-                }
-                if (nodeEntry.value.isIngestNode()) {
-                    ingestNodesBuilder.put(nodeEntry.key, nodeEntry.value);
-                }
-                minNodeVersion = minNodeVersion == null ? version : Version.min(minNodeVersion, version);
-                maxNodeVersion = maxNodeVersion == null ? version : Version.max(maxNodeVersion, version);
-            }
-
-            return new ProtobufDiscoveryNodes(
-                nodes.build(),
-                dataNodesBuilder.build(),
-                clusterManagerNodesBuilder.build(),
-                ingestNodesBuilder.build(),
-                clusterManagerNodeId,
-                localNodeId,
-                minNonClientNodeVersion == null ? Version.CURRENT : minNonClientNodeVersion,
-                maxNonClientNodeVersion == null ? Version.CURRENT : maxNonClientNodeVersion,
-                maxNodeVersion == null ? Version.CURRENT : maxNodeVersion,
-                minNodeVersion == null ? Version.CURRENT : minNodeVersion
-            );
-        }
-
-        public boolean isLocalNodeElectedClusterManager() {
-            return clusterManagerNodeId != null && clusterManagerNodeId.equals(localNodeId);
-        }
-
-        /** @deprecated As of 2.2, because supporting inclusive language, replaced by {@link #isLocalNodeElectedClusterManager()} */
-        @Deprecated
-        public boolean isLocalNodeElectedMaster() {
-            return isLocalNodeElectedClusterManager();
-        }
-    }
-
-    /**
-     * Check if the given name of the node role is 'cluster_manager' or 'master'.
-    * The method is added for {@link #resolveNodes} to keep the code clear, when support the both above roles.
-    * @deprecated As of 2.0, because promoting inclusive language. MASTER_ROLE is deprecated.
-    * @param matchAttrName a given String for a name of the node role.
-    * @return true if the given roleName is 'cluster_manger' or 'master'
-    */
-    @Deprecated
-    private boolean roleNameIsClusterManager(String matchAttrName) {
-        return DiscoveryNodeRole.MASTER_ROLE.roleName().equals(matchAttrName)
-            || DiscoveryNodeRole.CLUSTER_MANAGER_ROLE.roleName().equals(matchAttrName);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterApplier.java b/server/src/main/java/org/opensearch/cluster/service/ClusterApplier.java
index 539b84ae2e025..939feb89b6054 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterApplier.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterApplier.java
@@ -33,7 +33,6 @@
 package org.opensearch.cluster.service;
 
 import org.opensearch.cluster.ClusterState;
-import org.opensearch.cluster.ProtobufClusterState;
 
 import java.util.function.Supplier;
 
@@ -49,12 +48,6 @@ public interface ClusterApplier {
      */
     void setInitialState(ClusterState initialState);
 
-    // /**
-    //  * Sets the initial state for this applier. Should only be called once.
-    //  * @param initialState the initial state to set
-    //  */
-    // void setInitialProtobufState(ProtobufClusterState initialState);
-
     /**
      * Method to invoke when a new cluster state is available to be applied
      *
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java b/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
index 75b809658f2ea..219477ea15c67 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
@@ -44,7 +44,6 @@
 import org.opensearch.cluster.LocalNodeClusterManagerListener;
 import org.opensearch.cluster.LocalNodeMasterListener;
 import org.opensearch.cluster.NodeConnectionsService;
-import org.opensearch.cluster.ProtobufClusterState;
 import org.opensearch.cluster.TimeoutClusterStateListener;
 import org.opensearch.cluster.metadata.ProcessClusterEventTimeoutException;
 import org.opensearch.cluster.node.DiscoveryNodes;
@@ -115,7 +114,6 @@ public class ClusterApplierService extends AbstractLifecycleComponent implements
     private final Map<TimeoutClusterStateListener, NotifyTimeout> timeoutClusterStateListeners = new ConcurrentHashMap<>();
 
     private final AtomicReference<ClusterState> state; // last applied state
-    // private final AtomicReference<ProtobufClusterState> protobufState; // last applied state
 
     private final String nodeName;
 
@@ -153,15 +151,6 @@ public void setInitialState(ClusterState initialState) {
         state.set(initialState);
     }
 
-    // @Override
-    // public void setInitialProtobufState(ProtobufClusterState initialState) {
-    //     if (lifecycle.started()) {
-    //         throw new IllegalStateException("can't set initial state when started");
-    //     }
-    //     assert protobufState.get() == null : "state is already set";
-    //     protobufState.set(initialState);
-    // }
-
     @Override
     protected synchronized void doStart() {
         Objects.requireNonNull(nodeConnectionsService, "please set the node connection service before starting");
@@ -226,17 +215,6 @@ public ClusterState state() {
         return clusterState;
     }
 
-    // /**
-    //  * The current cluster state.
-    //  * Should be renamed to appliedClusterState
-    //  */
-    // public ProtobufClusterState protobufState() {
-    //     assert assertNotCalledFromClusterStateApplier("the applied cluster state is not yet available");
-    //     ProtobufClusterState clusterState = this.protobufState.get();
-    //     assert clusterState != null : "initial cluster state not set yet";
-    //     return clusterState;
-    // }
-
     /**
      * Returns true if the appliedClusterState is not null
      */
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterService.java b/server/src/main/java/org/opensearch/cluster/service/ClusterService.java
index 2c079048f3a4b..e097803d86b48 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterService.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterService.java
@@ -42,7 +42,6 @@
 import org.opensearch.cluster.LocalNodeClusterManagerListener;
 import org.opensearch.cluster.LocalNodeMasterListener;
 import org.opensearch.cluster.NodeConnectionsService;
-import org.opensearch.cluster.ProtobufClusterState;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.routing.OperationRouting;
 import org.opensearch.cluster.routing.RerouteService;
@@ -171,14 +170,6 @@ public ClusterState state() {
         return clusterApplierService.state();
     }
 
-    // /**
-    //  * The currently applied cluster state.
-    //  * TODO: Should be renamed to appliedState / appliedClusterState
-    //  */
-    // public ProtobufClusterState protobufState() {
-    //     return clusterApplierService.protobufState();
-    // }
-
     /**
      * Adds a high priority applier of updated cluster states.
      */
diff --git a/server/src/main/java/org/opensearch/common/logging/ProtobufNodeAndClusterIdStateListener.java b/server/src/main/java/org/opensearch/common/logging/ProtobufNodeAndClusterIdStateListener.java
deleted file mode 100644
index 848623d13b248..0000000000000
--- a/server/src/main/java/org/opensearch/common/logging/ProtobufNodeAndClusterIdStateListener.java
+++ /dev/null
@@ -1,71 +0,0 @@
-// /*
-//  * 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.
-//  */
-
-// package org.opensearch.common.logging;
-
-// import org.apache.logging.log4j.LogManager;
-// import org.apache.logging.log4j.Logger;
-// import org.opensearch.cluster.ProtobufClusterState;
-// import org.opensearch.cluster.ProtobufClusterStateObserver;
-// import org.opensearch.cluster.service.ClusterService;
-// import org.opensearch.common.unit.TimeValue;
-// import org.opensearch.common.util.concurrent.ThreadContext;
-
-// /**
-//  * The {@link ProtobufNodeAndClusterIdStateListener} listens to cluster state changes and ONLY when receives the first update
-//  * it sets the clusterUUID and nodeID in log4j pattern converter {@link NodeAndClusterIdConverter}.
-//  * Once the first update is received, it will automatically be de-registered from subsequent updates.
-//  *
-//  * @opensearch.internal
-//  */
-// public class ProtobufNodeAndClusterIdStateListener implements ProtobufClusterStateObserver.Listener {
-//     private static final Logger logger = LogManager.getLogger(ProtobufNodeAndClusterIdStateListener.class);
-
-//     private ProtobufNodeAndClusterIdStateListener() {}
-
-//     /**
-//      * Subscribes for the first cluster state update where nodeId and clusterId is present
-//      * and sets these values in {@link NodeAndClusterIdConverter}.
-//      */
-//     public static void getAndSetNodeIdAndClusterId(ClusterService clusterService, ThreadContext threadContext) {
-//         ProtobufClusterState clusterState = clusterService.protobufState();
-//         ProtobufClusterStateObserver observer = new ProtobufClusterStateObserver(clusterState, clusterService, null, logger, threadContext);
-
-//         observer.waitForNextChange(
-//             new ProtobufNodeAndClusterIdStateListener(),
-//             ProtobufNodeAndClusterIdStateListener::isNodeAndClusterIdPresent
-//         );
-//     }
-
-//     private static boolean isNodeAndClusterIdPresent(ProtobufClusterState clusterState) {
-//         return getNodeId(clusterState) != null && getClusterUUID(clusterState) != null;
-//     }
-
-//     private static String getClusterUUID(ProtobufClusterState state) {
-//         return state.getMetadata().clusterUUID();
-//     }
-
-//     private static String getNodeId(ProtobufClusterState state) {
-//         return state.getNodes().getLocalNodeId();
-//     }
-
-//     @Override
-//     public void onNewClusterState(ProtobufClusterState state) {
-//         String nodeId = getNodeId(state);
-//         String clusterUUID = getClusterUUID(state);
-
-//         logger.debug("Received cluster state update. Setting nodeId=[{}] and clusterUuid=[{}]", nodeId, clusterUUID);
-//         NodeAndClusterIdConverter.setNodeIdAndClusterId(nodeId, clusterUUID);
-//     }
-
-//     @Override
-//     public void onClusterServiceClose() {}
-
-//     @Override
-//     public void onTimeout(TimeValue timeout) {}
-// }
diff --git a/server/src/main/java/org/opensearch/common/transport/ProtobufTransportAddress.java b/server/src/main/java/org/opensearch/common/transport/ProtobufTransportAddress.java
deleted file mode 100644
index 79ecce81bb97e..0000000000000
--- a/server/src/main/java/org/opensearch/common/transport/ProtobufTransportAddress.java
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
-* 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.
-*/
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
-package org.opensearch.common.transport;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.network.NetworkAddress;
-import org.opensearch.core.xcontent.ToXContent.Params;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.net.InetAddress;
-import java.net.InetSocketAddress;
-import java.net.UnknownHostException;
-
-/** not used
- * A transport address used for IP socket address (wraps {@link java.net.InetSocketAddress}).
-*
-* @opensearch.internal
-*/
-public final class ProtobufTransportAddress implements ProtobufWriteable, ToXContentFragment {
-
-    /**
-     * A <a href="https://en.wikipedia.org/wiki/0.0.0.0">non-routeable v4 meta transport address</a> that can be used for
-    * testing or in scenarios where targets should be marked as non-applicable from a transport perspective.
-    */
-    public static final InetAddress META_ADDRESS;
-
-    static {
-        try {
-            META_ADDRESS = InetAddress.getByName("0.0.0.0");
-        } catch (UnknownHostException e) {
-            throw new AssertionError(e);
-        }
-    }
-
-    private final InetSocketAddress address;
-
-    public ProtobufTransportAddress(InetAddress address, int port) {
-        this(new InetSocketAddress(address, port));
-    }
-
-    public ProtobufTransportAddress(InetSocketAddress address) {
-        if (address == null) {
-            throw new IllegalArgumentException("InetSocketAddress must not be null");
-        }
-        if (address.getAddress() == null) {
-            throw new IllegalArgumentException("Address must be resolved but wasn't - InetSocketAddress#getAddress() returned null");
-        }
-        this.address = address;
-    }
-
-    /**
-     * Read from a stream.
-     */
-    public ProtobufTransportAddress(CodedInputStream in) throws IOException {
-        final int len = in.readRawByte();
-        final byte[] a = new byte[len]; // 4 bytes (IPv4) or 16 bytes (IPv6)
-        in.readRawBytes(len);
-        String host = in.readString(); // the host string was serialized so we can ignore the passed in version
-        final InetAddress inetAddress = InetAddress.getByAddress(host, a);
-        int port = in.readInt32();
-        this.address = new InetSocketAddress(inetAddress, port);
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        byte[] bytes = address.getAddress().getAddress();  // 4 bytes (IPv4) or 16 bytes (IPv6)
-        out.write((byte) bytes.length); // 1 byte
-        out.write(bytes, 0, bytes.length);
-        out.writeStringNoTag(address.getHostString());
-        // don't serialize scope ids over the network!!!!
-        // these only make sense with respect to the local machine, and will only formulate
-        // the address incorrectly remotely.
-        out.writeInt32NoTag(address.getPort());
-    }
-
-    /**
-     * Returns a string representation of the enclosed {@link InetSocketAddress}
-    * @see NetworkAddress#format(InetAddress)
-    */
-    public String getAddress() {
-        return NetworkAddress.format(address.getAddress());
-    }
-
-    /**
-     * Returns the addresses port
-    */
-    public int getPort() {
-        return address.getPort();
-    }
-
-    /**
-     * Returns the enclosed {@link InetSocketAddress}
-    */
-    public InetSocketAddress address() {
-        return this.address;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        ProtobufTransportAddress address1 = (ProtobufTransportAddress) o;
-        return address.equals(address1.address);
-    }
-
-    @Override
-    public int hashCode() {
-        return address != null ? address.hashCode() : 0;
-    }
-
-    @Override
-    public String toString() {
-        return NetworkAddress.format(address);
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        return builder.value(toString());
-    }
-}
diff --git a/server/src/main/java/org/opensearch/discovery/PeerFinder.java b/server/src/main/java/org/opensearch/discovery/PeerFinder.java
index 873abf690feb6..f979b6b45e0d0 100644
--- a/server/src/main/java/org/opensearch/discovery/PeerFinder.java
+++ b/server/src/main/java/org/opensearch/discovery/PeerFinder.java
@@ -519,6 +519,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                 }
+
+                @Override
+                public PeersResponse read(byte[] in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
             };
             transportService.sendRequest(
                 discoveryNode,
diff --git a/server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java b/server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java
index f9ea7c75351a6..2e3d6f95927ed 100644
--- a/server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java
+++ b/server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java
@@ -17,7 +17,6 @@
 import com.google.protobuf.InvalidProtocolBufferException;
 
 import org.opensearch.common.io.stream.TryWriteable;
-import org.opensearch.common.unit.TimeValue;
 import org.opensearch.example.proto.ExampleRequestProto.ExampleRequest;
 import org.opensearch.transport.TransportRequest;
 
@@ -63,7 +62,7 @@ public String message() {
         return request.getMessage();
     }
 
-    public ExampleRequest request() {
+    public ExampleRequest exampleRequest() {
         return request;
     }
 
diff --git a/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java b/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
index f0b082fb29b37..ab41083f92ec3 100644
--- a/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
+++ b/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
@@ -385,6 +385,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
             }
+
+            @Override
+            public InitializeExtensionResponse read(byte[] in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
         };
 
         logger.info("Sending extension request type: " + REQUEST_EXTENSION_ACTION_NAME);
diff --git a/server/src/main/java/org/opensearch/extensions/UpdateSettingsResponseHandler.java b/server/src/main/java/org/opensearch/extensions/UpdateSettingsResponseHandler.java
index fdca909949c67..858cd4d88630e 100644
--- a/server/src/main/java/org/opensearch/extensions/UpdateSettingsResponseHandler.java
+++ b/server/src/main/java/org/opensearch/extensions/UpdateSettingsResponseHandler.java
@@ -62,4 +62,10 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
         // TODO Auto-generated method stub
         throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
     }
+
+    @Override
+    public AcknowledgedResponse read(byte[] in) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'read'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java b/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java
index ed912c069db76..42875056ef0fe 100644
--- a/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java
+++ b/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java
@@ -234,6 +234,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                 }
+
+                @Override
+                public ExtensionActionResponse read(byte[] in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
             };
         try {
             transportService.sendRequest(
@@ -310,6 +316,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                 }
+
+                @Override
+                public RemoteExtensionActionResponse read(byte[] in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
             };
         try {
             transportService.sendRequest(
diff --git a/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java b/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java
index eb168c0736860..771d3e20d6829 100644
--- a/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java
+++ b/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java
@@ -253,6 +253,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
             }
+
+            @Override
+            public RestExecuteOnExtensionResponse read(byte[] in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
         };
 
         try {
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java
index 26d6b22524c8a..e578155f75cd8 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java
@@ -182,6 +182,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                         // TODO Auto-generated method stub
                         throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                     }
+
+                    @Override
+                    public ReplicationResponse read(byte[] in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
                 }
             );
         }
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java
index 5e0d0801bb74b..4f877998d7634 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java
@@ -190,6 +190,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                         // TODO Auto-generated method stub
                         throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                     }
+
+                    @Override
+                    public ReplicationResponse read(byte[] in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
                 }
             );
         }
diff --git a/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java b/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
index 03659e98bb076..c57e153d7e349 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
@@ -763,5 +763,11 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
             // TODO Auto-generated method stub
             throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
         }
+
+        @Override
+        public RecoveryResponse read(byte[] in) throws IOException {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'read'");
+        }
     }
 }
diff --git a/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java b/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
index 6bf319b5246b8..2b5547e7f2256 100644
--- a/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
+++ b/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
@@ -187,6 +187,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                         // TODO Auto-generated method stub
                         throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                     }
+
+                    @Override
+                    public ReplicationResponse read(byte[] in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
                 }
             );
             logger.trace(
diff --git a/server/src/main/java/org/opensearch/indices/store/IndicesStore.java b/server/src/main/java/org/opensearch/indices/store/IndicesStore.java
index d4aca6a79b0f3..ce6557e160b83 100644
--- a/server/src/main/java/org/opensearch/indices/store/IndicesStore.java
+++ b/server/src/main/java/org/opensearch/indices/store/IndicesStore.java
@@ -367,6 +367,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
             throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
         }
 
+        @Override
+        public ShardActiveResponse read(byte[] in) throws IOException {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'read'");
+        }
+
     }
 
     private class ShardActiveRequestHandler implements TransportRequestHandler<ShardActiveRequest> {
diff --git a/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java b/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java
new file mode 100644
index 0000000000000..96b8320fc6c53
--- /dev/null
+++ b/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java
@@ -0,0 +1,684 @@
+/*
+ * 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.
+ */
+
+package org.opensearch.monitor.jvm;
+
+import org.apache.lucene.util.Constants;
+import org.opensearch.common.Booleans;
+import org.opensearch.common.SuppressForbidden;
+import org.opensearch.common.io.PathUtils;
+import org.opensearch.common.io.stream.ProtobufStreamInput;
+import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.StreamOutput;
+import org.opensearch.common.io.stream.Writeable;
+import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.node.ProtobufReportingService;
+import org.opensearch.node.ReportingService;
+
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+
+import java.io.IOException;
+import java.lang.management.GarbageCollectorMXBean;
+import java.lang.management.ManagementFactory;
+import java.lang.management.ManagementPermission;
+import java.lang.management.MemoryMXBean;
+import java.lang.management.MemoryPoolMXBean;
+import java.lang.management.PlatformManagedObject;
+import java.lang.management.RuntimeMXBean;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Holds information about the JVM
+ *
+ * @opensearch.internal
+ */
+public class ProtobufJvmInfo implements ProtobufReportingService.ProtobufInfo {
+
+    private static ProtobufJvmInfo INSTANCE;
+
+    static {
+        RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
+        MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
+
+        long heapInit = memoryMXBean.getHeapMemoryUsage().getInit() < 0 ? 0 : memoryMXBean.getHeapMemoryUsage().getInit();
+        long heapMax = memoryMXBean.getHeapMemoryUsage().getMax() < 0 ? 0 : memoryMXBean.getHeapMemoryUsage().getMax();
+        long nonHeapInit = memoryMXBean.getNonHeapMemoryUsage().getInit() < 0 ? 0 : memoryMXBean.getNonHeapMemoryUsage().getInit();
+        long nonHeapMax = memoryMXBean.getNonHeapMemoryUsage().getMax() < 0 ? 0 : memoryMXBean.getNonHeapMemoryUsage().getMax();
+        long directMemoryMax = 0;
+        try {
+            Class<?> vmClass = Class.forName("sun.misc.VM");
+            directMemoryMax = (Long) vmClass.getMethod("maxDirectMemory").invoke(null);
+        } catch (Exception t) {
+            // ignore
+        }
+        String[] inputArguments = runtimeMXBean.getInputArguments().toArray(new String[0]);
+        Mem mem = new Mem(heapInit, heapMax, nonHeapInit, nonHeapMax, directMemoryMax);
+
+        String bootClassPath;
+        try {
+            bootClassPath = runtimeMXBean.getBootClassPath();
+        } catch (UnsupportedOperationException e) {
+            // oracle java 9
+            bootClassPath = System.getProperty("sun.boot.class.path");
+            if (bootClassPath == null) {
+                // something else
+                bootClassPath = "<unknown>";
+            }
+        }
+        String classPath = runtimeMXBean.getClassPath();
+        Map<String, String> systemProperties = Collections.unmodifiableMap(runtimeMXBean.getSystemProperties());
+
+        List<GarbageCollectorMXBean> gcMxBeans = ManagementFactory.getGarbageCollectorMXBeans();
+        String[] gcCollectors = new String[gcMxBeans.size()];
+        for (int i = 0; i < gcMxBeans.size(); i++) {
+            GarbageCollectorMXBean gcMxBean = gcMxBeans.get(i);
+            gcCollectors[i] = gcMxBean.getName();
+        }
+
+        List<MemoryPoolMXBean> memoryPoolMXBeans = ManagementFactory.getMemoryPoolMXBeans();
+        String[] memoryPools = new String[memoryPoolMXBeans.size()];
+        for (int i = 0; i < memoryPoolMXBeans.size(); i++) {
+            MemoryPoolMXBean memoryPoolMXBean = memoryPoolMXBeans.get(i);
+            memoryPools[i] = memoryPoolMXBean.getName();
+        }
+
+        String onError = null;
+        String onOutOfMemoryError = null;
+        String useCompressedOops = "unknown";
+        String useG1GC = "unknown";
+        long g1RegisionSize = -1;
+        String useSerialGC = "unknown";
+        long configuredInitialHeapSize = -1;
+        long configuredMaxHeapSize = -1;
+        try {
+            @SuppressWarnings("unchecked")
+            Class<? extends PlatformManagedObject> clazz = (Class<? extends PlatformManagedObject>) Class.forName(
+                "com.sun.management.HotSpotDiagnosticMXBean"
+            );
+            Class<?> vmOptionClazz = Class.forName("com.sun.management.VMOption");
+            PlatformManagedObject hotSpotDiagnosticMXBean = ManagementFactory.getPlatformMXBean(clazz);
+            Method vmOptionMethod = clazz.getMethod("getVMOption", String.class);
+            Method valueMethod = vmOptionClazz.getMethod("getValue");
+
+            try {
+                Object onErrorObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "OnError");
+                onError = (String) valueMethod.invoke(onErrorObject);
+            } catch (Exception ignored) {}
+
+            try {
+                Object onOutOfMemoryErrorObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "OnOutOfMemoryError");
+                onOutOfMemoryError = (String) valueMethod.invoke(onOutOfMemoryErrorObject);
+            } catch (Exception ignored) {}
+
+            try {
+                Object useCompressedOopsVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "UseCompressedOops");
+                useCompressedOops = (String) valueMethod.invoke(useCompressedOopsVmOptionObject);
+            } catch (Exception ignored) {}
+
+            try {
+                Object useG1GCVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "UseG1GC");
+                useG1GC = (String) valueMethod.invoke(useG1GCVmOptionObject);
+                Object regionSizeVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "G1HeapRegionSize");
+                g1RegisionSize = Long.parseLong((String) valueMethod.invoke(regionSizeVmOptionObject));
+            } catch (Exception ignored) {}
+
+            try {
+                Object initialHeapSizeVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "InitialHeapSize");
+                configuredInitialHeapSize = Long.parseLong((String) valueMethod.invoke(initialHeapSizeVmOptionObject));
+            } catch (Exception ignored) {}
+
+            try {
+                Object maxHeapSizeVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "MaxHeapSize");
+                configuredMaxHeapSize = Long.parseLong((String) valueMethod.invoke(maxHeapSizeVmOptionObject));
+            } catch (Exception ignored) {}
+
+            try {
+                Object useSerialGCVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "UseSerialGC");
+                useSerialGC = (String) valueMethod.invoke(useSerialGCVmOptionObject);
+            } catch (Exception ignored) {}
+
+        } catch (Exception ignored) {
+
+        }
+
+        final boolean bundledJdk = Booleans.parseBoolean(System.getProperty("opensearch.bundled_jdk", Boolean.FALSE.toString()));
+        final Boolean usingBundledJdk = bundledJdk ? usingBundledJdk() : null;
+
+        INSTANCE = new ProtobufJvmInfo(
+            JvmPid.getPid(),
+            System.getProperty("java.version"),
+            runtimeMXBean.getVmName(),
+            runtimeMXBean.getVmVersion(),
+            runtimeMXBean.getVmVendor(),
+            bundledJdk,
+            usingBundledJdk,
+            runtimeMXBean.getStartTime(),
+            configuredInitialHeapSize,
+            configuredMaxHeapSize,
+            mem,
+            inputArguments,
+            bootClassPath,
+            classPath,
+            systemProperties,
+            gcCollectors,
+            memoryPools,
+            onError,
+            onOutOfMemoryError,
+            useCompressedOops,
+            useG1GC,
+            useSerialGC,
+            g1RegisionSize
+        );
+    }
+
+    @SuppressForbidden(reason = "PathUtils#get")
+    private static boolean usingBundledJdk() {
+        /*
+         * We are using the bundled JDK if java.home is the jdk sub-directory of our working directory. This is because we always set
+         * the working directory of Elasticsearch to home, and the bundled JDK is in the jdk sub-directory there.
+         */
+        final String javaHome = System.getProperty("java.home");
+        final String userDir = System.getProperty("user.dir");
+        if (Constants.MAC_OS_X) {
+            return PathUtils.get(javaHome).equals(PathUtils.get(userDir).resolve("jdk.app/Contents/Home").toAbsolutePath());
+        } else {
+            return PathUtils.get(javaHome).equals(PathUtils.get(userDir).resolve("jdk").toAbsolutePath());
+        }
+    }
+
+    public static ProtobufJvmInfo jvmInfo() {
+        SecurityManager sm = System.getSecurityManager();
+        if (sm != null) {
+            sm.checkPermission(new ManagementPermission("monitor"));
+            sm.checkPropertyAccess("*");
+        }
+        return INSTANCE;
+    }
+
+    private final long pid;
+    private final String version;
+    private final String vmName;
+    private final String vmVersion;
+    private final String vmVendor;
+    private final boolean bundledJdk;
+    private final Boolean usingBundledJdk;
+    private final long startTime;
+    private final long configuredInitialHeapSize;
+    private final long configuredMaxHeapSize;
+    private final Mem mem;
+    private final String[] inputArguments;
+    private final String bootClassPath;
+    private final String classPath;
+    private final Map<String, String> systemProperties;
+    private final String[] gcCollectors;
+    private final String[] memoryPools;
+    private final String onError;
+    private final String onOutOfMemoryError;
+    private final String useCompressedOops;
+    private final String useG1GC;
+    private final String useSerialGC;
+    private final long g1RegionSize;
+
+    private ProtobufJvmInfo(
+        long pid,
+        String version,
+        String vmName,
+        String vmVersion,
+        String vmVendor,
+        boolean bundledJdk,
+        Boolean usingBundledJdk,
+        long startTime,
+        long configuredInitialHeapSize,
+        long configuredMaxHeapSize,
+        Mem mem,
+        String[] inputArguments,
+        String bootClassPath,
+        String classPath,
+        Map<String, String> systemProperties,
+        String[] gcCollectors,
+        String[] memoryPools,
+        String onError,
+        String onOutOfMemoryError,
+        String useCompressedOops,
+        String useG1GC,
+        String useSerialGC,
+        long g1RegionSize
+    ) {
+        this.pid = pid;
+        this.version = version;
+        this.vmName = vmName;
+        this.vmVersion = vmVersion;
+        this.vmVendor = vmVendor;
+        this.bundledJdk = bundledJdk;
+        this.usingBundledJdk = usingBundledJdk;
+        this.startTime = startTime;
+        this.configuredInitialHeapSize = configuredInitialHeapSize;
+        this.configuredMaxHeapSize = configuredMaxHeapSize;
+        this.mem = mem;
+        this.inputArguments = inputArguments;
+        this.bootClassPath = bootClassPath;
+        this.classPath = classPath;
+        this.systemProperties = systemProperties;
+        this.gcCollectors = gcCollectors;
+        this.memoryPools = memoryPools;
+        this.onError = onError;
+        this.onOutOfMemoryError = onOutOfMemoryError;
+        this.useCompressedOops = useCompressedOops;
+        this.useG1GC = useG1GC;
+        this.useSerialGC = useSerialGC;
+        this.g1RegionSize = g1RegionSize;
+    }
+
+    public ProtobufJvmInfo(StreamInput in) throws IOException {
+        pid = in.readLong();
+        version = in.readString();
+        vmName = in.readString();
+        vmVersion = in.readString();
+        vmVendor = in.readString();
+        bundledJdk = in.readBoolean();
+        usingBundledJdk = in.readOptionalBoolean();
+        startTime = in.readLong();
+        inputArguments = new String[in.readInt()];
+        for (int i = 0; i < inputArguments.length; i++) {
+            inputArguments[i] = in.readString();
+        }
+        bootClassPath = in.readString();
+        classPath = in.readString();
+        systemProperties = in.readMap(StreamInput::readString, StreamInput::readString);
+        mem = new Mem(in);
+        gcCollectors = in.readStringArray();
+        memoryPools = in.readStringArray();
+        useCompressedOops = in.readString();
+        // the following members are only used locally for bootstrap checks, never serialized nor printed out
+        this.configuredMaxHeapSize = -1;
+        this.configuredInitialHeapSize = -1;
+        this.onError = null;
+        this.onOutOfMemoryError = null;
+        this.useG1GC = "unknown";
+        this.useSerialGC = "unknown";
+        this.g1RegionSize = -1;
+    }
+
+    public ProtobufJvmInfo(CodedInputStream in) throws IOException {
+        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
+        pid = in.readInt64();
+        version = in.readString();
+        vmName = in.readString();
+        vmVersion = in.readString();
+        vmVendor = in.readString();
+        bundledJdk = in.readBool();
+        usingBundledJdk = protobufStreamInput.readOptionalBoolean();
+        startTime = in.readInt64();
+        inputArguments = new String[in.readInt32()];
+        for (int i = 0; i < inputArguments.length; i++) {
+            inputArguments[i] = in.readString();
+        }
+        bootClassPath = in.readString();
+        classPath = in.readString();
+        systemProperties = protobufStreamInput.readMap(CodedInputStream::readString, CodedInputStream::readString);
+        mem = new Mem(in);
+        gcCollectors = protobufStreamInput.readStringArray();
+        memoryPools = protobufStreamInput.readStringArray();
+        useCompressedOops = in.readString();
+        // the following members are only used locally for bootstrap checks, never serialized nor printed out
+        this.configuredMaxHeapSize = -1;
+        this.configuredInitialHeapSize = -1;
+        this.onError = null;
+        this.onOutOfMemoryError = null;
+        this.useG1GC = "unknown";
+        this.useSerialGC = "unknown";
+        this.g1RegionSize = -1;
+    }
+
+    @Override
+    public void writeTo(CodedOutputStream out) throws IOException {
+        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
+        out.writeInt64NoTag(pid);
+        out.writeStringNoTag(version);
+        out.writeStringNoTag(vmName);
+        out.writeStringNoTag(vmVersion);
+        out.writeStringNoTag(vmVendor);
+        out.writeBoolNoTag(bundledJdk);
+        protobufStreamOutput.writeOptionalBoolean(usingBundledJdk);
+        out.writeInt64NoTag(startTime);
+        out.writeInt32NoTag(inputArguments.length);
+        for (String inputArgument : inputArguments) {
+            out.writeStringNoTag(inputArgument);
+        }
+        out.writeStringNoTag(bootClassPath);
+        out.writeStringNoTag(classPath);
+        out.writeInt32NoTag(this.systemProperties.size());
+        for (Map.Entry<String, String> entry : systemProperties.entrySet()) {
+            out.writeStringNoTag(entry.getKey());
+            out.writeStringNoTag(entry.getValue());
+        }
+        mem.writeTo(out);
+        protobufStreamOutput.writeStringArray(gcCollectors);
+        protobufStreamOutput.writeStringArray(memoryPools);
+        out.writeStringNoTag(useCompressedOops);
+    }
+
+    /**
+     * The process id.
+     */
+    public long pid() {
+        return this.pid;
+    }
+
+    /**
+     * The process id.
+     */
+    public long getPid() {
+        return pid;
+    }
+
+    public String version() {
+        return this.version;
+    }
+
+    public String getVersion() {
+        return this.version;
+    }
+
+    public int versionAsInteger() {
+        try {
+            int i = 0;
+            StringBuilder sVersion = new StringBuilder();
+            for (; i < version.length(); i++) {
+                if (!Character.isDigit(version.charAt(i)) && version.charAt(i) != '.') {
+                    break;
+                }
+                if (version.charAt(i) != '.') {
+                    sVersion.append(version.charAt(i));
+                }
+            }
+            if (i == 0) {
+                return -1;
+            }
+            return Integer.parseInt(sVersion.toString());
+        } catch (Exception e) {
+            return -1;
+        }
+    }
+
+    public int versionUpdatePack() {
+        try {
+            int i = 0;
+            StringBuilder sVersion = new StringBuilder();
+            for (; i < version.length(); i++) {
+                if (!Character.isDigit(version.charAt(i)) && version.charAt(i) != '.') {
+                    break;
+                }
+                if (version.charAt(i) != '.') {
+                    sVersion.append(version.charAt(i));
+                }
+            }
+            if (i == 0) {
+                return -1;
+            }
+            Integer.parseInt(sVersion.toString());
+            int from;
+            if (version.charAt(i) == '_') {
+                // 1.7.0_4
+                from = ++i;
+            } else if (version.charAt(i) == '-' && version.charAt(i + 1) == 'u') {
+                // 1.7.0-u2-b21
+                i = i + 2;
+                from = i;
+            } else {
+                return -1;
+            }
+            for (; i < version.length(); i++) {
+                if (!Character.isDigit(version.charAt(i)) && version.charAt(i) != '.') {
+                    break;
+                }
+            }
+            if (from == i) {
+                return -1;
+            }
+            return Integer.parseInt(version.substring(from, i));
+        } catch (Exception e) {
+            return -1;
+        }
+    }
+
+    public String getVmName() {
+        return this.vmName;
+    }
+
+    public String getVmVersion() {
+        return this.vmVersion;
+    }
+
+    public String getVmVendor() {
+        return this.vmVendor;
+    }
+
+    public boolean getBundledJdk() {
+        return bundledJdk;
+    }
+
+    public Boolean getUsingBundledJdk() {
+        return usingBundledJdk;
+    }
+
+    public long getStartTime() {
+        return this.startTime;
+    }
+
+    public Mem getMem() {
+        return this.mem;
+    }
+
+    public String[] getInputArguments() {
+        return this.inputArguments;
+    }
+
+    public String getBootClassPath() {
+        return this.bootClassPath;
+    }
+
+    public String getClassPath() {
+        return this.classPath;
+    }
+
+    public Map<String, String> getSystemProperties() {
+        return this.systemProperties;
+    }
+
+    public long getConfiguredInitialHeapSize() {
+        return configuredInitialHeapSize;
+    }
+
+    public long getConfiguredMaxHeapSize() {
+        return configuredMaxHeapSize;
+    }
+
+    public String onError() {
+        return onError;
+    }
+
+    public String onOutOfMemoryError() {
+        return onOutOfMemoryError;
+    }
+
+    /**
+     * The value of the JVM flag UseCompressedOops, if available otherwise
+     * "unknown". The value "unknown" indicates that an attempt was
+     * made to obtain the value of the flag on this JVM and the attempt
+     * failed.
+     *
+     * @return the value of the JVM flag UseCompressedOops or "unknown"
+     */
+    public String useCompressedOops() {
+        return this.useCompressedOops;
+    }
+
+    public String useG1GC() {
+        return this.useG1GC;
+    }
+
+    public String useSerialGC() {
+        return this.useSerialGC;
+    }
+
+    public long getG1RegionSize() {
+        return g1RegionSize;
+    }
+
+    public String[] getGcCollectors() {
+        return gcCollectors;
+    }
+
+    public String[] getMemoryPools() {
+        return memoryPools;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(Fields.JVM);
+        builder.field(Fields.PID, pid);
+        builder.field(Fields.VERSION, version);
+        builder.field(Fields.VM_NAME, vmName);
+        builder.field(Fields.VM_VERSION, vmVersion);
+        builder.field(Fields.VM_VENDOR, vmVendor);
+        builder.field(Fields.BUNDLED_JDK, bundledJdk);
+        builder.field(Fields.USING_BUNDLED_JDK, usingBundledJdk);
+        builder.timeField(Fields.START_TIME_IN_MILLIS, Fields.START_TIME, startTime);
+
+        builder.startObject(Fields.MEM);
+        builder.humanReadableField(Fields.HEAP_INIT_IN_BYTES, Fields.HEAP_INIT, new ByteSizeValue(mem.heapInit));
+        builder.humanReadableField(Fields.HEAP_MAX_IN_BYTES, Fields.HEAP_MAX, new ByteSizeValue(mem.heapMax));
+        builder.humanReadableField(Fields.NON_HEAP_INIT_IN_BYTES, Fields.NON_HEAP_INIT, new ByteSizeValue(mem.nonHeapInit));
+        builder.humanReadableField(Fields.NON_HEAP_MAX_IN_BYTES, Fields.NON_HEAP_MAX, new ByteSizeValue(mem.nonHeapMax));
+        builder.humanReadableField(Fields.DIRECT_MAX_IN_BYTES, Fields.DIRECT_MAX, new ByteSizeValue(mem.directMemoryMax));
+        builder.endObject();
+
+        builder.array(Fields.GC_COLLECTORS, gcCollectors);
+        builder.array(Fields.MEMORY_POOLS, memoryPools);
+
+        builder.field(Fields.USING_COMPRESSED_OOPS, useCompressedOops);
+
+        builder.field(Fields.INPUT_ARGUMENTS, inputArguments);
+
+        builder.endObject();
+        return builder;
+    }
+
+    static final class Fields {
+        static final String JVM = "jvm";
+        static final String PID = "pid";
+        static final String VERSION = "version";
+        static final String VM_NAME = "vm_name";
+        static final String VM_VERSION = "vm_version";
+        static final String VM_VENDOR = "vm_vendor";
+        static final String BUNDLED_JDK = "bundled_jdk";
+        static final String USING_BUNDLED_JDK = "using_bundled_jdk";
+        static final String START_TIME = "start_time";
+        static final String START_TIME_IN_MILLIS = "start_time_in_millis";
+
+        static final String MEM = "mem";
+        static final String HEAP_INIT = "heap_init";
+        static final String HEAP_INIT_IN_BYTES = "heap_init_in_bytes";
+        static final String HEAP_MAX = "heap_max";
+        static final String HEAP_MAX_IN_BYTES = "heap_max_in_bytes";
+        static final String NON_HEAP_INIT = "non_heap_init";
+        static final String NON_HEAP_INIT_IN_BYTES = "non_heap_init_in_bytes";
+        static final String NON_HEAP_MAX = "non_heap_max";
+        static final String NON_HEAP_MAX_IN_BYTES = "non_heap_max_in_bytes";
+        static final String DIRECT_MAX = "direct_max";
+        static final String DIRECT_MAX_IN_BYTES = "direct_max_in_bytes";
+        static final String GC_COLLECTORS = "gc_collectors";
+        static final String MEMORY_POOLS = "memory_pools";
+        static final String USING_COMPRESSED_OOPS = "using_compressed_ordinary_object_pointers";
+        static final String INPUT_ARGUMENTS = "input_arguments";
+    }
+
+    /**
+     * Memory information.
+     *
+     * @opensearch.internal
+     */
+    public static class Mem implements Writeable, ProtobufWriteable {
+
+        private final long heapInit;
+        private final long heapMax;
+        private final long nonHeapInit;
+        private final long nonHeapMax;
+        private final long directMemoryMax;
+
+        public Mem(long heapInit, long heapMax, long nonHeapInit, long nonHeapMax, long directMemoryMax) {
+            this.heapInit = heapInit;
+            this.heapMax = heapMax;
+            this.nonHeapInit = nonHeapInit;
+            this.nonHeapMax = nonHeapMax;
+            this.directMemoryMax = directMemoryMax;
+        }
+
+        public Mem(StreamInput in) throws IOException {
+            this.heapInit = in.readVLong();
+            this.heapMax = in.readVLong();
+            this.nonHeapInit = in.readVLong();
+            this.nonHeapMax = in.readVLong();
+            this.directMemoryMax = in.readVLong();
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            out.writeVLong(heapInit);
+            out.writeVLong(heapMax);
+            out.writeVLong(nonHeapInit);
+            out.writeVLong(nonHeapMax);
+            out.writeVLong(directMemoryMax);
+        }
+
+        public Mem(CodedInputStream in) throws IOException {
+            this.heapInit = in.readInt64();
+            this.heapMax = in.readInt64();
+            this.nonHeapInit = in.readInt64();
+            this.nonHeapMax = in.readInt64();
+            this.directMemoryMax = in.readInt64();
+        }
+
+        @Override
+        public void writeTo(CodedOutputStream out) throws IOException {
+            out.writeInt64NoTag(heapInit);
+            out.writeInt64NoTag(heapMax);
+            out.writeInt64NoTag(nonHeapInit);
+            out.writeInt64NoTag(nonHeapMax);
+            out.writeInt64NoTag(directMemoryMax);
+        }
+
+        public ByteSizeValue getHeapInit() {
+            return new ByteSizeValue(heapInit);
+        }
+
+        public ByteSizeValue getHeapMax() {
+            return new ByteSizeValue(heapMax);
+        }
+
+        public ByteSizeValue getNonHeapInit() {
+            return new ByteSizeValue(nonHeapInit);
+        }
+
+        public ByteSizeValue getNonHeapMax() {
+            return new ByteSizeValue(nonHeapMax);
+        }
+
+        public ByteSizeValue getDirectMemoryMax() {
+            return new ByteSizeValue(directMemoryMax);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/node/Node.java b/server/src/main/java/org/opensearch/node/Node.java
index 1ad0962437780..5c24180cc7cec 100644
--- a/server/src/main/java/org/opensearch/node/Node.java
+++ b/server/src/main/java/org/opensearch/node/Node.java
@@ -101,8 +101,6 @@
 import org.opensearch.cluster.ClusterStateObserver;
 import org.opensearch.cluster.InternalClusterInfoService;
 import org.opensearch.cluster.NodeConnectionsService;
-import org.opensearch.cluster.ProtobufClusterState;
-// import org.opensearch.cluster.ProtobufClusterStateObserver;
 import org.opensearch.cluster.action.index.MappingUpdatedAction;
 import org.opensearch.cluster.metadata.AliasValidator;
 import org.opensearch.cluster.metadata.IndexTemplateMetadata;
@@ -114,7 +112,6 @@
 import org.opensearch.cluster.metadata.TemplateUpgradeService;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
-import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.routing.BatchedRerouteService;
 import org.opensearch.cluster.routing.RerouteService;
 import org.opensearch.cluster.routing.allocation.DiskThresholdMonitor;
@@ -131,7 +128,6 @@
 import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.logging.HeaderWarning;
 import org.opensearch.common.logging.NodeAndClusterIdStateListener;
-// import org.opensearch.common.logging.ProtobufNodeAndClusterIdStateListener;
 import org.opensearch.common.network.NetworkAddress;
 import org.opensearch.common.network.NetworkModule;
 import org.opensearch.common.network.NetworkService;
@@ -143,7 +139,6 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.settings.SettingsModule;
 import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.BoundTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.BigArrays;
@@ -558,19 +553,6 @@ protected Node(
                 additionalSettings.addAll(builder.getRegisteredSettings());
             }
             client = new NodeClient(settings, threadPool);
-
-            // final ProtobufThreadPool protobufThreadPool = new ProtobufThreadPool(settings, runnableTaskListener,
-            // executorBuilders.toArray(new ProtobufExecutorBuilder[0]));
-            // resourcesToClose.add(() -> ProtobufThreadPool.terminate(threadPool, 10, TimeUnit.SECONDS));
-            // final ResourceWatcherService resourceWatcherServiceProtobuf = new ResourceWatcherService(settings, protobufThreadPool);
-            // resourcesToClose.add(resourceWatcherServiceProtobuf);
-            // // adds the context to the DeprecationLogger so that it does not need to be injected everywhere
-            // HeaderWarning.setThreadContext(protobufThreadPool.getThreadContext());
-            // resourcesToClose.add(() -> HeaderWarning.removeThreadContext(protobufThreadPool.getThreadContext()));
-
-            // for (final ProtobufExecutorBuilder<?> builder : protobufThreadPool.builders()) {
-            // additionalSettings.addAll(builder.getRegisteredSettings());
-            // }
             protobufClient = new ProtobufNodeClient(settings, threadPool);
 
             final ScriptModule scriptModule = new ScriptModule(settings, pluginsService.filterPlugins(ScriptPlugin.class));
@@ -918,15 +900,6 @@ protected Node(
                 settingsModule.getClusterSettings(),
                 taskHeaders
             );
-            // final ProtobufTransportService protobufTransportService = newProtobufTransportService(
-            //     settings,
-            //     transport,
-            //     threadPool,
-            //     networkModule.getProtobufTransportInterceptor(),
-            //     protobufLocalNodeFactory,
-            //     settingsModule.getClusterSettings(),
-            //     taskHeaders
-            // );
             TopNSearchTasksLogger taskConsumer = new TopNSearchTasksLogger(settings, settingsModule.getClusterSettings());
             transportService.getTaskManager().registerTaskResourceConsumer(taskConsumer);
             // if (FeatureFlags.isEnabled(FeatureFlags.EXTENSIONS)) {
@@ -1311,18 +1284,6 @@ protected TransportService newTransportService(
         return new TransportService(settings, transport, threadPool, interceptor, localNodeFactory, clusterSettings, taskHeaders);
     }
 
-    // protected ProtobufTransportService newProtobufTransportService(
-    //     Settings settings,
-    //     Transport transport,
-    //     ThreadPool threadPool,
-    //     ProtobufTransportInterceptor interceptor,
-    //     Function<BoundTransportAddress, DiscoveryNode> localNodeFactory,
-    //     ClusterSettings clusterSettings,
-    //     Set<String> taskHeaders
-    // ) {
-    //     return new ProtobufTransportService(settings, transport, threadPool, interceptor, localNodeFactory, clusterSettings, taskHeaders);
-    // }
-
     protected void processRecoverySettings(ClusterSettings clusterSettings, RecoverySettings recoverySettings) {
         // Noop in production, overridden by tests
     }
@@ -1393,24 +1354,15 @@ public Node start() throws NodeValidationException {
         transportService.getTaskManager().setTaskResultsService(injector.getInstance(TaskResultsService.class));
         transportService.getTaskManager().setTaskCancellationService(new TaskCancellationService(transportService));
 
-        // ProtobufTransportService protobufTransportService = injector.getInstance(ProtobufTransportService.class);
-        // protobufTransportService.getTaskManager().setTaskResultsService(injector.getInstance(TaskResultsService.class));
-        // protobufTransportService.getTaskManager().setTaskCancellationService(new ProtobufTaskCancellationService(protobufTransportService));
-
         TaskResourceTrackingService taskResourceTrackingService = injector.getInstance(TaskResourceTrackingService.class);
         transportService.getTaskManager().setTaskResourceTrackingService(taskResourceTrackingService);
-        // protobufTransportService.getTaskManager().setTaskResourceTrackingService(taskResourceTrackingService);
         runnableTaskListener.set(taskResourceTrackingService);
 
         transportService.start();
         assert localNodeFactory.getNode() != null;
         assert transportService.getLocalNode().equals(localNodeFactory.getNode())
             : "transportService has a different local node than the factory provided";
-        // protobufTransportService.start();
-        // protobufTransportService.setLocalNode(localNodeFactory.getNode());
         assert localNodeFactory.getNode() != null;
-        // assert protobufTransportService.getLocalNode().equals(localNodeFactory.getNode())
-        //     : "protobufTransportService has a different local node than the factory provided";
         injector.getInstance(PeerRecoverySourceService.class).start();
         injector.getInstance(SegmentReplicationSourceService.class).start();
 
@@ -1457,29 +1409,14 @@ public Node start() throws NodeValidationException {
         assert clusterService.localNode().equals(localNodeFactory.getNode())
             : "clusterService has a different local node than the factory provided";
         transportService.acceptIncomingRequests();
-        // protobufTransportService.acceptIncomingRequests();
         discovery.startInitialJoin();
         final TimeValue initialStateTimeout = DiscoverySettings.INITIAL_STATE_TIMEOUT_SETTING.get(settings());
         configureNodeAndClusterIdStateListener(clusterService);
-        // configureProtobufNodeAndClusterIdStateListener(clusterService);
-
-        ClusterState clusterState1 = clusterService.state();
-        // System.out.println("Cluster state: " + clusterState1);
-        // ProtobufClusterState protobufClusterState1 = clusterService.protobufState();
-        // System.out.println("Protobuf Cluster state: " + protobufClusterState1);
 
         if (initialStateTimeout.millis() > 0) {
             final ThreadPool thread = injector.getInstance(ThreadPool.class);
             ClusterState clusterState = clusterService.state();
-            // ProtobufClusterState protobufClusterState = clusterService.protobufState();
             ClusterStateObserver observer = new ClusterStateObserver(clusterState, clusterService, null, logger, thread.getThreadContext());
-            // ProtobufClusterStateObserver protobufObserver = new ProtobufClusterStateObserver(
-            //     protobufClusterState,
-            //     clusterService,
-            //     null,
-            //     logger,
-            //     thread.getThreadContext()
-            // );
 
             if (clusterState.nodes().getClusterManagerNodeId() == null) {
                 logger.debug("waiting to join the cluster. timeout [{}]", initialStateTimeout);
@@ -1508,33 +1445,6 @@ public void onTimeout(TimeValue timeout) {
                     throw new OpenSearchTimeoutException("Interrupted while waiting for initial discovery state");
                 }
             }
-            // if (protobufClusterState.nodes().getClusterManagerNodeId() == null) {
-            //     logger.debug("waiting to join the cluster. timeout [{}]", initialStateTimeout);
-            //     final CountDownLatch latch = new CountDownLatch(1);
-            //     protobufObserver.waitForNextChange(new ProtobufClusterStateObserver.Listener() {
-            //         @Override
-            //         public void onNewClusterState(ProtobufClusterState state) {
-            //             latch.countDown();
-            //         }
-
-            //         @Override
-            //         public void onClusterServiceClose() {
-            //             latch.countDown();
-            //         }
-
-            //         @Override
-            //         public void onTimeout(TimeValue timeout) {
-            //             logger.warn("timed out while waiting for initial discovery state - timeout: {}", initialStateTimeout);
-            //             latch.countDown();
-            //         }
-            //     }, state -> state.nodes().getClusterManagerNodeId() != null, initialStateTimeout);
-
-            //     try {
-            //         latch.await();
-            //     } catch (InterruptedException e) {
-            //         throw new OpenSearchTimeoutException("Interrupted while waiting for initial discovery state");
-            //     }
-            // }
         }
 
         injector.getInstance(HttpServerTransport.class).start();
@@ -1560,13 +1470,6 @@ protected void configureNodeAndClusterIdStateListener(ClusterService clusterServ
         );
     }
 
-    // protected void configureProtobufNodeAndClusterIdStateListener(ClusterService clusterService) {
-    //     ProtobufNodeAndClusterIdStateListener.getAndSetNodeIdAndClusterId(
-    //         clusterService,
-    //         injector.getInstance(ThreadPool.class).getThreadContext()
-    //     );
-    // }
-
     private Node stop() {
         if (!lifecycle.moveToStopped()) {
             return this;
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
index 3922be907d20a..b5c4f2b9d27b9 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
@@ -17,16 +17,13 @@
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
 import org.opensearch.client.node.ProtobufNodeClient;
-import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.DiscoveryNodeRole;
-import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.common.Strings;
 import org.opensearch.common.Table;
 import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.network.NetworkAddress;
 import org.opensearch.common.transport.TransportAddress;
-import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.common.unit.TimeValue;
 import org.opensearch.http.ProtobufHttpInfo;
 import org.opensearch.index.cache.query.ProtobufQueryCacheStats;
 import org.opensearch.index.cache.request.ProtobufRequestCacheStats;
@@ -51,6 +48,19 @@
 import org.opensearch.rest.action.RestResponseListener;
 import org.opensearch.script.ProtobufScriptStats;
 import org.opensearch.search.suggest.completion.ProtobufCompletionStats;
+import org.opensearch.server.proto.ClusterStateResponseProto;
+import org.opensearch.server.proto.NodesInfoProto.NodesInfo;
+import org.opensearch.server.proto.NodesStatsProto.NodesStats;
+import org.opensearch.server.proto.NodesStatsProto.NodesStats.FlushStats;
+import org.opensearch.server.proto.NodesStatsProto.NodesStats.GetStats;
+import org.opensearch.server.proto.NodesStatsProto.NodesStats.IndexingStats;
+import org.opensearch.server.proto.NodesStatsProto.NodesStats.MergeStats;
+import org.opensearch.server.proto.NodesStatsProto.NodesStats.QueryCacheStats;
+import org.opensearch.server.proto.NodesStatsProto.NodesStats.RefreshStats;
+import org.opensearch.server.proto.NodesStatsProto.NodesStats.RequestCacheStats;
+import org.opensearch.server.proto.NodesStatsProto.NodesStats.ScriptStats;
+import org.opensearch.server.proto.NodesStatsProto.NodesStats.SearchStats;
+import org.opensearch.server.proto.NodesStatsProto.NodesStats.SegmentStats;
 
 import java.util.List;
 import java.util.Locale;
@@ -335,7 +345,7 @@ Table buildTable(
         ProtobufNodesInfoResponse nodesInfo,
         ProtobufNodesStatsResponse nodesStats
     ) {
-        DiscoveryNodes nodes = state.getState().nodes();
+        ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes nodes = state.response().getClusterState().getNodes();
         String clusterManagerId = nodes.getClusterManagerNodeId();
         Table table = getTableWithHeader(req);
         // System.out.println("Nodes: " + nodes);
@@ -344,193 +354,195 @@ Table buildTable(
         // System.out.println("nodesInfo: " + nodesInfo);
         // System.out.println("nodesStats: " + nodesStats);
 
-        for (DiscoveryNode node : nodes) {
-            ProtobufNodeInfo info = nodesInfo.getNodesMap().get(node.getId());
-            ProtobufNodeStats stats = nodesStats.getNodesMap().get(node.getId());
+        for (ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node node : nodes.getAllNodesMap().values()) {
+            NodesInfo info = nodesInfo.nodesMap().get(node.getNodeId());
+            System.out.println("info: " + info);
+            NodesStats stats = nodesStats.nodesMap().get(node.getNodeId());
+            System.out.println("stats: " + stats);
 
-            JvmInfo jvmInfo = info == null ? null : info.getInfo(JvmInfo.class);
-            ProtobufJvmStats jvmStats = stats == null ? null : stats.getJvm();
-            ProtobufFsInfo fsInfo = stats == null ? null : stats.getFs();
-            ProtobufOsStats osStats = stats == null ? null : stats.getOs();
-            ProtobufProcessStats processStats = stats == null ? null : stats.getProcess();
-            ProtobufNodeIndicesStats indicesStats = stats == null ? null : stats.getIndices();
+            // JvmInfo jvmInfo = info == null ? null : info.getInfo(JvmInfo.class);
+            // ProtobufJvmStats jvmStats = stats == null ? null : stats.getJvm();
+            // ProtobufFsInfo fsInfo = stats == null ? null : stats.getFs();
+            // ProtobufOsStats osStats = stats == null ? null : stats.getOs();
+            // ProtobufProcessStats processStats = stats == null ? null : stats.getProcess();
+            // ProtobufNodeIndicesStats indicesStats = stats == null ? null : stats.getIndices();
 
             table.startRow();
 
-            table.addCell(fullId ? node.getId() : Strings.substring(node.getId(), 0, 4));
-            table.addCell(info == null ? null : info.getInfo(ProtobufProcessInfo.class).getId());
+            table.addCell(fullId ? node.getNodeId() : Strings.substring(node.getNodeId(), 0, 4));
+            table.addCell(info == null ? null : info.getProcessId());
             table.addCell(node.getHostAddress());
-            table.addCell(node.getAddress().address().getPort());
-            final ProtobufHttpInfo httpInfo = info == null ? null : info.getInfo(ProtobufHttpInfo.class);
-            if (httpInfo != null) {
-                TransportAddress transportAddress = httpInfo.getAddress().publishAddress();
-                table.addCell(NetworkAddress.format(transportAddress.address()));
-            } else {
-                table.addCell("-");
-            }
+            table.addCell(node.getTransportAddress());
+            table.addCell(info == null ? null : info.getAddress());
+            // final ProtobufHttpInfo httpInfo = info == null ? null : info.getInfo(ProtobufHttpInfo.class);
+            // if (httpInfo != null) {
+            //     TransportAddress transportAddress = httpInfo.getAddress().publishAddress();
+            //     table.addCell(NetworkAddress.format(transportAddress.address()));
+            // } else {
+            //     table.addCell("-");
+            // }
 
             table.addCell(node.getVersion().toString());
-            table.addCell(info == null ? null : info.getBuild().type().displayName());
-            table.addCell(info == null ? null : info.getBuild().hash());
-            table.addCell(jvmInfo == null ? null : jvmInfo.version());
-
-            ByteSizeValue diskTotal = null;
-            ByteSizeValue diskUsed = null;
-            ByteSizeValue diskAvailable = null;
-            String diskUsedPercent = null;
-            if (fsInfo != null) {
-                diskTotal = fsInfo.getTotal().getTotal();
-                diskAvailable = fsInfo.getTotal().getAvailable();
-                diskUsed = new ByteSizeValue(diskTotal.getBytes() - diskAvailable.getBytes());
-
-                double diskUsedRatio = diskTotal.getBytes() == 0 ? 1.0 : (double) diskUsed.getBytes() / diskTotal.getBytes();
-                diskUsedPercent = String.format(Locale.ROOT, "%.2f", 100.0 * diskUsedRatio);
-            }
+            table.addCell(info == null ? null : info.getDisplayName());
+            table.addCell(info == null ? null : info.getHash());
+            table.addCell(info == null ? null : info.getJvmInfoVersion());
+
+            ByteSizeValue diskTotal = new ByteSizeValue(stats.getDiskTotal());
+            ByteSizeValue diskAvailable = new ByteSizeValue(stats.getDiskAvailable());
+            ByteSizeValue diskUsed = new ByteSizeValue(diskTotal.getBytes() - diskAvailable.getBytes());
+            double diskUsedRatio = diskTotal.getBytes() == 0 ? 1.0 : (double) diskUsed.getBytes() / diskTotal.getBytes();
+            String diskUsedPercent = String.format(Locale.ROOT, "%.2f", 100.0 * diskUsedRatio);
+            
+            // String diskUsedPercent = null;
+            // if (fsInfo != null) {
+            //     diskTotal = stats.getDiskTotal();
+            //     diskAvailable = fsInfo.getTotal().getAvailable();
+            //     diskUsed = new ByteSizeValue(diskTotal.getBytes() - diskAvailable.getBytes());
+
+            //     double diskUsedRatio = diskTotal.getBytes() == 0 ? 1.0 : (double) diskUsed.getBytes() / diskTotal.getBytes();
+            //     diskUsedPercent = String.format(Locale.ROOT, "%.2f", 100.0 * diskUsedRatio);
+            // }
             table.addCell(diskTotal);
             table.addCell(diskUsed);
             table.addCell(diskAvailable);
             table.addCell(diskUsedPercent);
 
-            table.addCell(jvmStats == null ? null : jvmStats.getMem().getHeapUsed());
-            table.addCell(jvmStats == null ? null : jvmStats.getMem().getHeapUsedPercent());
-            table.addCell(jvmInfo == null ? null : jvmInfo.getMem().getHeapMax());
-            table.addCell(osStats == null ? null : osStats.getMem() == null ? null : osStats.getMem().getUsed());
-            table.addCell(osStats == null ? null : osStats.getMem() == null ? null : osStats.getMem().getUsedPercent());
-            table.addCell(osStats == null ? null : osStats.getMem() == null ? null : osStats.getMem().getTotal());
-            table.addCell(processStats == null ? null : processStats.getOpenFileDescriptors());
-            table.addCell(
-                processStats == null
-                    ? null
-                    : calculatePercentage(processStats.getOpenFileDescriptors(), processStats.getMaxFileDescriptors())
-            );
-            table.addCell(processStats == null ? null : processStats.getMaxFileDescriptors());
-
-            table.addCell(osStats == null ? null : Short.toString(osStats.getCpu().getPercent()));
-            boolean hasLoadAverage = osStats != null && osStats.getCpu().getLoadAverage() != null;
+            table.addCell(new ByteSizeValue(stats.getJvmHeapUsed()));
+            table.addCell(stats.getJvmHeapUsedPercent());
+            table.addCell(info.getJvmHeapMax());
+            table.addCell(new ByteSizeValue(stats.getOsMemUsed()));
+            table.addCell(stats.getOsMemUsedPercent());
+            table.addCell(new ByteSizeValue(stats.getOsMemTotal()));
+            table.addCell(stats.getProcessOpenFileDescriptors());
+            table.addCell(calculatePercentage(stats.getProcessOpenFileDescriptors(), stats.getProcessMaxFileDescriptors()));
+            table.addCell(stats.getProcessMaxFileDescriptors());
+
+            table.addCell(stats.getOsCpuPercent());
+            boolean hasLoadAverage = stats.getOsCpuLoadAverageList() != null;
             table.addCell(
-                !hasLoadAverage || osStats.getCpu().getLoadAverage()[0] == -1
+                !hasLoadAverage || stats.getOsCpuLoadAverage(0) == -1
                     ? null
-                    : String.format(Locale.ROOT, "%.2f", osStats.getCpu().getLoadAverage()[0])
+                    : String.format(Locale.ROOT, "%.2f", stats.getOsCpuLoadAverage(0))
             );
             table.addCell(
-                !hasLoadAverage || osStats.getCpu().getLoadAverage()[1] == -1
+                !hasLoadAverage || stats.getOsCpuLoadAverage(1) == -1
                     ? null
-                    : String.format(Locale.ROOT, "%.2f", osStats.getCpu().getLoadAverage()[1])
+                    : String.format(Locale.ROOT, "%.2f", stats.getOsCpuLoadAverage(1))
             );
             table.addCell(
-                !hasLoadAverage || osStats.getCpu().getLoadAverage()[2] == -1
+                !hasLoadAverage || stats.getOsCpuLoadAverage(2) == -1
                     ? null
-                    : String.format(Locale.ROOT, "%.2f", osStats.getCpu().getLoadAverage()[2])
+                    : String.format(Locale.ROOT, "%.2f", stats.getOsCpuLoadAverage(2))
             );
-            table.addCell(jvmStats == null ? null : jvmStats.getUptime());
+            table.addCell(new TimeValue(stats.getJvmUpTime()));
 
             final String roles;
             final String allRoles;
-            if (node.getRoles().isEmpty()) {
+            if (node.getRolesList().isEmpty()) {
                 roles = "-";
                 allRoles = "-";
             } else {
-                List<DiscoveryNodeRole> knownNodeRoles = node.getRoles()
+                List<ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole> knownNodeRoles = node.getRolesList()
                     .stream()
-                    .filter(DiscoveryNodeRole::isKnownRole)
+                    .filter(ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole::getIsKnownRole)
                     .collect(Collectors.toList());
                 roles = knownNodeRoles.size() > 0
-                    ? knownNodeRoles.stream().map(DiscoveryNodeRole::roleNameAbbreviation).sorted().collect(Collectors.joining())
+                    ? knownNodeRoles.stream().map(ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole::getRoleNameAbbreviation).sorted().collect(Collectors.joining())
                     : "-";
-                allRoles = node.getRoles().stream().map(DiscoveryNodeRole::roleName).sorted().collect(Collectors.joining(","));
+                allRoles = node.getRolesList().stream().map(ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole::getRoleName).sorted().collect(Collectors.joining(","));
             }
             table.addCell(roles);
             table.addCell(allRoles);
-            table.addCell(clusterManagerId == null ? "x" : clusterManagerId.equals(node.getId()) ? "*" : "-");
-            table.addCell(node.getName());
+            table.addCell(clusterManagerId == null ? "x" : clusterManagerId.equals(node.getNodeId()) ? "*" : "-");
+            table.addCell(node.getNodeName());
 
-            ProtobufCompletionStats completionStats = indicesStats == null ? null : stats.getIndices().getCompletion();
-            table.addCell(completionStats == null ? null : completionStats.getSize());
+            // ProtobufCompletionStats completionStats = indicesStats == null ? null : stats.getIndices().getCompletion();
+            table.addCell(stats.getCompletionStats() == null ? null : stats.getCompletionStats().getSize());
 
-            ProtobufFieldDataStats fdStats = indicesStats == null ? null : stats.getIndices().getFieldData();
-            table.addCell(fdStats == null ? null : fdStats.getMemorySize());
-            table.addCell(fdStats == null ? null : fdStats.getEvictions());
+            // ProtobufFieldDataStats fdStats = indicesStats == null ? null : stats.getIndices().getFieldData();
+            table.addCell(stats.getFieldDataStats() == null ? null : stats.getFieldDataStats().getMemSize());
+            table.addCell(stats.getFieldDataStats() == null ? null : stats.getFieldDataStats().getEvictions());
 
-            ProtobufQueryCacheStats fcStats = indicesStats == null ? null : indicesStats.getQueryCache();
-            table.addCell(fcStats == null ? null : fcStats.getMemorySize());
-            table.addCell(fcStats == null ? null : fcStats.getEvictions());
+            QueryCacheStats fcStats = stats.getQueryCacheStats() == null ? null : stats.getQueryCacheStats();
+            table.addCell(fcStats == null ? null : new ByteSizeValue(fcStats.getRamBytesUsed()));
+            table.addCell(fcStats == null ? null : fcStats.getCacheCount() - fcStats.getCacheSize());
             table.addCell(fcStats == null ? null : fcStats.getHitCount());
             table.addCell(fcStats == null ? null : fcStats.getMissCount());
 
-            ProtobufRequestCacheStats qcStats = indicesStats == null ? null : indicesStats.getRequestCache();
-            table.addCell(qcStats == null ? null : qcStats.getMemorySize());
+            RequestCacheStats qcStats = stats.getRequestCacheStats() == null ? null : stats.getRequestCacheStats();
+            table.addCell(qcStats == null ? null : new ByteSizeValue(qcStats.getMemorySize()));
             table.addCell(qcStats == null ? null : qcStats.getEvictions());
             table.addCell(qcStats == null ? null : qcStats.getHitCount());
             table.addCell(qcStats == null ? null : qcStats.getMissCount());
 
-            ProtobufFlushStats flushStats = indicesStats == null ? null : indicesStats.getFlush();
+            FlushStats flushStats = stats.getFlushStats() == null ? null : stats.getFlushStats();
             table.addCell(flushStats == null ? null : flushStats.getTotal());
-            table.addCell(flushStats == null ? null : flushStats.getTotalTime());
+            table.addCell(flushStats == null ? null : flushStats.getTotalTimeInMillis());
 
-            ProtobufGetStats getStats = indicesStats == null ? null : indicesStats.getGet();
-            table.addCell(getStats == null ? null : getStats.current());
-            table.addCell(getStats == null ? null : getStats.getTime());
+            GetStats getStats = stats.getGetStats() == null ? null : stats.getGetStats();
+            table.addCell(getStats == null ? null : getStats.getCurrent());
+            table.addCell(getStats == null ? null : new TimeValue(getStats.getTime()));
             table.addCell(getStats == null ? null : getStats.getCount());
-            table.addCell(getStats == null ? null : getStats.getExistsTime());
+            table.addCell(getStats == null ? null : new TimeValue(getStats.getExistsTimeInMillis()));
             table.addCell(getStats == null ? null : getStats.getExistsCount());
-            table.addCell(getStats == null ? null : getStats.getMissingTime());
+            table.addCell(getStats == null ? null : new TimeValue(getStats.getMissingTimeInMillis()));
             table.addCell(getStats == null ? null : getStats.getMissingCount());
 
-            ProtobufIndexingStats indexingStats = indicesStats == null ? null : indicesStats.getIndexing();
-            table.addCell(indexingStats == null ? null : indexingStats.getTotal().getDeleteCurrent());
-            table.addCell(indexingStats == null ? null : indexingStats.getTotal().getDeleteTime());
-            table.addCell(indexingStats == null ? null : indexingStats.getTotal().getDeleteCount());
-            table.addCell(indexingStats == null ? null : indexingStats.getTotal().getIndexCurrent());
-            table.addCell(indexingStats == null ? null : indexingStats.getTotal().getIndexTime());
-            table.addCell(indexingStats == null ? null : indexingStats.getTotal().getIndexCount());
-            table.addCell(indexingStats == null ? null : indexingStats.getTotal().getIndexFailedCount());
+            IndexingStats indexingStats = stats.getIndexingStats() == null ? null : stats.getIndexingStats();
+            table.addCell(indexingStats == null ? null : indexingStats.getDeleteCurrent());
+            table.addCell(indexingStats == null ? null : new TimeValue(indexingStats.getDeleteTimeInMillis()));
+            table.addCell(indexingStats == null ? null : indexingStats.getDeleteCount());
+            table.addCell(indexingStats == null ? null : indexingStats.getIndexCurrent());
+            table.addCell(indexingStats == null ? null : new TimeValue(indexingStats.getIndexTimeInMillis()));
+            table.addCell(indexingStats == null ? null : indexingStats.getIndexCount());
+            table.addCell(indexingStats == null ? null : indexingStats.getIndexFailedCount());
 
-            ProtobufMergeStats mergeStats = indicesStats == null ? null : indicesStats.getMerge();
+            MergeStats mergeStats = stats.getMergeStats() == null ? null : stats.getMergeStats();
             table.addCell(mergeStats == null ? null : mergeStats.getCurrent());
             table.addCell(mergeStats == null ? null : mergeStats.getCurrentNumDocs());
-            table.addCell(mergeStats == null ? null : mergeStats.getCurrentSize());
+            table.addCell(mergeStats == null ? null : new ByteSizeValue(mergeStats.getCurrentSizeInBytes()));
             table.addCell(mergeStats == null ? null : mergeStats.getTotal());
             table.addCell(mergeStats == null ? null : mergeStats.getTotalNumDocs());
-            table.addCell(mergeStats == null ? null : mergeStats.getTotalSize());
-            table.addCell(mergeStats == null ? null : mergeStats.getTotalTime());
+            table.addCell(mergeStats == null ? null : new ByteSizeValue(mergeStats.getTotalSizeInBytes()));
+            table.addCell(mergeStats == null ? null : new TimeValue(mergeStats.getTotalTimeInMillis()));
 
-            ProtobufRefreshStats refreshStats = indicesStats == null ? null : indicesStats.getRefresh();
+            RefreshStats refreshStats = stats.getRefreshStats() == null ? null : stats.getRefreshStats();
             table.addCell(refreshStats == null ? null : refreshStats.getTotal());
-            table.addCell(refreshStats == null ? null : refreshStats.getTotalTime());
+            table.addCell(refreshStats == null ? null : new TimeValue(refreshStats.getTotalTimeInMillis()));
             table.addCell(refreshStats == null ? null : refreshStats.getExternalTotal());
-            table.addCell(refreshStats == null ? null : refreshStats.getExternalTotalTime());
+            table.addCell(refreshStats == null ? null : new TimeValue(refreshStats.getExternalTotalTimeInMillis()));
             table.addCell(refreshStats == null ? null : refreshStats.getListeners());
 
-            ProtobufScriptStats scriptStats = stats == null ? null : stats.getScriptStats();
+            ScriptStats scriptStats = stats == null ? null : stats.getScriptStats();
             table.addCell(scriptStats == null ? null : scriptStats.getCompilations());
             table.addCell(scriptStats == null ? null : scriptStats.getCacheEvictions());
             table.addCell(scriptStats == null ? null : scriptStats.getCompilationLimitTriggered());
 
-            ProtobufSearchStats searchStats = indicesStats == null ? null : indicesStats.getSearch();
-            table.addCell(searchStats == null ? null : searchStats.getTotal().getFetchCurrent());
-            table.addCell(searchStats == null ? null : searchStats.getTotal().getFetchTime());
-            table.addCell(searchStats == null ? null : searchStats.getTotal().getFetchCount());
+            SearchStats searchStats = stats.getSearchStats() == null ? null : stats.getSearchStats();
+            table.addCell(searchStats == null ? null : searchStats.getFetchCurrent());
+            table.addCell(searchStats == null ? null : new TimeValue(searchStats.getFetchTimeInMillis()));
+            table.addCell(searchStats == null ? null : searchStats.getFetchCount());
             table.addCell(searchStats == null ? null : searchStats.getOpenContexts());
-            table.addCell(searchStats == null ? null : searchStats.getTotal().getQueryCurrent());
-            table.addCell(searchStats == null ? null : searchStats.getTotal().getQueryTime());
-            table.addCell(searchStats == null ? null : searchStats.getTotal().getQueryCount());
-            table.addCell(searchStats == null ? null : searchStats.getTotal().getScrollCurrent());
-            table.addCell(searchStats == null ? null : searchStats.getTotal().getScrollTime());
-            table.addCell(searchStats == null ? null : searchStats.getTotal().getScrollCount());
-            table.addCell(searchStats == null ? null : searchStats.getTotal().getPitCurrent());
-            table.addCell(searchStats == null ? null : searchStats.getTotal().getPitTime());
-            table.addCell(searchStats == null ? null : searchStats.getTotal().getPitCount());
-
-            ProtobufSegmentsStats segmentsStats = indicesStats == null ? null : indicesStats.getSegments();
+            table.addCell(searchStats == null ? null : searchStats.getQueryCurrent());
+            table.addCell(searchStats == null ? null : new TimeValue(searchStats.getQueryTimeInMillis()));
+            table.addCell(searchStats == null ? null : searchStats.getQueryCount());
+            table.addCell(searchStats == null ? null : searchStats.getScrollCurrent());
+            table.addCell(searchStats == null ? null : new TimeValue(searchStats.getScrollTimeInMillis()));
+            table.addCell(searchStats == null ? null : searchStats.getScrollCount());
+            table.addCell(searchStats == null ? null : searchStats.getPitCurrent());
+            table.addCell(searchStats == null ? null : new TimeValue(searchStats.getPitTimeInMillis()));
+            table.addCell(searchStats == null ? null : searchStats.getPitCount());
+
+            SegmentStats segmentsStats = stats.getSegmentStats() == null ? null : stats.getSegmentStats();
             table.addCell(segmentsStats == null ? null : segmentsStats.getCount());
-            table.addCell(segmentsStats == null ? null : segmentsStats.getZeroMemory());
-            table.addCell(segmentsStats == null ? null : segmentsStats.getIndexWriterMemory());
-            table.addCell(segmentsStats == null ? null : segmentsStats.getVersionMapMemory());
-            table.addCell(segmentsStats == null ? null : segmentsStats.getBitsetMemory());
-
-            table.addCell(searchStats == null ? null : searchStats.getTotal().getSuggestCurrent());
-            table.addCell(searchStats == null ? null : searchStats.getTotal().getSuggestTime());
-            table.addCell(searchStats == null ? null : searchStats.getTotal().getSuggestCount());
+            table.addCell(segmentsStats == null ? null : new ByteSizeValue(0L));
+            table.addCell(segmentsStats == null ? null : new ByteSizeValue(segmentsStats.getIndexWriterMemoryInBytes()));
+            table.addCell(segmentsStats == null ? null : new ByteSizeValue(segmentsStats.getVersionMapMemoryInBytes()));
+            table.addCell(segmentsStats == null ? null : new ByteSizeValue(segmentsStats.getBitsetMemoryInBytes()));
+
+            table.addCell(searchStats == null ? null : searchStats.getSuggestCurrent());
+            table.addCell(searchStats == null ? null : new TimeValue(searchStats.getSuggestTimeInMillis()));
+            table.addCell(searchStats == null ? null : searchStats.getSuggestCount());
 
             table.endRow();
         }
diff --git a/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java b/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java
index a6aaef912043b..9acfe10ee6bbf 100644
--- a/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java
+++ b/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java
@@ -616,6 +616,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                         // TODO Auto-generated method stub
                         throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                     }
+
+                    @Override
+                    public UpdateIndexShardSnapshotStatusResponse read(byte[] in) throws IOException {
+                        // TODO Auto-generated method stub
+                        throw new UnsupportedOperationException("Unimplemented method 'read'");
+                    }
                 }
             )
         );
diff --git a/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java
index 6cfc73d9eb0b5..9c5a1c8cc98dc 100644
--- a/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java
+++ b/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java
@@ -82,4 +82,10 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
         // TODO Auto-generated method stub
         throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
     }
+
+    @Override
+    public Empty read(byte[] in) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'read'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/transport/InboundHandler.java b/server/src/main/java/org/opensearch/transport/InboundHandler.java
index fb7f83e487eb6..acc47fa0d2afa 100644
--- a/server/src/main/java/org/opensearch/transport/InboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/InboundHandler.java
@@ -37,6 +37,14 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.apache.lucene.util.BytesRef;
 import org.opensearch.Version;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodeInfo;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequest;
+import org.opensearch.action.admin.cluster.node.info.ProtobufTransportNodesInfoAction.NodeInfoRequest;
+import org.opensearch.action.admin.cluster.node.stats.ProtobufNodeStats;
+import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsRequest;
+import org.opensearch.action.admin.cluster.node.stats.ProtobufTransportNodesStatsAction.NodeStatsRequest;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
 import org.opensearch.common.bytes.BytesReference;
 import org.opensearch.common.bytes.ReleasableBytesReference;
 import org.opensearch.common.collect.Tuple;
@@ -45,10 +53,18 @@
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.server.proto.ClusterStateRequestProto.ClusterStateReq;
+import org.opensearch.server.proto.ClusterStateResponseProto.ClusterStateRes;
+import org.opensearch.server.proto.NodesInfoProto.NodesInfo;
+import org.opensearch.server.proto.NodesInfoRequestProto.NodesInfoReq;
+import org.opensearch.server.proto.NodesStatsProto.NodesStats;
+import org.opensearch.server.proto.NodesStatsRequestProto.NodesStatsReq;
+import org.opensearch.server.proto.OutboundMessageProto.OutboundMsg;
 import org.opensearch.threadpool.ThreadPool;
 
 import com.google.protobuf.CodedInputStream;
@@ -60,6 +76,7 @@
 import java.nio.ByteBuffer;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 /**
  * Handler for inbound data
@@ -138,7 +155,7 @@ void inboundMessage(TcpChannel channel, InboundMessage message) throws Exception
         }
     }
 
-    void inboundMessageProtobuf(TcpChannel channel, BytesReference message) throws InvalidProtocolBufferException {
+    void inboundMessageProtobuf(TcpChannel channel, BytesReference message) throws IOException {
         System.out.println("InboundHandler.inboundMessageProtobuf");
         System.out.println("message: " + message);
         final long startTime = threadPool.relativeTimeInMillis();
@@ -152,10 +169,10 @@ void inboundMessageProtobuf(TcpChannel channel, BytesReference message) throws I
 
     private static final CodedInputStream EMPTY_CODED_INPUT_STREAM = CodedInputStream.newInstance(BytesRef.EMPTY_BYTES);
 
-    private void messageReceivedProtobuf(TcpChannel channel, ProtobufOutboundMessage message, long startTime) {
+    private void messageReceivedProtobuf(TcpChannel channel, ProtobufOutboundMessage message, long startTime) throws IOException {
         System.out.println("InboundHandler.messageReceivedProtobuf");
         final InetSocketAddress remoteAddress = channel.getRemoteAddress();
-        final org.opensearch.example.proto.OutboundMessageProto.OutboundMsg.Header header = message.getHeader();
+        final org.opensearch.server.proto.OutboundMessageProto.OutboundMsg.Header header = message.getHeader();
         System.out.println("header: " + header);
         System.out.println("message: " + message);
         System.out.println("remoteAddress: " + remoteAddress);
@@ -170,8 +187,24 @@ private void messageReceivedProtobuf(TcpChannel channel, ProtobufOutboundMessage
                 System.out.println("InboundHandler.messageReceivedProtobuf isRequest");
                 System.out.println("Header: " + header);
                 System.out.println("message: " + message);
+                handleRequestProtobuf(channel, header, message);
             } else {
                 System.out.println("InboundHandler.messageReceivedProtobuf isResponse");
+                long requestId = header.getRequestId();
+                TransportResponseHandler<? extends TransportResponse> handler = responseHandlers.onResponseReceived(
+                    requestId,
+                    messageListener
+                );
+                System.out.println("Found the handler: " + handler);
+                if (handler != null) {
+                    System.out.println("Handler for the response is: " + handler);
+                    System.out.println("Handler for the response is: " + handler.toString());
+                    System.out.println("The final message is: " + message);
+                    if (handler.toString().contains("Protobuf")) {
+                        System.out.println("Trying protobuf");
+                        handleProtobufResponse(requestId, remoteAddress, message, handler);
+                    }
+                }
             }
         } finally {
             final long took = threadPool.relativeTimeInMillis() - startTime;
@@ -286,6 +319,104 @@ private void messageReceived(TcpChannel channel, InboundMessage message, long st
         }
     }
 
+    private <T extends TransportRequest> void handleRequestProtobuf(TcpChannel channel, org.opensearch.server.proto.OutboundMessageProto.OutboundMsg.Header header, ProtobufOutboundMessage message) throws IOException {
+        OutboundMsg outboundMsg = message.getMessage();
+        final String action = outboundMsg.getAction();
+        final long requestId = header.getRequestId();
+        final Version version = Version.fromString(outboundMsg.getVersion());
+        System.out.println("InboundHandler.handleRequestProtobuf");
+        System.out.println("Header: " + header);
+        System.out.println("Action: " + action);
+        System.out.println("RequestId: " + requestId);
+        System.out.println("Version: " + version);
+        System.out.println("Message: " + outboundMsg);
+        final TransportChannel transportChannel = new TcpTransportChannel(
+            outboundHandler,
+            channel,
+            action,
+            requestId,
+            version,
+            outboundMsg.getFeaturesList().stream().map(String::valueOf).collect(Collectors.toSet()),
+            false,
+            false,
+            () -> {}
+        );
+        try {
+            messageListener.onRequestReceived(requestId, action);
+            final ProtobufRequestHandlerRegistry<T> reg = protobufRequestHandlers.getHandler(action);
+            assert reg != null;
+            if (outboundMsg.hasClusterStateReq()) {
+                System.out.println("InboundHandler.handleRequestProtobuf hasClusterStateReq");
+                final ClusterStateReq clusterStateReq = outboundMsg.getClusterStateReq();
+                System.out.println("ClusterStateReq: " + clusterStateReq);
+                ProtobufClusterStateRequest protobufClusterStateRequest = new ProtobufClusterStateRequest(clusterStateReq.toByteArray());
+                final T request = (T) protobufClusterStateRequest;
+                request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
+                System.out.println("Transport request: " + request);
+                final String executor = reg.getExecutor();
+                if (ThreadPool.Names.SAME.equals(executor)) {
+                    try {
+                        reg.processMessageReceived(request, transportChannel);
+                    } catch (Exception e) {
+                        sendErrorResponse(reg.getAction(), transportChannel, e);
+                    }
+                } else {
+                    threadPool.executor(executor).execute(new ProtobufRequestHandler<>(reg, request, transportChannel));
+                }
+            } else if (outboundMsg.hasNodesInfoReq()) {
+                System.out.println("InboundHandler.handleRequestProtobuf hasNodesInfoReq");
+                final NodesInfoReq nodesInfoReq = outboundMsg.getNodesInfoReq();
+                System.out.println("NodesInfoReq: " + nodesInfoReq);
+                try {
+                    ProtobufNodesInfoRequest protobufNodesInfoRequest = new ProtobufNodesInfoRequest(nodesInfoReq.toByteArray());
+                    System.out.println("Converted node info request: " + protobufNodesInfoRequest);
+                    final T request = (T) new NodeInfoRequest(protobufNodesInfoRequest);
+                    request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
+                    System.out.println("Transport request: " + request);
+                    final String executor = reg.getExecutor();
+                    if (ThreadPool.Names.SAME.equals(executor)) {
+                        try {
+                            reg.processMessageReceived(request, transportChannel);
+                        } catch (Exception e) {
+                            sendErrorResponse(reg.getAction(), transportChannel, e);
+                        }
+                    } else {
+                        System.out.println("In else condition for thread pool");
+                        threadPool.executor(executor).execute(new ProtobufRequestHandler<>(reg, request, transportChannel));
+                    }
+                } catch (Exception e) {
+                    System.out.println("Exception: " + e);
+                }             
+            } else if (outboundMsg.hasNodesStatsReq()) {
+                System.out.println("InboundHandler.handleRequestProtobuf hasNodesStatsReq");
+                final NodesStatsReq nodesStatsReq = outboundMsg.getNodesStatsReq();
+                System.out.println("NodesStatsReq: " + nodesStatsReq);
+                try {
+                    ProtobufNodesStatsRequest protobufNodesStatsRequest = new ProtobufNodesStatsRequest(nodesStatsReq.toByteArray());
+                    System.out.println("Converted node stats request: " + protobufNodesStatsRequest);
+                    final T request = (T) new NodeStatsRequest(protobufNodesStatsRequest);
+                    request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
+                    System.out.println("Transport request: " + request);
+                    final String executor = reg.getExecutor();
+                    if (ThreadPool.Names.SAME.equals(executor)) {
+                        try {
+                            reg.processMessageReceived(request, transportChannel);
+                        } catch (Exception e) {
+                            sendErrorResponse(reg.getAction(), transportChannel, e);
+                        }
+                    } else {
+                        System.out.println("In else condition for thread pool");
+                        threadPool.executor(executor).execute(new ProtobufRequestHandler<>(reg, request, transportChannel));
+                    }
+                } catch (Exception e) {
+                    System.out.println("Exception: " + e);
+                }             
+            }
+        } catch (Exception e) {
+            sendErrorResponse(action, transportChannel, e);
+        }
+    }
+
     private <T extends TransportRequest> void handleRequest(TcpChannel channel, Header header, InboundMessage message) throws IOException {
         final String action = header.getActionName();
         final long requestId = header.getRequestId();
@@ -368,6 +499,7 @@ private <T extends TransportRequest> void handleRequest(TcpChannel channel, Head
                                 sendErrorResponse(reg.getAction(), transportChannel, e);
                             }
                         } else {
+                            System.out.println("In else condition for thread pool normal");
                             threadPool.executor(executor).execute(new RequestHandler<>(reg, request, transportChannel));
                         }
                     } catch (Exception e) {
@@ -554,6 +686,72 @@ private <T extends TransportResponse> void handleResponse(
         }
     }
 
+    private <T extends TransportResponse> void handleProtobufResponse(
+        final long requestId,
+        InetSocketAddress remoteAddress,
+        final ProtobufOutboundMessage message,
+        final TransportResponseHandler<T> handler
+    ) throws IOException {
+        System.out.println("handleProtobufResponse");
+        try {
+            OutboundMsg outboundMsg = message.getMessage();
+            if (outboundMsg.hasClusterStateRes()) {
+                System.out.println("InboundHandler.handleProtobufResponse hasClusterStateRes");
+                final ClusterStateRes clusterStateRes = outboundMsg.getClusterStateRes();
+                System.out.println("ClusterStateRes: " + clusterStateRes);
+                ProtobufClusterStateResponse protobufClusterStateResponse = new ProtobufClusterStateResponse(clusterStateRes.toByteArray());
+                final T response = (T) protobufClusterStateResponse;
+                response.remoteAddress(new TransportAddress(remoteAddress));
+                System.out.println("Transport response: " + response);
+
+                final String executor = handler.executor();
+                if (ThreadPool.Names.SAME.equals(executor)) {
+                    doHandleResponse(handler, response);
+                } else {
+                    threadPool.executor(executor).execute(() -> doHandleResponse(handler, response));
+                }
+            } else if (outboundMsg.hasNodesInfoRes()) {
+                System.out.println("InboundHandler.handleProtobufResponse hasNodesInfoRes");
+                final NodesInfo nodesInfoRes = outboundMsg.getNodesInfoRes();
+                System.out.println("NodesInfoRes: " + nodesInfoRes);
+                ProtobufNodeInfo protobufNodeInfo = new ProtobufNodeInfo(nodesInfoRes.toByteArray());
+                final T response = (T) protobufNodeInfo;
+                response.remoteAddress(new TransportAddress(remoteAddress));
+                System.out.println("Transport nodes response: " + response);
+
+                final String executor = handler.executor();
+                if (ThreadPool.Names.SAME.equals(executor)) {
+                    doHandleResponse(handler, response);
+                } else {
+                    threadPool.executor(executor).execute(() -> doHandleResponse(handler, response));
+                }
+            } else if (outboundMsg.hasNodesStatsRes()) {
+                System.out.println("InboundHandler.handleProtobufResponse hasNodesStatsRes");
+                final NodesStats nodesStatsRes = outboundMsg.getNodesStatsRes();
+                System.out.println("NodesStatsRes: " + nodesStatsRes);
+                ProtobufNodeStats protobufNodeStats = new ProtobufNodeStats(nodesStatsRes.toByteArray());
+                final T response = (T) protobufNodeStats;
+                response.remoteAddress(new TransportAddress(remoteAddress));
+                System.out.println("Transport nodes stats response: " + response);
+
+                final String executor = handler.executor();
+                if (ThreadPool.Names.SAME.equals(executor)) {
+                    doHandleResponse(handler, response);
+                } else {
+                    threadPool.executor(executor).execute(() -> doHandleResponse(handler, response));
+                }
+            }
+        } catch (Exception e) {
+            final Exception serializationException = new TransportSerializationException(
+                "Failed to deserialize response from handler [" + handler + "]",
+                e
+            );
+            logger.warn(new ParameterizedMessage("Failed to deserialize response from [{}]", remoteAddress), serializationException);
+            handleException(handler, serializationException);
+            return;
+        }
+    }
+
     private <T extends TransportResponse> void handleResponseProtobuf(
         final long requestId,
         InetSocketAddress remoteAddress,
@@ -675,4 +873,36 @@ public void onFailure(Exception e) {
             sendErrorResponse(reg.getAction(), transportChannel, e);
         }
     }
+
+    /**
+     * Internal request handler
+     *
+     * @opensearch.internal
+     */
+    private static class ProtobufRequestHandler<T extends TransportRequest> extends AbstractRunnable {
+        private final ProtobufRequestHandlerRegistry<T> reg;
+        private final T request;
+        private final TransportChannel transportChannel;
+
+        ProtobufRequestHandler(ProtobufRequestHandlerRegistry<T> reg, T request, TransportChannel transportChannel) {
+            this.reg = reg;
+            this.request = request;
+            this.transportChannel = transportChannel;
+        }
+
+        @Override
+        protected void doRun() throws Exception {
+            reg.processMessageReceived(request, transportChannel);
+        }
+
+        @Override
+        public boolean isForceExecution() {
+            return reg.isForceExecution();
+        }
+
+        @Override
+        public void onFailure(Exception e) {
+            sendErrorResponse(reg.getAction(), transportChannel, e);
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/transport/InboundPipeline.java b/server/src/main/java/org/opensearch/transport/InboundPipeline.java
index c770d8a8b8208..dde4ecaa54ed4 100644
--- a/server/src/main/java/org/opensearch/transport/InboundPipeline.java
+++ b/server/src/main/java/org/opensearch/transport/InboundPipeline.java
@@ -117,10 +117,10 @@ public void close() {
     public void handleBytes(TcpChannel channel, ReleasableBytesReference reference) throws IOException {
         System.out.println("Handle bytes in InboundPipeline");
         System.out.println("Incoming bytes length: " + reference.length());
-        System.out.println("Now the incoming bytes: ");
-        for (int i = 0; i < reference.length(); i++) {
-            System.out.print(reference.get(i) + " ");
-        }
+        // System.out.println("Now the incoming bytes: ");
+        // for (int i = 0; i < reference.length(); i++) {
+        //     System.out.print(reference.get(i) + " ");
+        // }
         System.out.println();
         if (uncaughtException != null) {
             throw new IllegalStateException("Pipeline state corrupted by uncaught exception", uncaughtException);
@@ -139,9 +139,9 @@ public void doHandleBytes(TcpChannel channel, ReleasableBytesReference reference
             System.out.println("Size of incoming bytes: " + incomingBytes.length);
             ProtobufOutboundMessage protobufOutboundMessage = new ProtobufOutboundMessage(incomingBytes);
             if (protobufOutboundMessage.isProtobuf()) {
-                for (int i = 0; i < incomingBytes.length; i++) {
-                    System.out.println("Byte " + i + " is: " + incomingBytes[i]);
-                }
+                // for (int i = 0; i < incomingBytes.length; i++) {
+                //     System.out.println("Byte " + i + " is: " + incomingBytes[i]);
+                // }
                 System.out.println("Last byte is 1");
                 forwardFragmentsProtobuf(channel, reference);
                 // byte[] newBytes = Arrays.copyOfRange(incomingBytes, 0, incomingBytes.length-1);
diff --git a/server/src/main/java/org/opensearch/transport/OutboundHandler.java b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
index 90e6908382968..5465c43601588 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
@@ -38,6 +38,14 @@
 import org.opensearch.Version;
 import org.opensearch.action.ActionListener;
 import org.opensearch.action.NotifyOnceListener;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodeInfo;
+import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequest;
+import org.opensearch.action.admin.cluster.node.info.ProtobufTransportNodesInfoAction.NodeInfoRequest;
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
+import org.opensearch.action.admin.cluster.node.stats.ProtobufNodeStats;
+import org.opensearch.action.admin.cluster.node.stats.ProtobufTransportNodesStatsAction.NodeStatsRequest;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.CheckedSupplier;
 import org.opensearch.core.common.bytes.BytesReference;
@@ -47,19 +55,12 @@
 import org.opensearch.common.transport.NetworkExceptionHelper;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.util.BigArrays;
-import org.opensearch.common.util.ByteArray;
-import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.common.util.io.IOUtils;
-import org.opensearch.example.proto.ExampleProtoRequest;
-import org.opensearch.example.proto.ExampleRequestProto.ExampleRequest;
-import org.opensearch.example.proto.OutboundMessageProto.OutboundMsg;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.lease.Releasables;
 import org.opensearch.threadpool.ThreadPool;
 
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.Set;
@@ -80,7 +81,6 @@ final class OutboundHandler {
     private final ThreadPool threadPool;
     private final BigArrays bigArrays;
     private volatile TransportMessageListener messageListener = TransportMessageListener.NOOP_LISTENER;
-    // private volatile ProtobufTransportMessageListener protobufMessageListener = ProtobufTransportMessageListener.NOOP_LISTENER;
 
     OutboundHandler(
         String nodeName,
@@ -134,16 +134,6 @@ void sendRequest(
             isHandshake,
             compressRequest
         );
-        // ProtobufOutboundMessage.Request protobufMessage = new ProtobufOutboundMessage.Request(
-        //     threadPool.getThreadContext(),
-        //     features,
-        //     request,
-        //     version,
-        //     action,
-        //     requestId,
-        //     isHandshake,
-        //     compressRequest
-        // );
 
         System.out.println("OutboundHandler.sendRequest");
         System.out.println("node: " + node);
@@ -154,50 +144,58 @@ void sendRequest(
         System.out.println("canonical: " + request.getClass().getCanonicalName());
         System.out.println("message: " + message);
         ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onRequestSent(node, requestId, action, request, options));
-        if (request.getClass().getCanonicalName().contains("ClusterState") && request.getClass().getCanonicalName().contains("Protobuf")) {
-            ExampleProtoRequest exampleProtoRequest = new ExampleProtoRequest(1, "message");
-            sendProtobufRequest(node, channel, requestId, action, exampleProtoRequest, options, channelVersion, compressRequest, isHandshake);
+        if (request.getClass().getCanonicalName().contains("ProtobufClusterState")) {
+            // ExampleProtoRequest exampleProtoRequest = new ExampleProtoRequest(1, "message");
+            ProtobufClusterStateRequest protobufClusterStateRequest = (ProtobufClusterStateRequest) request;
+            byte[] bytes = new byte[1];
+            bytes[0] = 0;
+            ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufClusterStateRequest.request(), features, action);
+            sendProtobufMessage(channel, protobufMessage, listener);
+        } else if (request.getClass().getCanonicalName().contains("ProtobufTransportNodesInfo")) {
+            System.out.println("It is a nodes info request for protobuf");
+            NodeInfoRequest protobufNodesInfoRequest = (NodeInfoRequest) request;
+            byte[] bytes = new byte[1];
+            bytes[0] = 0;
+            ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufNodesInfoRequest.request().request(), features, action);
+            sendProtobufMessage(channel, protobufMessage, listener);
+        } else if (request.getClass().getCanonicalName().contains("ProtobufTransportNodesStats")) {
+            System.out.println("It is a nodes stats request for protobuf");
+            NodeStatsRequest protobufNodesStatsRequest = (NodeStatsRequest) request;
+            byte[] bytes = new byte[1];
+            bytes[0] = 0;
+            ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufNodesStatsRequest.request().request(), features, action);
+            sendProtobufMessage(channel, protobufMessage, listener);
         } else {
             sendMessage(channel, message, listener);
         }
-        // if (request.getClass().getCanonicalName().contains("Protobuf")) {
-        //     sendMessageProtobuf(channel, protobufMessage, listener);
-        // } else {
-            // sendMessage(channel, message, listener);
-        // }   
     }
 
-    void sendProtobufRequest(
-        final DiscoveryNode node,
-        final TcpChannel channel,
-        final long requestId,
-        final String action,
-        final ExampleProtoRequest request,
-        final TransportRequestOptions options,
-        final Version channelVersion,
-        final boolean compressRequest,
-        final boolean isHandshake
-    ) throws IOException, TransportException {
-        Version version = Version.min(this.version, channelVersion);
-
-        System.out.println("OutboundHandler.sendProtobufRequest");
-        System.out.println("node: " + node);
-        System.out.println("channel: " + channel);
-        System.out.println("requestId: " + requestId);
-        System.out.println("action: " + action);
-        System.out.println("request: " + request.toString());
-        System.out.println("canonical: " + request.getClass().getCanonicalName());
-        ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onRequestSent(node, requestId, action, request, options));
-        byte[] bytes = new byte[1];
-        bytes[0] = 0;
-        ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), request.request(), features, action);
-        sendProtobufMessage(channel, protobufMessage, listener);
-        // if (request.getClass().getCanonicalName().contains("Protobuf")) {
-        //     sendMessageProtobuf(channel, protobufMessage, listener);
-        // } else {
-            // sendMessage(channel, message, listener);
-        // }   
-    }
+    // void sendProtobufRequest(
+    //     final DiscoveryNode node,
+    //     final TcpChannel channel,
+    //     final long requestId,
+    //     final String action,
+    //     final TransportRequest request,
+    //     final TransportRequestOptions options,
+    //     final Version channelVersion,
+    //     final boolean compressRequest,
+    //     final boolean isHandshake
+    // ) throws IOException, TransportException {
+    //     Version version = Version.min(this.version, channelVersion);
+
+    //     System.out.println("OutboundHandler.sendProtobufRequest");
+    //     System.out.println("node: " + node);
+    //     System.out.println("channel: " + channel);
+    //     System.out.println("requestId: " + requestId);
+    //     System.out.println("action: " + action);
+    //     System.out.println("request: " + request.toString());
+    //     System.out.println("canonical: " + request.getClass().getCanonicalName());
+    //     ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onRequestSent(node, requestId, action, request, options));
+    //     byte[] bytes = new byte[1];
+    //     bytes[0] = 0;
+    //     ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), request.transportReq(), features, action);
+    //     sendProtobufMessage(channel, protobufMessage, listener);
+    // }
 
     /**
      * Sends the response to the given channel. This method should be used to send {@link TransportResponse}
@@ -230,7 +228,31 @@ void sendResponse(
         System.out.println("response: " + response);
         System.out.println("canonical: " + response.getClass().getCanonicalName());
         ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onResponseSent(requestId, action, response));
-        sendMessage(channel, message, listener);
+        if (response.getClass().getCanonicalName().contains("ProtobufClusterState")) {
+            // ExampleProtoRequest exampleProtoRequest = new ExampleProtoRequest(1, "message");
+            System.out.println("In sendReponse for protobuf");
+            ProtobufClusterStateResponse protobufClusterStateResponse = (ProtobufClusterStateResponse) response;
+            byte[] bytes = new byte[1];
+            bytes[0] = 1;
+            ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufClusterStateResponse.response(), features, action);
+            sendProtobufMessage(channel, protobufMessage, listener);
+        } else if (response.getClass().getCanonicalName().contains("ProtobufNodeInfo")) {
+            System.out.println("Sending response of type protobuf node info");
+            ProtobufNodeInfo protobufNodeInfo = (ProtobufNodeInfo) response;
+            byte[] bytes = new byte[1];
+            bytes[0] = 1;
+            ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufNodeInfo.response(), features, action);
+            sendProtobufMessage(channel, protobufMessage, listener);
+        } else if (response.getClass().getCanonicalName().contains("ProtobufNodeStats")) {
+            System.out.println("Sending response of type protobuf node stats");
+            ProtobufNodeStats protobufNodeStats = (ProtobufNodeStats) response;
+            byte[] bytes = new byte[1];
+            bytes[0] = 1;
+            ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufNodeStats.response(), features, action);
+            sendProtobufMessage(channel, protobufMessage, listener);
+        } else {
+            sendMessage(channel, message, listener);
+        }
     }
 
     /**
@@ -284,15 +306,6 @@ private void sendMessage1(TcpChannel channel, OutboundMessage networkMessage, Ac
         internalSend(channel, sendContext);
     }
 
-    // private void sendMessageProtobuf(TcpChannel channel, ProtobufOutboundMessage networkMessage, ActionListener<Void> listener) throws IOException {
-    //     System.out.println("OutboundHandler.sendMessageProtobuf");
-    //     System.out.println("OutboundHandler.sendMessageProtobuf networkMessage = " + networkMessage);
-    //     MessageSerializerProtobuf serializer = new MessageSerializerProtobuf(networkMessage, bigArrays);
-    //     SendContext sendContext = new SendContext(channel, serializer, listener, serializer);
-    //     System.out.println("attempting internal send for protobuf ");
-    //     internalSend(channel, sendContext);
-    // }
-
     private void internalSend(TcpChannel channel, SendContext sendContext) throws IOException {
         System.out.println("In internal send");
         System.out.println("channel: " + channel);
@@ -318,14 +331,6 @@ void setMessageListener(TransportMessageListener listener) {
         }
     }
 
-    // void setProtobufMessageListener(ProtobufTransportMessageListener listener) {
-    //     if (protobufMessageListener == ProtobufTransportMessageListener.NOOP_LISTENER) {
-    //         protobufMessageListener = listener;
-    //     } else {
-    //         throw new IllegalStateException("Cannot set message listener twice");
-    //     }
-    // }
-
     /**
      * Internal message serializer
      *
@@ -422,35 +427,6 @@ public void close() {
         }
     }
 
-    // /**
-    //  * Internal message serializer
-    //  *
-    //  * @opensearch.internal
-    //  */
-    // private static class MessageSerializerProtobuf implements CheckedSupplier<BytesReference, IOException>, Releasable {
-
-    //     private final ProtobufOutboundMessage message;
-    //     private final BigArrays bigArrays;
-    //     private volatile ReleasableBytesStreamOutput bytesStreamOutput;
-
-    //     private MessageSerializerProtobuf(ProtobufOutboundMessage message, BigArrays bigArrays) {
-    //         this.message = message;
-    //         this.bigArrays = bigArrays;
-    //     }
-
-    //     @Override
-    //     public BytesReference get() throws IOException {
-    //         System.out.println("OutboundHandler.MessageSerializer.get");
-    //         bytesStreamOutput = new ReleasableBytesStreamOutput(bigArrays);
-    //         return message.serialize(bytesStreamOutput);
-    //     }
-
-    //     @Override
-    //     public void close() {
-    //         IOUtils.closeWhileHandlingException(bytesStreamOutput);
-    //     }
-    // }
-
     private class SendContext extends NotifyOnceListener<Void> implements CheckedSupplier<BytesReference, IOException> {
 
         private final TcpChannel channel;
diff --git a/server/src/main/java/org/opensearch/transport/OutboundMessage.java b/server/src/main/java/org/opensearch/transport/OutboundMessage.java
index 7531d116f5a59..aa09d6c46ed5f 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundMessage.java
@@ -84,10 +84,10 @@ BytesReference serialize(BytesStreamOutput bytesStream) throws IOException {
         TcpHeader.writeHeader(bytesStream, requestId, status, version, contentSize, variableHeaderLength);
         System.out.println("Bytes serialized length: " + reference.length());
         System.out.println("Bytes serialized: " + reference);
-        System.out.println("Now the bytes: ");
-        for (int i = 0; i < reference.length(); i++) {
-            System.out.print(reference.get(i) + " ");
-        }
+        // System.out.println("Now the bytes: ");
+        // for (int i = 0; i < reference.length(); i++) {
+        //     System.out.print(reference.get(i) + " ");
+        // }
         System.out.println();
         return reference;
     }
diff --git a/server/src/main/java/org/opensearch/transport/PlainTransportFuture.java b/server/src/main/java/org/opensearch/transport/PlainTransportFuture.java
index be9678a391f79..6ac8565f0cf0a 100644
--- a/server/src/main/java/org/opensearch/transport/PlainTransportFuture.java
+++ b/server/src/main/java/org/opensearch/transport/PlainTransportFuture.java
@@ -138,4 +138,10 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
         // TODO Auto-generated method stub
         throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
     }
+
+    @Override
+    public V read(byte[] in) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'read'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java b/server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java
deleted file mode 100644
index 534d67f243a4f..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufClusterConnectionManager.java
+++ /dev/null
@@ -1,283 +0,0 @@
-// /*
-// * 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.
-// */
-
-// package org.opensearch.transport;
-
-// import org.apache.logging.log4j.LogManager;
-// import org.apache.logging.log4j.Logger;
-// import org.opensearch.action.ActionListener;
-// import org.opensearch.cluster.node.DiscoveryNode;
-// import org.opensearch.common.settings.Settings;
-// import org.opensearch.common.util.concurrent.AbstractRefCounted;
-// import org.opensearch.common.util.concurrent.ConcurrentCollections;
-// import org.opensearch.common.util.concurrent.OpenSearchExecutors;
-// import org.opensearch.common.util.concurrent.ListenableFuture;
-// import org.opensearch.common.util.concurrent.RunOnce;
-// import org.opensearch.common.util.io.IOUtils;
-
-// import java.util.Collections;
-// import java.util.Iterator;
-// import java.util.Map;
-// import java.util.Set;
-// import java.util.concurrent.ConcurrentMap;
-// import java.util.concurrent.CountDownLatch;
-// import java.util.concurrent.atomic.AtomicBoolean;
-
-// /**
-//  * This class manages node connections within a cluster. The connection is opened by the underlying transport.
-// * Once the connection is opened, this class manages the connection. This includes closing the connection when
-// * the connection manager is closed.
-// *
-// * @opensearch.internal
-// */
-// public class ProtobufClusterConnectionManager implements ConnectionManager {
-
-//     private static final Logger logger = LogManager.getLogger(ProtobufClusterConnectionManager.class);
-
-//     private final ConcurrentMap<DiscoveryNode, Transport.Connection> connectedNodes = ConcurrentCollections.newConcurrentMap();
-//     private final ConcurrentMap<DiscoveryNode, ListenableFuture<Void>> pendingConnections = ConcurrentCollections.newConcurrentMap();
-//     private final AbstractRefCounted connectingRefCounter = new AbstractRefCounted("connection manager") {
-//         @Override
-//         protected void closeInternal() {
-//             Iterator<Map.Entry<DiscoveryNode, Transport.Connection>> iterator = connectedNodes.entrySet().iterator();
-//             while (iterator.hasNext()) {
-//                 Map.Entry<DiscoveryNode, Transport.Connection> next = iterator.next();
-//                 try {
-//                     IOUtils.closeWhileHandlingException(next.getValue());
-//                 } finally {
-//                     iterator.remove();
-//                 }
-//             }
-//             closeLatch.countDown();
-//         }
-//     };
-//     private final Transport transport;
-//     private final ConnectionProfile defaultProfile;
-//     private final AtomicBoolean closing = new AtomicBoolean(false);
-//     private final CountDownLatch closeLatch = new CountDownLatch(1);
-//     private final DelegatingNodeConnectionListener connectionListener = new DelegatingNodeConnectionListener();
-
-//     public ProtobufClusterConnectionManager(Settings settings, Transport transport) {
-//         this(ConnectionProfile.buildDefaultConnectionProfile(settings), transport);
-//     }
-
-//     public ProtobufClusterConnectionManager(ConnectionProfile connectionProfile, Transport transport) {
-//         this.transport = transport;
-//         this.defaultProfile = connectionProfile;
-//     }
-
-//     @Override
-//     public void addListener(TransportConnectionListener listener) {
-//         this.connectionListener.addListener(listener);
-//     }
-
-//     @Override
-//     public void removeListener(TransportConnectionListener listener) {
-//         this.connectionListener.removeListener(listener);
-//     }
-
-//     @Override
-//     public void openConnection(
-//         DiscoveryNode node,
-//         ConnectionProfile connectionProfile,
-//         ActionListener<Transport.Connection> listener
-//     ) {
-//         ConnectionProfile resolvedProfile = ConnectionProfile.resolveConnectionProfile(connectionProfile, defaultProfile);
-//         internalOpenConnection(node, resolvedProfile, listener);
-//     }
-
-//     /**
-//      * Connects to a node with the given connection profile. If the node is already connected this method has no effect.
-//     * Once a successful is established, it can be validated before being exposed.
-//     * The ActionListener will be called on the calling thread or the generic thread pool.
-//     */
-//     @Override
-//     public void connectToNode(
-//         DiscoveryNode node,
-//         ConnectionProfile connectionProfile,
-//         ConnectionValidator connectionValidator,
-//         ActionListener<Void> listener
-//     ) throws ProtobufConnectTransportException {
-//         ConnectionProfile resolvedProfile = ConnectionProfile.resolveConnectionProfile(connectionProfile, defaultProfile);
-//         if (node == null) {
-//             listener.onFailure(new ProtobufConnectTransportException(null, "can't connect to a null node"));
-//             return;
-//         }
-
-//         if (connectingRefCounter.tryIncRef() == false) {
-//             listener.onFailure(new IllegalStateException("connection manager is closed"));
-//             return;
-//         }
-
-//         if (connectedNodes.containsKey(node)) {
-//             connectingRefCounter.decRef();
-//             listener.onResponse(null);
-//             return;
-//         }
-
-//         final ListenableFuture<Void> currentListener = new ListenableFuture<>();
-//         final ListenableFuture<Void> existingListener = pendingConnections.putIfAbsent(node, currentListener);
-//         if (existingListener != null) {
-//             try {
-//                 // wait on previous entry to complete connection attempt
-//                 existingListener.addListener(listener, OpenSearchExecutors.newDirectExecutorService());
-//             } finally {
-//                 connectingRefCounter.decRef();
-//             }
-//             return;
-//         }
-
-//         currentListener.addListener(listener, OpenSearchExecutors.newDirectExecutorService());
-
-//         final RunOnce releaseOnce = new RunOnce(connectingRefCounter::decRef);
-//         internalOpenConnection(node, resolvedProfile, ActionListener.wrap(conn -> {
-//             connectionValidator.validate(conn, resolvedProfile, ActionListener.wrap(ignored -> {
-//                 assert Transports.assertNotTransportThread("connection validator success");
-//                 try {
-//                     if (connectedNodes.putIfAbsent(node, conn) != null) {
-//                         logger.debug("existing connection to node [{}], closing new redundant connection", node);
-//                         IOUtils.closeWhileHandlingException(conn);
-//                     } else {
-//                         logger.debug("connected to node [{}]", node);
-//                         try {
-//                             connectionListener.onNodeConnected(node, conn);
-//                         } finally {
-//                             final Transport.Connection finalConnection = conn;
-//                             conn.addCloseListener(ActionListener.wrap(() -> {
-//                                 logger.trace("unregistering {} after connection close and marking as disconnected", node);
-//                                 connectedNodes.remove(node, finalConnection);
-//                                 connectionListener.onNodeDisconnected(node, conn);
-//                             }));
-//                         }
-//                     }
-//                 } finally {
-//                     ListenableFuture<Void> future = pendingConnections.remove(node);
-//                     assert future == currentListener : "Listener in pending map is different than the expected listener";
-//                     releaseOnce.run();
-//                     future.onResponse(null);
-//                 }
-//             }, e -> {
-//                 assert Transports.assertNotTransportThread("connection validator failure");
-//                 IOUtils.closeWhileHandlingException(conn);
-//                 failConnectionListeners(node, releaseOnce, e, currentListener);
-//             }));
-//         }, e -> {
-//             assert Transports.assertNotTransportThread("internalOpenConnection failure");
-//             failConnectionListeners(node, releaseOnce, e, currentListener);
-//         }));
-//     }
-
-//     /**
-//      * Returns a connection for the given node if the node is connected.
-//     * Connections returned from this method must not be closed. The lifecycle of this connection is
-//     * maintained by this connection manager
-//     *
-//     * @throws ProtobufNodeNotConnectedException if the node is not connected
-//     * @see #connectToNode(DiscoveryNode, ConnectionProfile, ConnectionValidator, ActionListener)
-//     */
-//     @Override
-//     public Transport.Connection getConnection(DiscoveryNode node) {
-//         Transport.Connection connection = connectedNodes.get(node);
-//         if (connection == null) {
-//             throw new ProtobufNodeNotConnectedException(node, "Node not connected");
-//         }
-//         return connection;
-//     }
-
-//     /**
-//      * Returns {@code true} if the node is connected.
-//     */
-//     @Override
-//     public boolean nodeConnected(DiscoveryNode node) {
-//         return connectedNodes.containsKey(node);
-//     }
-
-//     /**
-//      * Disconnected from the given node, if not connected, will do nothing.
-//     */
-//     @Override
-//     public void disconnectFromNode(DiscoveryNode node) {
-//         Transport.Connection nodeChannels = connectedNodes.remove(node);
-//         if (nodeChannels != null) {
-//             // if we found it and removed it we close
-//             nodeChannels.close();
-//         }
-//     }
-
-//     /**
-//      * Returns the number of nodes this manager is connected to.
-//     */
-//     @Override
-//     public int size() {
-//         return connectedNodes.size();
-//     }
-
-//     @Override
-//     public Set<DiscoveryNode> getAllConnectedNodes() {
-//         return Collections.unmodifiableSet(connectedNodes.keySet());
-//     }
-
-//     @Override
-//     public void close() {
-//         internalClose(true);
-//     }
-
-//     @Override
-//     public void closeNoBlock() {
-//         internalClose(false);
-//     }
-
-//     private void internalClose(boolean waitForPendingConnections) {
-//         assert Transports.assertNotTransportThread("Closing ConnectionManager");
-//         if (closing.compareAndSet(false, true)) {
-//             connectingRefCounter.decRef();
-//             if (waitForPendingConnections) {
-//                 try {
-//                     closeLatch.await();
-//                 } catch (InterruptedException e) {
-//                     Thread.currentThread().interrupt();
-//                     throw new IllegalStateException(e);
-//                 }
-//             }
-//         }
-//     }
-
-//     private void internalOpenConnection(
-//         DiscoveryNode node,
-//         ConnectionProfile connectionProfile,
-//         ActionListener<Transport.Connection> listener
-//     ) {
-//         transport.openConnection(node, connectionProfile, ActionListener.map(listener, connection -> {
-//             assert Transports.assertNotTransportThread("internalOpenConnection success");
-//             try {
-//                 connectionListener.onConnectionOpened(connection);
-//             } finally {
-//                 connection.addCloseListener(ActionListener.wrap(() -> connectionListener.onConnectionClosed(connection)));
-//             }
-//             if (connection.isClosed()) {
-//                 throw new ProtobufConnectTransportException(node, "a channel closed while connecting");
-//             }
-//             return connection;
-//         }));
-//     }
-
-//     private void failConnectionListeners(DiscoveryNode node, RunOnce releaseOnce, Exception e, ListenableFuture<Void> expectedListener) {
-//         ListenableFuture<Void> future = pendingConnections.remove(node);
-//         releaseOnce.run();
-//         if (future != null) {
-//             assert future == expectedListener : "Listener in pending map is different than the expected listener";
-//             future.onFailure(e);
-//         }
-//     }
-
-//     @Override
-//     public ConnectionProfile getConnectionProfile() {
-//         return defaultProfile;
-//     }
-
-// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java b/server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java
deleted file mode 100644
index feea2de175cdb..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufConnectionManager.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import org.opensearch.action.ActionListener;
-import org.opensearch.cluster.node.DiscoveryNode;
-
-import java.io.Closeable;
-import java.util.Set;
-import java.util.concurrent.CopyOnWriteArrayList;
-
-/** not used
- * ProtobufTransport connection manager.
-*
-* @opensearch.internal
-*/
-public interface ProtobufConnectionManager extends Closeable {
-
-    void addListener(TransportConnectionListener listener);
-
-    void removeListener(TransportConnectionListener listener);
-
-    void openConnection(
-        DiscoveryNode node,
-        ConnectionProfile connectionProfile,
-        ActionListener<Transport.Connection> listener
-    );
-
-    void connectToNode(
-        DiscoveryNode node,
-        ConnectionProfile connectionProfile,
-        ConnectionValidator connectionValidator,
-        ActionListener<Void> listener
-    ) throws ConnectTransportException;
-
-    Transport.Connection getConnection(DiscoveryNode node);
-
-    boolean nodeConnected(DiscoveryNode node);
-
-    void disconnectFromNode(DiscoveryNode node);
-
-    Set<DiscoveryNode> getAllConnectedNodes();
-
-    int size();
-
-    @Override
-    void close();
-
-    void closeNoBlock();
-
-    ConnectionProfile getConnectionProfile();
-
-    /**
-     * Validates a connection
-    *
-    * @opensearch.internal
-    */
-    @FunctionalInterface
-    interface ConnectionValidator {
-        void validate(Transport.Connection connection, ConnectionProfile profile, ActionListener<Void> listener);
-    }
-
-    /**
-     * Connection listener for a delegating node
-    *
-    * @opensearch.internal
-    */
-    final class DelegatingNodeConnectionListener implements TransportConnectionListener {
-
-        private final CopyOnWriteArrayList<TransportConnectionListener> listeners = new CopyOnWriteArrayList<>();
-
-        @Override
-        public void onNodeDisconnected(DiscoveryNode key, Transport.Connection connection) {
-            for (TransportConnectionListener listener : listeners) {
-                listener.onNodeDisconnected(key, connection);
-            }
-        }
-
-        @Override
-        public void onNodeConnected(DiscoveryNode node, Transport.Connection connection) {
-            for (TransportConnectionListener listener : listeners) {
-                listener.onNodeConnected(node, connection);
-            }
-        }
-
-        @Override
-        public void onConnectionOpened(Transport.Connection connection) {
-            for (TransportConnectionListener listener : listeners) {
-                listener.onConnectionOpened(connection);
-            }
-        }
-
-        @Override
-        public void onConnectionClosed(Transport.Connection connection) {
-            for (TransportConnectionListener listener : listeners) {
-                listener.onConnectionClosed(connection);
-            }
-        }
-
-        public void addListener(TransportConnectionListener listener) {
-            listeners.addIfAbsent(listener);
-        }
-
-        public void removeListener(TransportConnectionListener listener) {
-            listeners.remove(listener);
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufConnectionProfile.java b/server/src/main/java/org/opensearch/transport/ProtobufConnectionProfile.java
deleted file mode 100644
index 20919b8cf5aca..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufConnectionProfile.java
+++ /dev/null
@@ -1,359 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.common.Nullable;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.unit.TimeValue;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.EnumSet;
-import java.util.List;
-import java.util.Objects;
-import java.util.Set;
-import java.util.concurrent.atomic.AtomicInteger;
-
-/** not used
- * A connection profile describes how many connection are established to specific node for each of the available request types.
-* ({@link org.opensearch.transport.TransportRequestOptions.Type}). This allows to tailor a connection towards a specific usage.
-*
-* @opensearch.internal
-*/
-public final class ProtobufConnectionProfile {
-
-    /**
-     * takes a {@link ProtobufConnectionProfile} resolves it to a fully specified (i.e., no nulls) profile
-    */
-    public static ProtobufConnectionProfile resolveConnectionProfile(
-        @Nullable ProtobufConnectionProfile profile,
-        ProtobufConnectionProfile fallbackProfile
-    ) {
-        Objects.requireNonNull(fallbackProfile);
-        if (profile == null) {
-            return fallbackProfile;
-        } else if (profile.getConnectTimeout() != null
-            && profile.getHandshakeTimeout() != null
-            && profile.getPingInterval() != null
-            && profile.getCompressionEnabled() != null) {
-                return profile;
-            } else {
-                ProtobufConnectionProfile.Builder builder = new ProtobufConnectionProfile.Builder(profile);
-                if (profile.getConnectTimeout() == null) {
-                    builder.setConnectTimeout(fallbackProfile.getConnectTimeout());
-                }
-                if (profile.getHandshakeTimeout() == null) {
-                    builder.setHandshakeTimeout(fallbackProfile.getHandshakeTimeout());
-                }
-                if (profile.getPingInterval() == null) {
-                    builder.setPingInterval(fallbackProfile.getPingInterval());
-                }
-                if (profile.getCompressionEnabled() == null) {
-                    builder.setCompressionEnabled(fallbackProfile.getCompressionEnabled());
-                }
-                return builder.build();
-            }
-    }
-
-    /**
-     * Builds a default connection profile based on the provided settings.
-    *
-    * @param settings to build the connection profile from
-    * @return the connection profile
-    */
-    public static ProtobufConnectionProfile buildDefaultConnectionProfile(Settings settings) {
-        int connectionsPerNodeRecovery = TransportSettings.CONNECTIONS_PER_NODE_RECOVERY.get(settings);
-        int connectionsPerNodeBulk = TransportSettings.CONNECTIONS_PER_NODE_BULK.get(settings);
-        int connectionsPerNodeReg = TransportSettings.CONNECTIONS_PER_NODE_REG.get(settings);
-        int connectionsPerNodeState = TransportSettings.CONNECTIONS_PER_NODE_STATE.get(settings);
-        int connectionsPerNodePing = TransportSettings.CONNECTIONS_PER_NODE_PING.get(settings);
-        Builder builder = new Builder();
-        builder.setConnectTimeout(TransportSettings.CONNECT_TIMEOUT.get(settings));
-        builder.setHandshakeTimeout(TransportSettings.CONNECT_TIMEOUT.get(settings));
-        builder.setPingInterval(TransportSettings.PING_SCHEDULE.get(settings));
-        builder.setCompressionEnabled(TransportSettings.TRANSPORT_COMPRESS.get(settings));
-        builder.addConnections(connectionsPerNodeBulk, TransportRequestOptions.Type.BULK);
-        builder.addConnections(connectionsPerNodePing, TransportRequestOptions.Type.PING);
-        // if we are not cluster-manager eligible we don't need a dedicated channel to publish the state
-        builder.addConnections(
-            DiscoveryNode.isClusterManagerNode(settings) ? connectionsPerNodeState : 0,
-            TransportRequestOptions.Type.STATE
-        );
-        // if we are not a data-node we don't need any dedicated channels for recovery
-        builder.addConnections(DiscoveryNode.isDataNode(settings) ? connectionsPerNodeRecovery : 0, TransportRequestOptions.Type.RECOVERY);
-        builder.addConnections(connectionsPerNodeReg, TransportRequestOptions.Type.REG);
-        return builder.build();
-    }
-
-    /**
-     * Builds a connection profile that is dedicated to a single channel type. Use this
-    * when opening single use connections
-    */
-    public static ProtobufConnectionProfile buildSingleChannelProfile(TransportRequestOptions.Type channelType) {
-        return buildSingleChannelProfile(channelType, null, null, null, null);
-    }
-
-    /**
-     * Builds a connection profile that is dedicated to a single channel type. Allows passing connection and
-    * handshake timeouts and compression settings.
-    */
-    public static ProtobufConnectionProfile buildSingleChannelProfile(
-        TransportRequestOptions.Type channelType,
-        @Nullable TimeValue connectTimeout,
-        @Nullable TimeValue handshakeTimeout,
-        @Nullable TimeValue pingInterval,
-        @Nullable Boolean compressionEnabled
-    ) {
-        Builder builder = new Builder();
-        builder.addConnections(1, channelType);
-        final EnumSet<TransportRequestOptions.Type> otherTypes = EnumSet.allOf(TransportRequestOptions.Type.class);
-        otherTypes.remove(channelType);
-        builder.addConnections(0, otherTypes.toArray(new TransportRequestOptions.Type[0]));
-        if (connectTimeout != null) {
-            builder.setConnectTimeout(connectTimeout);
-        }
-        if (handshakeTimeout != null) {
-            builder.setHandshakeTimeout(handshakeTimeout);
-        }
-        if (pingInterval != null) {
-            builder.setPingInterval(pingInterval);
-        }
-        if (compressionEnabled != null) {
-            builder.setCompressionEnabled(compressionEnabled);
-        }
-        return builder.build();
-    }
-
-    private final List<ConnectionTypeHandle> handles;
-    private final int numConnections;
-    private final TimeValue connectTimeout;
-    private final TimeValue handshakeTimeout;
-    private final TimeValue pingInterval;
-    private final Boolean compressionEnabled;
-
-    private ProtobufConnectionProfile(
-        List<ConnectionTypeHandle> handles,
-        int numConnections,
-        TimeValue connectTimeout,
-        TimeValue handshakeTimeout,
-        TimeValue pingInterval,
-        Boolean compressionEnabled
-    ) {
-        this.handles = handles;
-        this.numConnections = numConnections;
-        this.connectTimeout = connectTimeout;
-        this.handshakeTimeout = handshakeTimeout;
-        this.pingInterval = pingInterval;
-        this.compressionEnabled = compressionEnabled;
-    }
-
-    /**
-     * A builder to build a new {@link ProtobufConnectionProfile}
-    *
-    * @opensearch.internal
-    */
-    public static class Builder {
-        private final List<ConnectionTypeHandle> handles = new ArrayList<>();
-        private final Set<TransportRequestOptions.Type> addedTypes = EnumSet.noneOf(TransportRequestOptions.Type.class);
-        private int numConnections = 0;
-        private TimeValue connectTimeout;
-        private TimeValue handshakeTimeout;
-        private Boolean compressionEnabled;
-        private TimeValue pingInterval;
-
-        /** create an empty builder */
-        public Builder() {}
-
-        /** copy constructor, using another profile as a base */
-        public Builder(ProtobufConnectionProfile source) {
-            handles.addAll(source.getHandles());
-            numConnections = source.getNumConnections();
-            handles.forEach(th -> addedTypes.addAll(th.types));
-            connectTimeout = source.getConnectTimeout();
-            handshakeTimeout = source.getHandshakeTimeout();
-            compressionEnabled = source.getCompressionEnabled();
-            pingInterval = source.getPingInterval();
-        }
-
-        /**
-         * Sets a connect timeout for this connection profile
-        */
-        public Builder setConnectTimeout(TimeValue connectTimeout) {
-            if (connectTimeout.millis() < 0) {
-                throw new IllegalArgumentException("connectTimeout must be non-negative but was: " + connectTimeout);
-            }
-            this.connectTimeout = connectTimeout;
-            return this;
-        }
-
-        /**
-         * Sets a handshake timeout for this connection profile
-        */
-        public Builder setHandshakeTimeout(TimeValue handshakeTimeout) {
-            if (handshakeTimeout.millis() < 0) {
-                throw new IllegalArgumentException("handshakeTimeout must be non-negative but was: " + handshakeTimeout);
-            }
-            this.handshakeTimeout = handshakeTimeout;
-            return this;
-        }
-
-        /**
-         * Sets a ping interval for this connection profile
-        */
-        public Builder setPingInterval(TimeValue pingInterval) {
-            this.pingInterval = pingInterval;
-            return this;
-        }
-
-        /**
-         * Sets compression enabled for this connection profile
-        */
-        public Builder setCompressionEnabled(boolean compressionEnabled) {
-            this.compressionEnabled = compressionEnabled;
-            return this;
-        }
-
-        /**
-         * Adds a number of connections for one or more types. Each type can only be added once.
-        * @param numConnections the number of connections to use in the pool for the given connection types
-        * @param types a set of types that should share the given number of connections
-        */
-        public Builder addConnections(int numConnections, TransportRequestOptions.Type... types) {
-            if (types == null || types.length == 0) {
-                throw new IllegalArgumentException("types must not be null");
-            }
-            for (TransportRequestOptions.Type type : types) {
-                if (addedTypes.contains(type)) {
-                    throw new IllegalArgumentException("type [" + type + "] is already registered");
-                }
-            }
-            addedTypes.addAll(Arrays.asList(types));
-            handles.add(new ConnectionTypeHandle(this.numConnections, numConnections, EnumSet.copyOf(Arrays.asList(types))));
-            this.numConnections += numConnections;
-            return this;
-        }
-
-        /**
-         * Creates a new {@link ProtobufConnectionProfile} based on the added connections.
-        * @throws IllegalStateException if any of the {@link org.opensearch.transport.TransportRequestOptions.Type} enum is missing
-        */
-        public ProtobufConnectionProfile build() {
-            EnumSet<TransportRequestOptions.Type> types = EnumSet.allOf(TransportRequestOptions.Type.class);
-            types.removeAll(addedTypes);
-            if (types.isEmpty() == false) {
-                throw new IllegalStateException("not all types are added for this connection profile - missing types: " + types);
-            }
-            return new ProtobufConnectionProfile(
-                Collections.unmodifiableList(handles),
-                numConnections,
-                connectTimeout,
-                handshakeTimeout,
-                pingInterval,
-                compressionEnabled
-            );
-        }
-
-    }
-
-    /**
-     * Returns the connect timeout or <code>null</code> if no explicit timeout is set on this profile.
-    */
-    public TimeValue getConnectTimeout() {
-        return connectTimeout;
-    }
-
-    /**
-     * Returns the handshake timeout or <code>null</code> if no explicit timeout is set on this profile.
-    */
-    public TimeValue getHandshakeTimeout() {
-        return handshakeTimeout;
-    }
-
-    /**
-     * Returns the ping interval or <code>null</code> if no explicit ping interval is set on this profile.
-    */
-    public TimeValue getPingInterval() {
-        return pingInterval;
-    }
-
-    /**
-     * Returns boolean indicating if compression is enabled or <code>null</code> if no explicit compression
-    * is set on this profile.
-    */
-    public Boolean getCompressionEnabled() {
-        return compressionEnabled;
-    }
-
-    /**
-     * Returns the total number of connections for this profile
-    */
-    public int getNumConnections() {
-        return numConnections;
-    }
-
-    /**
-     * Returns the number of connections per type for this profile. This might return a count that is shared with other types such
-    * that the sum of all connections per type might be higher than {@link #getNumConnections()}. For instance if
-    * {@link org.opensearch.transport.TransportRequestOptions.Type#BULK} shares connections with
-    * {@link org.opensearch.transport.TransportRequestOptions.Type#REG} they will return both the same number of connections from
-    * this method but the connections are not distinct.
-    */
-    public int getNumConnectionsPerType(TransportRequestOptions.Type type) {
-        for (ConnectionTypeHandle handle : handles) {
-            if (handle.getTypes().contains(type)) {
-                return handle.length;
-            }
-        }
-        throw new AssertionError("no handle found for type: " + type);
-    }
-
-    /**
-     * Returns the type handles for this connection profile
-    */
-    List<ConnectionTypeHandle> getHandles() {
-        return Collections.unmodifiableList(handles);
-    }
-
-    /**
-     * Connection type handle encapsulates the logic which connection
-    */
-    static final class ConnectionTypeHandle {
-        public final int length;
-        public final int offset;
-        private final Set<TransportRequestOptions.Type> types;
-        private final AtomicInteger counter = new AtomicInteger();
-
-        private ConnectionTypeHandle(int offset, int length, Set<TransportRequestOptions.Type> types) {
-            this.length = length;
-            this.offset = offset;
-            this.types = types;
-        }
-
-        /**
-         * Returns one of the channels out configured for this handle. The channel is selected in a round-robin
-        * fashion.
-        */
-        <T> T getChannel(List<T> channels) {
-            if (length == 0) {
-                throw new IllegalStateException("can't select channel size is 0 for types: " + types);
-            }
-            assert channels.size() >= offset + length : "illegal size: " + channels.size() + " expected >= " + (offset + length);
-            return channels.get(offset + Math.floorMod(counter.incrementAndGet(), length));
-        }
-
-        /**
-         * Returns all types for this handle
-        */
-        Set<TransportRequestOptions.Type> getTypes() {
-            return types;
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java
index 71090200fb053..4f28a234957c8 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java
@@ -60,4 +60,9 @@ public void handleException(TransportException exp) {
         // TODO Auto-generated method stub
         throw new UnsupportedOperationException("Unimplemented method 'handleException'");
     }
+
+    @Override
+    public TransportResponse.Empty read(byte[] in) throws IOException {
+        return TransportResponse.Empty.INSTANCE;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java b/server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java
deleted file mode 100644
index 2106a46737923..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufOutboundHandler.java
+++ /dev/null
@@ -1,281 +0,0 @@
-// /*
-// * 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.
-// */
-
-// package org.opensearch.transport;
-
-// import com.google.protobuf.CodedOutputStream;
-// import org.apache.logging.log4j.LogManager;
-// import org.apache.logging.log4j.Logger;
-// import org.apache.logging.log4j.message.ParameterizedMessage;
-// import org.opensearch.Version;
-// import org.opensearch.action.ActionListener;
-// import org.opensearch.action.NotifyOnceListener;
-// import org.opensearch.cluster.node.DiscoveryNode;
-// import org.opensearch.common.CheckedSupplier;
-// import org.opensearch.common.bytes.BytesReference;
-// import org.opensearch.common.lease.Releasable;
-// import org.opensearch.common.lease.Releasables;
-// import org.opensearch.common.network.CloseableChannel;
-// import org.opensearch.common.transport.NetworkExceptionHelper;
-// import org.opensearch.common.transport.TransportAddress;
-// import org.opensearch.common.util.concurrent.ThreadContext;
-// import org.opensearch.threadpool.ThreadPool;
-
-// import java.io.IOException;
-// import java.util.Set;
-
-// /**
-//  * Outbound data handler
-// *
-// * @opensearch.internal
-// */
-// final class ProtobufOutboundHandler {
-
-//     private static final Logger logger = LogManager.getLogger(ProtobufOutboundHandler.class);
-
-//     private final String nodeName;
-//     private final Version version;
-//     private final String[] features;
-//     private final StatsTracker statsTracker;
-//     private final ThreadPool threadPool;
-//     // private final BigArrays bigArrays;
-//     private final byte[] bytes;
-//     private volatile ProtobufTransportMessageListener messageListener = ProtobufTransportMessageListener.NOOP_LISTENER;
-
-//     ProtobufOutboundHandler(
-//         String nodeName,
-//         Version version,
-//         String[] features,
-//         StatsTracker statsTracker,
-//         ThreadPool threadPool,
-//         byte[] bytes
-//     ) {
-//         this.nodeName = nodeName;
-//         this.version = version;
-//         this.features = features;
-//         this.statsTracker = statsTracker;
-//         this.threadPool = threadPool;
-//         this.bytes = bytes;
-//     }
-
-//     void sendBytes(TcpChannel channel, BytesReference bytes, ActionListener<Void> listener) {
-//         SendContext sendContext = new SendContext(channel, () -> bytes, listener);
-//         try {
-//             internalSend(channel, sendContext);
-//         } catch (IOException e) {
-//             // This should not happen as the bytes are already serialized
-//             throw new AssertionError(e);
-//         }
-//     }
-
-//     /**
-//      * Sends the request to the given channel. This method should be used to send {@link TransportRequest}
-//     * objects back to the caller.
-//     */
-//     void sendRequest(
-//         final DiscoveryNode node,
-//         final TcpChannel channel,
-//         final long requestId,
-//         final String action,
-//         final TransportRequest request,
-//         final TransportRequestOptions options,
-//         final Version channelVersion,
-//         final boolean compressRequest,
-//         final boolean isHandshake
-//     ) throws IOException, TransportException {
-//         Version version = Version.min(this.version, channelVersion);
-//         ProtobufOutboundMessage.Request message = new ProtobufOutboundMessage.Request(
-//             threadPool.getThreadContext(),
-//             features,
-//             request,
-//             version,
-//             action,
-//             requestId,
-//             isHandshake,
-//             compressRequest
-//         );
-//         ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onRequestSent(node, requestId, action, request, options));
-//         sendMessage(channel, message, listener);
-//     }
-
-//     /**
-//      * Sends the response to the given channel. This method should be used to send {@link TransportResponse}
-//     * objects back to the caller.
-//     *
-//     * @see #sendErrorResponse(Version, Set, TcpChannel, long, String, Exception) for sending error responses
-//     */
-//     void sendResponse(
-//         final Version nodeVersion,
-//         final Set<String> features,
-//         final TcpChannel channel,
-//         final long requestId,
-//         final String action,
-//         final TransportResponse response,
-//         final boolean compress,
-//         final boolean isHandshake
-//     ) throws IOException {
-//         Version version = Version.min(this.version, nodeVersion);
-//         ProtobufOutboundMessage.Response message = new ProtobufOutboundMessage.Response(
-//             threadPool.getThreadContext(),
-//             features,
-//             response,
-//             version,
-//             requestId,
-//             isHandshake,
-//             compress
-//         );
-//         ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onResponseSent(requestId, action, response));
-//         sendMessage(channel, message, listener);
-//     }
-
-//     /**
-//      * Sends back an error response to the caller via the given channel
-//     */
-//     void sendErrorResponse(
-//         final Version nodeVersion,
-//         final Set<String> features,
-//         final TcpChannel channel,
-//         final long requestId,
-//         final String action,
-//         final Exception error
-//     ) throws IOException {
-//         Version version = Version.min(this.version, nodeVersion);
-//         TransportAddress address = new TransportAddress(channel.getLocalAddress());
-//         ProtobufRemoteTransportException tx = new ProtobufRemoteTransportException(nodeName, address, action, error);
-//         ProtobufOutboundMessage.Response message = new ProtobufOutboundMessage.Response(
-//             threadPool.getThreadContext(),
-//             features,
-//             tx,
-//             version,
-//             requestId,
-//             false,
-//             false
-//         );
-//         ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onResponseSent(requestId, action, error));
-//         sendMessage(channel, message, listener);
-//     }
-
-//     private void sendMessage(TcpChannel channel, ProtobufOutboundMessage networkMessage, ActionListener<Void> listener) throws IOException {
-//         MessageSerializer serializer = new MessageSerializer(networkMessage, bytes);
-//         SendContext sendContext = new SendContext(channel, serializer, listener, serializer);
-//         internalSend(channel, sendContext);
-//     }
-
-//     private void internalSend(TcpChannel channel, SendContext sendContext) throws IOException {
-//         channel.getChannelStats().markAccessed(threadPool.relativeTimeInMillis());
-//         BytesReference reference = sendContext.get();
-//         // stash thread context so that channel event loop is not polluted by thread context
-//         try (ThreadContext.StoredContext existing = threadPool.getThreadContext().stashContext()) {
-//             channel.sendMessage(reference, sendContext);
-//         } catch (RuntimeException ex) {
-//             sendContext.onFailure(ex);
-//             CloseableChannel.closeChannel(channel);
-//             throw ex;
-//         }
-//     }
-
-//     void setMessageListener(ProtobufTransportMessageListener listener) {
-//         if (messageListener == ProtobufTransportMessageListener.NOOP_LISTENER) {
-//             messageListener = listener;
-//         } else {
-//             throw new IllegalStateException("Cannot set message listener twice");
-//         }
-//     }
-
-//     /**
-//      * Internal message serializer
-//     *
-//     * @opensearch.internal
-//     */
-//     private static class MessageSerializer implements CheckedSupplier<BytesReference, IOException>, Releasable {
-
-//         private final ProtobufOutboundMessage message;
-//         private byte[] bytes;
-//         // private final BigArrays bigArrays;
-//         // private volatile ReleasableBytesStreamOutput bytesStreamOutput;
-
-//         private MessageSerializer(ProtobufOutboundMessage message, byte[] bytes) {
-//             this.message = message;
-//             this.bytes = bytes;
-//         }
-
-//         @Override
-//         public BytesReference get() throws IOException {
-//             CodedOutputStream out = CodedOutputStream.newInstance(bytes);
-//             return message.serialize(out, bytes);
-//         }
-
-//         @Override
-//         public void close() {
-//             // IOUtils.closeWhileHandlingException(bytesStreamOutput);
-//         }
-//     }
-
-//     private class SendContext extends NotifyOnceListener<Void> implements CheckedSupplier<BytesReference, IOException> {
-
-//         private final TcpChannel channel;
-//         private final CheckedSupplier<BytesReference, IOException> messageSupplier;
-//         private final ActionListener<Void> listener;
-//         private final Releasable optionalReleasable;
-//         private long messageSize = -1;
-
-//         private SendContext(
-//             TcpChannel channel,
-//             CheckedSupplier<BytesReference, IOException> messageSupplier,
-//             ActionListener<Void> listener
-//         ) {
-//             this(channel, messageSupplier, listener, null);
-//         }
-
-//         private SendContext(
-//             TcpChannel channel,
-//             CheckedSupplier<BytesReference, IOException> messageSupplier,
-//             ActionListener<Void> listener,
-//             Releasable optionalReleasable
-//         ) {
-//             this.channel = channel;
-//             this.messageSupplier = messageSupplier;
-//             this.listener = listener;
-//             this.optionalReleasable = optionalReleasable;
-//         }
-
-//         public BytesReference get() throws IOException {
-//             BytesReference message;
-//             try {
-//                 message = messageSupplier.get();
-//                 messageSize = message.length();
-//                 TransportLogger.logOutboundMessage(channel, message);
-//                 return message;
-//             } catch (Exception e) {
-//                 onFailure(e);
-//                 throw e;
-//             }
-//         }
-
-//         @Override
-//         protected void innerOnResponse(Void v) {
-//             assert messageSize != -1 : "If onResponse is being called, the message should have been serialized";
-//             statsTracker.markBytesWritten(messageSize);
-//             closeAndCallback(() -> listener.onResponse(v));
-//         }
-
-//         @Override
-//         protected void innerOnFailure(Exception e) {
-//             if (NetworkExceptionHelper.isCloseConnectionException(e)) {
-//                 logger.debug(() -> new ParameterizedMessage("send message failed [channel: {}]", channel), e);
-//             } else {
-//                 logger.warn(() -> new ParameterizedMessage("send message failed [channel: {}]", channel), e);
-//             }
-//             closeAndCallback(() -> listener.onFailure(e));
-//         }
-
-//         private void closeAndCallback(Runnable runnable) {
-//             Releasables.close(optionalReleasable, runnable::run);
-//         }
-//     }
-// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java b/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
index 20204fef3bcb4..09db38c1cef74 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
@@ -19,11 +19,15 @@
 
 import org.opensearch.Version;
 import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.example.proto.ExampleRequestProto.ExampleRequest;
-import org.opensearch.example.proto.OutboundMessageProto.OutboundMsg;
-import org.opensearch.example.proto.OutboundMessageProto.OutboundMsg.Header;
-import org.opensearch.example.proto.OutboundMessageProto.OutboundMsg.ResponseHandlersList;
-
+import org.opensearch.server.proto.ClusterStateRequestProto.ClusterStateReq;
+import org.opensearch.server.proto.ClusterStateResponseProto.ClusterStateRes;
+import org.opensearch.server.proto.NodesInfoProto.NodesInfo;
+import org.opensearch.server.proto.NodesInfoRequestProto.NodesInfoReq;
+import org.opensearch.server.proto.NodesStatsProto.NodesStats;
+import org.opensearch.server.proto.NodesStatsRequestProto.NodesStatsReq;
+import org.opensearch.server.proto.OutboundMessageProto.OutboundMsg;
+import org.opensearch.server.proto.OutboundMessageProto.OutboundMsg.Header;
+import org.opensearch.server.proto.OutboundMessageProto.OutboundMsg.ResponseHandlersList;
 import com.google.protobuf.ByteString;
 import com.google.protobuf.InvalidProtocolBufferException;
 
@@ -37,7 +41,139 @@ public class ProtobufOutboundMessage {
     private final OutboundMsg message;
     private static final byte[] PREFIX = { (byte) 'E', (byte) 'S' };
 
-    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, ExampleRequest exampleRequest, String[] features, String action) {
+    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, ClusterStateReq clusterStateReq, String[] features, String action) {
+        Header header = Header.newBuilder()
+                            .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
+                            .setRequestId(requestId)
+                            .setStatus(ByteString.copyFrom(status))
+                            .setVersionId(version.id)
+                            .build();
+        Map<String, String> requestHeaders = threadContext.getHeaders();
+        Map<String, List<String>> responseHeaders = threadContext.getResponseHeaders();
+        Map<String, ResponseHandlersList> responseHandlers = new HashMap<>();
+        for (Map.Entry<String, List<String>> entry : responseHeaders.entrySet()) {
+            String key = entry.getKey();
+            List<String> value = entry.getValue();
+            ResponseHandlersList responseHandlersList = ResponseHandlersList.newBuilder()
+                                                                        .addAllSetOfResponseHandlers(value)
+                                                                        .build();
+            responseHandlers.put(key, responseHandlersList);
+        }
+        this.message = OutboundMsg.newBuilder()
+                            .setHeader(header)
+                            .putAllRequestHeaders(requestHeaders)
+                            .putAllResponseHandlers(responseHandlers)
+                            .setVersion(version.toString())
+                            .setStatus(ByteString.copyFrom(status))
+                            .setRequestId(requestId)
+                            .setClusterStateReq(clusterStateReq)
+                            .setAction(action)
+                            .addAllFeatures(Arrays.asList(features))
+                            .setIsProtobuf(true)
+                            .build();
+                            
+    }
+
+    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, ClusterStateRes clusterStateRes, Set<String> features, String action) {
+        Header header = Header.newBuilder()
+                            .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
+                            .setRequestId(requestId)
+                            .setStatus(ByteString.copyFrom(status))
+                            .setVersionId(version.id)
+                            .build();
+        Map<String, String> requestHeaders = threadContext.getHeaders();
+        Map<String, List<String>> responseHeaders = threadContext.getResponseHeaders();
+        Map<String, ResponseHandlersList> responseHandlers = new HashMap<>();
+        for (Map.Entry<String, List<String>> entry : responseHeaders.entrySet()) {
+            String key = entry.getKey();
+            List<String> value = entry.getValue();
+            ResponseHandlersList responseHandlersList = ResponseHandlersList.newBuilder()
+                                                                        .addAllSetOfResponseHandlers(value)
+                                                                        .build();
+            responseHandlers.put(key, responseHandlersList);
+        }
+        this.message = OutboundMsg.newBuilder()
+                            .setHeader(header)
+                            .putAllRequestHeaders(requestHeaders)
+                            .putAllResponseHandlers(responseHandlers)
+                            .setVersion(version.toString())
+                            .setStatus(ByteString.copyFrom(status))
+                            .setRequestId(requestId)
+                            .setClusterStateRes(clusterStateRes)
+                            .setAction(action)
+                            .addAllFeatures(features)
+                            .setIsProtobuf(true)
+                            .build();
+                            
+    }
+
+    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, NodesInfoReq nodesInfoReq, String[] features, String action) {
+        Header header = Header.newBuilder()
+                            .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
+                            .setRequestId(requestId)
+                            .setStatus(ByteString.copyFrom(status))
+                            .setVersionId(version.id)
+                            .build();
+        Map<String, String> requestHeaders = threadContext.getHeaders();
+        Map<String, List<String>> responseHeaders = threadContext.getResponseHeaders();
+        Map<String, ResponseHandlersList> responseHandlers = new HashMap<>();
+        for (Map.Entry<String, List<String>> entry : responseHeaders.entrySet()) {
+            String key = entry.getKey();
+            List<String> value = entry.getValue();
+            ResponseHandlersList responseHandlersList = ResponseHandlersList.newBuilder()
+                                                                        .addAllSetOfResponseHandlers(value)
+                                                                        .build();
+            responseHandlers.put(key, responseHandlersList);
+        }
+        this.message = OutboundMsg.newBuilder()
+                            .setHeader(header)
+                            .putAllRequestHeaders(requestHeaders)
+                            .putAllResponseHandlers(responseHandlers)
+                            .setVersion(version.toString())
+                            .setStatus(ByteString.copyFrom(status))
+                            .setRequestId(requestId)
+                            .setNodesInfoReq(nodesInfoReq)
+                            .setAction(action)
+                            .addAllFeatures(Arrays.asList(features))
+                            .setIsProtobuf(true)
+                            .build();
+                            
+    }
+
+    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, NodesInfo nodesInfoRes, Set<String> features, String action) {
+        Header header = Header.newBuilder()
+                            .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
+                            .setRequestId(requestId)
+                            .setStatus(ByteString.copyFrom(status))
+                            .setVersionId(version.id)
+                            .build();
+        Map<String, String> requestHeaders = threadContext.getHeaders();
+        Map<String, List<String>> responseHeaders = threadContext.getResponseHeaders();
+        Map<String, ResponseHandlersList> responseHandlers = new HashMap<>();
+        for (Map.Entry<String, List<String>> entry : responseHeaders.entrySet()) {
+            String key = entry.getKey();
+            List<String> value = entry.getValue();
+            ResponseHandlersList responseHandlersList = ResponseHandlersList.newBuilder()
+                                                                        .addAllSetOfResponseHandlers(value)
+                                                                        .build();
+            responseHandlers.put(key, responseHandlersList);
+        }
+        this.message = OutboundMsg.newBuilder()
+                            .setHeader(header)
+                            .putAllRequestHeaders(requestHeaders)
+                            .putAllResponseHandlers(responseHandlers)
+                            .setVersion(version.toString())
+                            .setStatus(ByteString.copyFrom(status))
+                            .setRequestId(requestId)
+                            .setNodesInfoRes(nodesInfoRes)
+                            .setAction(action)
+                            .addAllFeatures(features)
+                            .setIsProtobuf(true)
+                            .build();
+                            
+    }
+
+    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, NodesStatsReq nodesStatsReq, String[] features, String action) {
         Header header = Header.newBuilder()
                             .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
                             .setRequestId(requestId)
@@ -62,7 +198,7 @@ public ProtobufOutboundMessage(long requestId, byte[] status, Version version, T
                             .setVersion(version.toString())
                             .setStatus(ByteString.copyFrom(status))
                             .setRequestId(requestId)
-                            .setMessage(exampleRequest)
+                            .setNodesStatsReq(nodesStatsReq)
                             .setAction(action)
                             .addAllFeatures(Arrays.asList(features))
                             .setIsProtobuf(true)
@@ -70,6 +206,39 @@ public ProtobufOutboundMessage(long requestId, byte[] status, Version version, T
                             
     }
 
+    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, NodesStats nodesStatsRes, Set<String> features, String action) {
+        Header header = Header.newBuilder()
+                            .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
+                            .setRequestId(requestId)
+                            .setStatus(ByteString.copyFrom(status))
+                            .setVersionId(version.id)
+                            .build();
+        Map<String, String> requestHeaders = threadContext.getHeaders();
+        Map<String, List<String>> responseHeaders = threadContext.getResponseHeaders();
+        Map<String, ResponseHandlersList> responseHandlers = new HashMap<>();
+        for (Map.Entry<String, List<String>> entry : responseHeaders.entrySet()) {
+            String key = entry.getKey();
+            List<String> value = entry.getValue();
+            ResponseHandlersList responseHandlersList = ResponseHandlersList.newBuilder()
+                                                                        .addAllSetOfResponseHandlers(value)
+                                                                        .build();
+            responseHandlers.put(key, responseHandlersList);
+        }
+        this.message = OutboundMsg.newBuilder()
+                            .setHeader(header)
+                            .putAllRequestHeaders(requestHeaders)
+                            .putAllResponseHandlers(responseHandlers)
+                            .setVersion(version.toString())
+                            .setStatus(ByteString.copyFrom(status))
+                            .setRequestId(requestId)
+                            .setNodesStatsRes(nodesStatsRes)
+                            .setAction(action)
+                            .addAllFeatures(features)
+                            .setIsProtobuf(true)
+                            .build();
+                            
+    }
+
     public ProtobufOutboundMessage(byte[] data) throws InvalidProtocolBufferException {
         this.message = OutboundMsg.parseFrom(data);
     }
@@ -111,258 +280,4 @@ public Map<String, Set<String>> getResponseHandlers() {
     public boolean isProtobuf() {
         return this.message.getIsProtobuf();
     }
-
-
-    // private final TransportMessage message;
-
-    // ProtobufOutboundMessage(ThreadContext threadContext, Version version, byte status, long requestId, TransportMessage message) {
-    //     super(threadContext, version, status, requestId);
-    //     this.message = message;
-    // }
-
-    // BytesReference serialize(BytesStreamOutput bytesStream) throws IOException {
-    //     // TcpHeader.writeHeaderProtobuf(outputStream, requestId, status, version, TcpHeader.headerSize(version), TcpHeader.headerSize(version));
-    //     // writeVariableHeader(outputStream);
-    //     // message.writeTo(outputStream);
-    //     // System.out.println("Inside ProtobufOutboundMessage.serialize");
-    //     // CodedOutputStream codedOutputStream = CodedOutputStream.newInstance(bytesStream);
-    //     // ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(codedOutputStream);
-    //     // protobufStreamOutput.setVersion(version);
-    //     // // bytesStream.setVersion(version);
-    //     // // bytesStream.skip(TcpHeader.headerSize(version));
-
-    //     // // The compressible bytes stream will not close the underlying bytes stream
-    //     // BytesReference reference;
-    //     // int variableHeaderLength = -1;
-    //     // final long preHeaderPosition = codedOutputStream.getTotalBytesWritten();
-    //     // writeVariableHeader(codedOutputStream);
-    //     // variableHeaderLength = Math.toIntExact(codedOutputStream.getTotalBytesWritten() - preHeaderPosition);
-
-    //     // protobufStreamOutput.setFeatures(bytesStream.getFeatures());
-    //     // if (variableHeaderLength == -1) {
-    //     //         writeVariableHeader(codedOutputStream);
-    //     // }
-    //     // reference = writeMessage(codedOutputStream);
-    //     // // try (CompressibleBytesOutputStream stream = new CompressibleBytesOutputStream(bytesStream, TransportStatus.isCompress(status))) {
-    //     // //     stream.setVersion(version);
-    //     // //     stream.setFeatures(bytesStream.getFeatures());
-
-    //     // //     if (variableHeaderLength == -1) {
-    //     // //         writeVariableHeader(stream);
-    //     // //     }
-    //     // //     reference = writeMessage(stream);
-    //     // // }
-
-    //     // // bytesStream.seek(0);
-    //     // final int contentSize = reference.length() - TcpHeader.headerSize(version);
-    //     // TcpHeader.writeHeaderProtobuf(codedOutputStream, requestId, status, version, contentSize, variableHeaderLength);
-    //     // System.out.println("Bytes serialized length: " + reference.length());
-    //     // System.out.println("Bytes serialized: " + reference);
-    //     // System.out.println("Now the bytes: ");
-    //     // for (int i = 0; i < reference.length(); i++) {
-    //     //     System.out.print(reference.get(i) + " ");
-    //     // }
-    //     // System.out.println();
-    //     // return reference;
-
-        
-    //     bytesStream.setVersion(version);
-    //     bytesStream.skip(TcpHeader.headerSize(version));
-
-    //     // The compressible bytes stream will not close the underlying bytes stream
-    //     BytesReference reference;
-    //     int variableHeaderLength = -1;
-    //     final long preHeaderPosition = bytesStream.position();
-    //     writeVariableHeader(bytesStream);
-    //     variableHeaderLength = Math.toIntExact(bytesStream.position() - preHeaderPosition);
-
-    //     try (CompressibleBytesOutputStream stream = new CompressibleBytesOutputStream(bytesStream, TransportStatus.isCompress(status))) {
-    //         stream.setVersion(version);
-    //         stream.setFeatures(bytesStream.getFeatures());
-
-    //         if (variableHeaderLength == -1) {
-    //             writeVariableHeader(stream);
-    //         }
-    //         reference = writeMessage(stream);
-    //     }
-
-    //     bytesStream.seek(0);
-    //     final int contentSize = reference.length() - TcpHeader.headerSize(version);
-    //     TcpHeader.writeHeader(bytesStream, requestId, status, version, contentSize, variableHeaderLength);
-    //     System.out.println("Bytes serialized length: " + reference.length());
-    //     System.out.println("Bytes serialized: " + reference);
-    //     System.out.println("Now the bytes: ");
-    //     for (int i = 0; i < reference.length(); i++) {
-    //         System.out.print(reference.get(i) + " ");
-    //     }
-    //     System.out.println();
-    //     // convert output stream to bytes
-    //     // ByteArrayOutputStream baos = new ByteArrayOutputStream();
-    //     // baos.write(outputStream);
-    //     // outputStream.writeTo(baos);
-    //     // byte[] bytes = baos.toByteArray();
-    //     // System.out.println("Bytes serialized length: " + bytes.length);
-    //     // System.out.println("Bytes serialized: " + bytes);
-    //     // System.out.println("Now the bytes: ");
-
-    //     return reference;
-    // }
-
-    // protected void writeVariableHeader(StreamOutput stream) throws IOException {
-    //     threadContext.writeTo(stream);
-    // }
-
-    // protected BytesReference writeMessage(CompressibleBytesOutputStream stream) throws IOException {
-    //     // final BytesReference zeroCopyBuffer;
-    //     // if (message instanceof BytesTransportRequest) {
-    //     //     BytesTransportRequest bRequest = (BytesTransportRequest) message;
-    //     //     bRequest.writeThinProtobuf(stream);
-    //     //     zeroCopyBuffer = bRequest.bytes;
-    //     // } else if (message instanceof ProtobufRemoteTransportException) {
-    //     //     ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(stream);
-    //     //     protobufStreamOutput.writeException((ProtobufRemoteTransportException) message);
-    //     //     zeroCopyBuffer = BytesArray.EMPTY;
-    //     // } else {
-    //     //     message.writeTo(stream);
-    //     //     zeroCopyBuffer = BytesArray.EMPTY;
-    //     // }
-    //     // // we have to call materializeBytes() here before accessing the bytes. A CompressibleBytesOutputStream
-    //     // // might be implementing compression. And materializeBytes() ensures that some marker bytes (EOS marker)
-    //     // // are written. Otherwise we barf on the decompressing end when we read past EOF on purpose in the
-    //     // // #validateRequest method. this might be a problem in deflate after all but it's important to write
-    //     // // the marker bytes.
-    //     // ByteBuffer byteBuffer = ByteBuffer.wrap(bytes);
-    //     // final BytesReference message = stream
-    //     // if (zeroCopyBuffer.length() == 0) {
-    //     //     return message;
-    //     // } else {
-    //     //     return CompositeBytesReference.of(message, zeroCopyBuffer);
-    //     // }
-    //     final BytesReference zeroCopyBuffer;
-    //     if (message instanceof BytesTransportRequest) {
-    //         BytesTransportRequest bRequest = (BytesTransportRequest) message;
-    //         bRequest.writeThin(stream);
-    //         zeroCopyBuffer = bRequest.bytes;
-    //     // } else if (message instanceof RemoteTransportException) {
-    //     //     stream.writeException((RemoteTransportException) message);
-    //     //     zeroCopyBuffer = BytesArray.EMPTY;
-    //     } else {
-    //         // CodedOutputStream outputStream = CodedOutputStream.newInstance(stream);
-    //         message.writeTo(stream);
-    //         zeroCopyBuffer = BytesArray.EMPTY;
-    //     }
-    //     // we have to call materializeBytes() here before accessing the bytes. A CompressibleBytesOutputStream
-    //     // might be implementing compression. And materializeBytes() ensures that some marker bytes (EOS marker)
-    //     // are written. Otherwise we barf on the decompressing end when we read past EOF on purpose in the
-    //     // #validateRequest method. this might be a problem in deflate after all but it's important to write
-    //     // the marker bytes.
-    //     final BytesReference message = stream.materializeBytes();
-    //     if (zeroCopyBuffer.length() == 0) {
-    //         return message;
-    //     } else {
-    //         return CompositeBytesReference.of(message, zeroCopyBuffer);
-    //     }
-    // }
-
-    // /**
-    //  * Internal outbound message request
-    // *
-    // * @opensearch.internal
-    // */
-    // static class Request extends ProtobufOutboundMessage {
-
-    //     private final String[] features;
-    //     private final String action;
-
-    //     Request(
-    //         ThreadContext threadContext,
-    //         String[] features,
-    //         TransportMessage message,
-    //         Version version,
-    //         String action,
-    //         long requestId,
-    //         boolean isHandshake,
-    //         boolean compress
-    //     ) {
-    //         super(threadContext, version, setStatus(compress, isHandshake, message), requestId, message);
-    //         this.features = features;
-    //         this.action = action;
-    //     }
-
-    //     @Override
-    //     protected void writeVariableHeader(StreamOutput stream) throws IOException {
-    //         // super.writeVariableHeader(out);
-    //         // ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-    //         // protobufStreamOutput.writeStringArray(features);
-    //         // out.writeStringNoTag(action);
-    //         super.writeVariableHeader(stream);
-    //         stream.writeStringArray(features);
-    //         stream.writeString(action);
-    //     }
-
-    //     private static byte setStatus(boolean compress, boolean isHandshake, TransportMessage message) {
-    //         byte status = 0;
-    //         status = TransportStatus.setRequest(status);
-    //         if (compress && ProtobufOutboundMessage.canCompress(message)) {
-    //             status = TransportStatus.setCompress(status);
-    //         }
-    //         if (isHandshake) {
-    //             status = TransportStatus.setHandshake(status);
-    //         }
-
-    //         return status;
-    //     }
-    // }
-
-    // /**
-    //  * Internal message response
-    // *
-    // * @opensearch.internal
-    // */
-    // static class Response extends ProtobufOutboundMessage {
-
-    //     private final Set<String> features;
-
-    //     Response(
-    //         ThreadContext threadContext,
-    //         Set<String> features,
-    //         TransportMessage message,
-    //         Version version,
-    //         long requestId,
-    //         boolean isHandshake,
-    //         boolean compress
-    //     ) {
-    //         super(threadContext, version, setStatus(compress, isHandshake, message), requestId, message);
-    //         this.features = features;
-    //     }
-
-    //     @Override
-    //     protected void writeVariableHeader(StreamOutput stream) throws IOException {
-    //         // super.writeVariableHeader(out);
-    //         // ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-    //         // protobufStreamOutput.setFeatures(features);
-    //         super.writeVariableHeader(stream);
-    //         stream.setFeatures(features);
-    //     }
-
-    //     private static byte setStatus(boolean compress, boolean isHandshake, TransportMessage message) {
-    //         byte status = 0;
-    //         status = TransportStatus.setResponse(status);
-    //         // if (message instanceof RemoteTransportException) {
-    //         //     status = TransportStatus.setError(status);
-    //         // }
-    //         if (compress) {
-    //             status = TransportStatus.setCompress(status);
-    //         }
-    //         if (isHandshake) {
-    //             status = TransportStatus.setHandshake(status);
-    //         }
-
-    //         return status;
-    //     }
-    // }
-
-    // private static boolean canCompress(TransportMessage message) {
-    //     return message instanceof ProtobufBytesTransportRequest == false;
-    // }
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufPlainTransportFuture.java b/server/src/main/java/org/opensearch/transport/ProtobufPlainTransportFuture.java
index 24ae8cc4c84ec..d7d05e7703721 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufPlainTransportFuture.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufPlainTransportFuture.java
@@ -113,4 +113,9 @@ public void handleException(TransportException exp) {
         // TODO Auto-generated method stub
         throw new UnsupportedOperationException("Unimplemented method 'handleException'");
     }
+
+    @Override
+    public V read(byte[] in) throws IOException {
+        return handler.read(in);
+    }
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java
index b1933e08fd610..3731e608197f0 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java
@@ -56,7 +56,7 @@ protected <Request extends ProtobufActionRequest, Response extends ProtobufActio
                 action.name(),
                 request,
                 TransportRequestOptions.EMPTY,
-                new ProtobufActionListenerResponseHandler<>(listener, action.getResponseReader())
+                new ProtobufActionListenerResponseHandler<>(listener, action.getResponseReaderTry())
             );
         }, listener::onFailure));
     }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
index 66ece62dc5a67..695d49660b3ed 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
@@ -168,6 +168,11 @@ public void handleException(TransportException exp) {
                             // TODO Auto-generated method stub
                             throw new UnsupportedOperationException("Unimplemented method 'handleException'");
                         }
+
+                        @Override
+                        public ProtobufClusterStateResponse read(byte[] in) throws IOException {
+                            return new ProtobufClusterStateResponse(in);
+                        }
                     }
                 );
             }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java
deleted file mode 100644
index 38d658aacafa7..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionManager.java
+++ /dev/null
@@ -1,222 +0,0 @@
-// /*
-// * 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.
-// */
-
-// package org.opensearch.transport;
-
-// import org.opensearch.Version;
-// import org.opensearch.action.ActionListener;
-// import org.opensearch.cluster.node.DiscoveryNode;
-
-// import java.io.IOException;
-// import java.util.ArrayList;
-// import java.util.Collections;
-// import java.util.List;
-// import java.util.Set;
-// import java.util.concurrent.atomic.AtomicLong;
-
-// /**
-//  * Manager for connecting to remote nodes
-// *
-// * @opensearch.internal
-// */
-// public class ProtobufRemoteConnectionManager implements ConnectionManager {
-
-//     private final String clusterAlias;
-//     private final ConnectionManager delegate;
-//     private final AtomicLong counter = new AtomicLong();
-//     private volatile List<DiscoveryNode> connectedNodes = Collections.emptyList();
-
-//     ProtobufRemoteConnectionManager(String clusterAlias, ConnectionManager delegate) {
-//         this.clusterAlias = clusterAlias;
-//         this.delegate = delegate;
-//         this.delegate.addListener(new TransportConnectionListener() {
-//             @Override
-//             public void onNodeConnected(DiscoveryNode node, Transport.Connection connection) {
-//                 addConnectedNode(node);
-//             }
-
-//             @Override
-//             public void onNodeDisconnected(DiscoveryNode node, Transport.Connection connection) {
-//                 removeConnectedNode(node);
-//             }
-//         });
-//     }
-
-//     @Override
-//     public void connectToNode(
-//         DiscoveryNode node,
-//         ConnectionProfile connectionProfile,
-//         ConnectionManager.ConnectionValidator connectionValidator,
-//         ActionListener<Void> listener
-//     ) throws ConnectTransportException {
-//         delegate.connectToNode(node, connectionProfile, connectionValidator, listener);
-//     }
-
-//     @Override
-//     public void addListener(TransportConnectionListener listener) {
-//         delegate.addListener(listener);
-//     }
-
-//     @Override
-//     public void removeListener(TransportConnectionListener listener) {
-//         delegate.removeListener(listener);
-//     }
-
-//     @Override
-//     public void openConnection(
-//         DiscoveryNode node,
-//         ConnectionProfile profile,
-//         ActionListener<Transport.Connection> listener
-//     ) {
-//         delegate.openConnection(node, profile, listener);
-//     }
-
-//     @Override
-//     public Transport.Connection getConnection(DiscoveryNode node) {
-//         try {
-//             return delegate.getConnection(node);
-//         } catch (NodeNotConnectedException e) {
-//             return new ProxyConnection(getAnyRemoteConnection(), node);
-//         }
-//     }
-
-//     @Override
-//     public boolean nodeConnected(DiscoveryNode node) {
-//         return delegate.nodeConnected(node);
-//     }
-
-//     @Override
-//     public void disconnectFromNode(DiscoveryNode node) {
-//         delegate.disconnectFromNode(node);
-//     }
-
-//     @Override
-//     public ConnectionProfile getConnectionProfile() {
-//         return delegate.getConnectionProfile();
-//     }
-
-//     public Transport.Connection getAnyRemoteConnection() {
-//         List<DiscoveryNode> localConnectedNodes = this.connectedNodes;
-//         long curr;
-//         while ((curr = counter.incrementAndGet()) == Long.MIN_VALUE)
-//             ;
-//         if (localConnectedNodes.isEmpty() == false) {
-//             DiscoveryNode nextNode = localConnectedNodes.get(Math.toIntExact(Math.floorMod(curr, (long) localConnectedNodes.size())));
-//             try {
-//                 return delegate.getConnection(nextNode);
-//             } catch (NodeNotConnectedException e) {
-//                 // Ignore. We will manually create an iterator of open nodes
-//             }
-//         }
-//         Set<DiscoveryNode> allConnectionNodes = getAllConnectedNodes();
-//         for (DiscoveryNode connectedNode : allConnectionNodes) {
-//             try {
-//                 return delegate.getConnection(connectedNode);
-//             } catch (NodeNotConnectedException e) {
-//                 // Ignore. We will try the next one until all are exhausted.
-//             }
-//         }
-//         throw new NoSuchRemoteClusterException(clusterAlias);
-//     }
-
-//     @Override
-//     public Set<DiscoveryNode> getAllConnectedNodes() {
-//         return delegate.getAllConnectedNodes();
-//     }
-
-//     @Override
-//     public int size() {
-//         return delegate.size();
-//     }
-
-//     @Override
-//     public void close() {
-//         delegate.closeNoBlock();
-//     }
-
-//     @Override
-//     public void closeNoBlock() {
-//         delegate.closeNoBlock();
-//     }
-
-//     private synchronized void addConnectedNode(DiscoveryNode addedNode) {
-//         ArrayList<DiscoveryNode> newConnections = new ArrayList<>(this.connectedNodes);
-//         newConnections.add(addedNode);
-//         this.connectedNodes = Collections.unmodifiableList(newConnections);
-//     }
-
-//     private synchronized void removeConnectedNode(DiscoveryNode removedNode) {
-//         int newSize = this.connectedNodes.size() - 1;
-//         ArrayList<DiscoveryNode> newConnectedNodes = new ArrayList<>(newSize);
-//         for (DiscoveryNode connectedNode : this.connectedNodes) {
-//             if (connectedNode.equals(removedNode) == false) {
-//                 newConnectedNodes.add(connectedNode);
-//             }
-//         }
-//         assert newConnectedNodes.size() == newSize : "Expected connection node count: " + newSize + ", Found: " + newConnectedNodes.size();
-//         this.connectedNodes = Collections.unmodifiableList(newConnectedNodes);
-//     }
-
-//     static final class ProxyConnection implements Transport.Connection {
-//         private final Transport.Connection connection;
-//         private final DiscoveryNode targetNode;
-
-//         private ProxyConnection(Transport.Connection connection, DiscoveryNode targetNode) {
-//             this.connection = connection;
-//             this.targetNode = targetNode;
-//         }
-
-//         @Override
-//         public DiscoveryNode getNode() {
-//             return targetNode;
-//         }
-
-//         @Override
-//         public void sendRequestProtobuf(long requestId, String action, ProtobufTransportRequest request, TransportRequestOptions options)
-//             throws IOException, TransportException {
-//             connection.sendRequestProtobuf(
-//                 requestId,
-//                 ProtobufTransportActionProxy.getProxyAction(action),
-//                 ProtobufTransportActionProxy.wrapRequest(targetNode, request),
-//                 options
-//             );
-//         }
-
-//         @Override
-//         public void close() {
-//             assert false : "proxy connections must not be closed";
-//         }
-
-//         @Override
-//         public void addCloseListener(ActionListener<Void> listener) {
-//             connection.addCloseListener(listener);
-//         }
-
-//         @Override
-//         public boolean isClosed() {
-//             return connection.isClosed();
-//         }
-
-//         @Override
-//         public Version getVersion() {
-//             return connection.getVersion();
-//         }
-
-//         @Override
-//         public Object getCacheKey() {
-//             return connection.getCacheKey();
-//         }
-
-//         @Override
-//         public void sendRequest(long requestId, String action, TransportRequest request,
-//                 TransportRequestOptions options) throws IOException, TransportException {
-//             // TODO Auto-generated method stub
-//             throw new UnsupportedOperationException("Unimplemented method 'sendRequest'");
-//         }
-//     }
-// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
index f197e8405db89..1fd59deef7586 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
@@ -62,7 +62,10 @@ public Request newRequest(CodedInputStream in) throws IOException {
 
     public void processMessageReceived(Request request, TransportChannel channel) throws Exception {
         System.out.println("ProtobufRequestHandlerRegistry.processMessageReceived");
+        System.out.println("request: " + request);
+        System.out.println("channel: " + channel);
         final ProtobufTask task = taskManager.registerProtobuf(channel.getChannelType(), action, request);
+        System.out.println("task: " + task);
         ThreadContext.StoredContext contextToRestore = taskManager.protobufTaskExecutionStarted(task);
 
         Releasable unregisterTask = () -> taskManager.unregisterProtobufTask(task);
@@ -74,6 +77,7 @@ public void processMessageReceived(Request request, TransportChannel channel) th
                 // Math.max(0, System.currentTimeMillis() - ((ShardSearchRequest) request).getInboundNetworkTime())
                 // );
                 // }
+                System.out.println("Inside if for processMessageReceived");
                 final TcpChannel tcpChannel = ((TcpTransportChannel) channel).getChannel();
                 final Releasable stopTracking = taskManager.startProtobufTrackingCancellableChannelTask(
                     tcpChannel,
@@ -81,6 +85,7 @@ public void processMessageReceived(Request request, TransportChannel channel) th
                 );
                 unregisterTask = Releasables.wrap(unregisterTask, stopTracking);
             }
+            System.out.println("Before calling handler.messageReceived");
             final TaskTransportChannel taskTransportChannel = new TaskTransportChannel(channel, unregisterTask);
             handler.messageReceived(request, taskTransportChannel, task);
             unregisterTask = null;
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java
index 3c4fb1208120c..7562cc3825c43 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java
@@ -462,6 +462,11 @@ public void handleException(TransportException exp) {
             // TODO Auto-generated method stub
             throw new UnsupportedOperationException("Unimplemented method 'handleException'");
         }
+
+        @Override
+        public ProtobufClusterStateResponse read(byte[] in) throws IOException {
+            return new ProtobufClusterStateResponse(in);
+        }
     }
 
     private Predicate<ClusterName> getRemoteClusterNamePredicate() {
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTaskTransportChannel.java b/server/src/main/java/org/opensearch/transport/ProtobufTaskTransportChannel.java
deleted file mode 100644
index 72927d10b26d7..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufTaskTransportChannel.java
+++ /dev/null
@@ -1,67 +0,0 @@
-// /*
-// * 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.
-// */
-
-// package org.opensearch.transport;
-
-// import org.opensearch.Version;
-// import org.opensearch.common.lease.Releasable;
-
-// import java.io.IOException;
-
-// /**
-//  * Transport channel for tasks
-// *
-// * @opensearch.internal
-// */
-// public class ProtobufTaskTransportChannel implements ProtobufTransportChannel {
-
-//     private final ProtobufTransportChannel channel;
-//     private final Releasable onTaskFinished;
-
-//     ProtobufTaskTransportChannel(ProtobufTransportChannel channel, Releasable onTaskFinished) {
-//         this.channel = channel;
-//         this.onTaskFinished = onTaskFinished;
-//     }
-
-//     @Override
-//     public String getProfileName() {
-//         return channel.getProfileName();
-//     }
-
-//     @Override
-//     public String getChannelType() {
-//         return channel.getChannelType();
-//     }
-
-//     @Override
-//     public void sendResponse(TransportResponse response) throws IOException {
-//         try {
-//             onTaskFinished.close();
-//         } finally {
-//             channel.sendResponse(response);
-//         }
-//     }
-
-//     @Override
-//     public void sendResponse(Exception exception) throws IOException {
-//         try {
-//             onTaskFinished.close();
-//         } finally {
-//             channel.sendResponse(exception);
-//         }
-//     }
-
-//     @Override
-//     public Version getVersion() {
-//         return channel.getVersion();
-//     }
-
-//     public ProtobufTransportChannel getChannel() {
-//         return channel;
-//     }
-// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTcpTransportChannel.java b/server/src/main/java/org/opensearch/transport/ProtobufTcpTransportChannel.java
deleted file mode 100644
index e098801534237..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufTcpTransportChannel.java
+++ /dev/null
@@ -1,110 +0,0 @@
-// /*
-// * 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.
-// */
-
-// package org.opensearch.transport;
-
-// import org.opensearch.Version;
-// import org.opensearch.common.lease.Releasable;
-// import java.io.IOException;
-// import java.util.Set;
-// import java.util.concurrent.atomic.AtomicBoolean;
-
-// /**
-//  * Channel for a TCP connection
-// *
-// * @opensearch.internal
-// */
-// public final class ProtobufTcpTransportChannel implements ProtobufTransportChannel {
-
-//     private final AtomicBoolean released = new AtomicBoolean();
-//     private final ProtobufOutboundHandler outboundHandler;
-//     private final TcpChannel channel;
-//     private final String action;
-//     private final long requestId;
-//     private final Version version;
-//     private final Set<String> features;
-//     private final boolean compressResponse;
-//     private final boolean isHandshake;
-//     private final Releasable breakerRelease;
-
-//     ProtobufTcpTransportChannel(
-//         ProtobufOutboundHandler outboundHandler,
-//         TcpChannel channel,
-//         String action,
-//         long requestId,
-//         Version version,
-//         Set<String> features,
-//         boolean compressResponse,
-//         boolean isHandshake,
-//         Releasable breakerRelease
-//     ) {
-//         this.version = version;
-//         this.features = features;
-//         this.channel = channel;
-//         this.outboundHandler = outboundHandler;
-//         this.action = action;
-//         this.requestId = requestId;
-//         this.compressResponse = compressResponse;
-//         this.isHandshake = isHandshake;
-//         this.breakerRelease = breakerRelease;
-//     }
-
-//     @Override
-//     public String getProfileName() {
-//         return channel.getProfile();
-//     }
-
-//     @Override
-//     public void sendResponse(TransportResponse response) throws IOException {
-//         try {
-//             // if (response instanceof QuerySearchResult && ((QuerySearchResult) response).getShardSearchRequest() != null) {
-//             // // update outbound network time with current time before sending response over network
-//             // ((QuerySearchResult) response).getShardSearchRequest().setOutboundNetworkTime(System.currentTimeMillis());
-//             // }
-//             outboundHandler.sendResponse(version, features, channel, requestId, action, response, compressResponse, isHandshake);
-//         } finally {
-//             release(false);
-//         }
-//     }
-
-//     @Override
-//     public void sendResponse(Exception exception) throws IOException {
-//         try {
-//             outboundHandler.sendErrorResponse(version, features, channel, requestId, action, exception);
-//         } finally {
-//             release(true);
-//         }
-//     }
-
-//     private Exception releaseBy;
-
-//     private void release(boolean isExceptionResponse) {
-//         if (released.compareAndSet(false, true)) {
-//             assert (releaseBy = new Exception()) != null; // easier to debug if it's already closed
-//             breakerRelease.close();
-//         } else if (isExceptionResponse == false) {
-//             // only fail if we are not sending an error - we might send the error triggered by the previous
-//             // sendResponse call
-//             throw new IllegalStateException("reserved bytes are already released", releaseBy);
-//         }
-//     }
-
-//     @Override
-//     public String getChannelType() {
-//         return "transport";
-//     }
-
-//     @Override
-//     public Version getVersion() {
-//         return version;
-//     }
-
-//     public TcpChannel getChannel() {
-//         return channel;
-//     }
-// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java
index ffeb0aae71ea7..297b8ba70fa01 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java
@@ -13,6 +13,7 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.tasks.ProtobufTask;
 import org.opensearch.threadpool.ThreadPool;
 
@@ -40,12 +41,12 @@ private static class ProxyRequestHandler<T extends ProxyRequest> implements Prot
 
         private final TransportService service;
         private final String action;
-        private final Function<TransportRequest, ProtobufWriteable.Reader<? extends TransportResponse>> responseFunction;
+        private final Function<TransportRequest, TryWriteable.Reader<? extends TransportResponse>> responseFunction;
 
         ProxyRequestHandler(
             TransportService service,
             String action,
-            Function<TransportRequest, ProtobufWriteable.Reader<? extends TransportResponse>> responseFunction
+            Function<TransportRequest, TryWriteable.Reader<? extends TransportResponse>> responseFunction
         ) {
             this.service = service;
             this.action = action;
@@ -72,17 +73,18 @@ public void messageReceived(T request, TransportChannel channel, ProtobufTask ta
     */
     private static class ProxyResponseHandler<T extends TransportResponse> implements TransportResponseHandler<T> {
 
-        private final ProtobufWriteable.Reader<T> reader;
+        private final TryWriteable.Reader<T> reader;
         private final TransportChannel channel;
 
-        ProxyResponseHandler(TransportChannel channel, ProtobufWriteable.Reader<T> reader) {
+        ProxyResponseHandler(TransportChannel channel, TryWriteable.Reader<T> reader) {
             this.reader = reader;
             this.channel = channel;
         }
 
         @Override
         public T read(CodedInputStream in) throws IOException {
-            return reader.read(in);
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'read'");
         }
 
         @Override
@@ -119,6 +121,11 @@ public void handleException(TransportException exp) {
             // TODO Auto-generated method stub
             throw new UnsupportedOperationException("Unimplemented method 'handleException'");
         }
+
+        @Override
+        public T read(byte[] in) throws IOException {
+            return reader.read(in);
+        }
     }
 
     /**
@@ -156,7 +163,7 @@ public void writeTo(CodedOutputStream out) throws IOException {
     public static void registerProxyActionWithDynamicResponseType(
         TransportService service,
         String action,
-        Function<TransportRequest, ProtobufWriteable.Reader<? extends TransportResponse>> responseFunction
+        Function<TransportRequest, TryWriteable.Reader<? extends TransportResponse>> responseFunction
     ) {
         ProtobufRequestHandlerRegistry<? extends TransportRequest> requestHandler = service.getRequestHandlerProtobuf(action);
         service.registerRequestHandlerProtobuf(
@@ -176,7 +183,7 @@ public static void registerProxyActionWithDynamicResponseType(
     public static void registerProxyAction(
         TransportService service,
         String action,
-        ProtobufWriteable.Reader<? extends TransportResponse> reader
+        TryWriteable.Reader<? extends TransportResponse> reader
     ) {
         ProtobufRequestHandlerRegistry<? extends TransportRequest> requestHandler = service.getRequestHandlerProtobuf(action);
         service.registerRequestHandlerProtobuf(
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportChannel.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportChannel.java
deleted file mode 100644
index 36148be7bd662..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportChannel.java
+++ /dev/null
@@ -1,56 +0,0 @@
-// /*
-// * 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.
-// */
-
-// package org.opensearch.transport;
-
-// import org.apache.logging.log4j.LogManager;
-// import org.apache.logging.log4j.Logger;
-// import org.apache.logging.log4j.message.ParameterizedMessage;
-// import org.opensearch.Version;
-
-// import java.io.IOException;
-
-// /**
-//  * A transport channel allows to send a response to a request on the channel.
-// *
-// * @opensearch.internal
-// */
-// public interface ProtobufTransportChannel {
-
-//     Logger logger = LogManager.getLogger(ProtobufTransportChannel.class);
-
-//     String getProfileName();
-
-//     String getChannelType();
-
-//     void sendResponse(TransportResponse response) throws IOException;
-
-//     void sendResponse(Exception exception) throws IOException;
-
-//     /**
-//      * Returns the version of the other party that this channel will send a response to.
-//     */
-//     default Version getVersion() {
-//         return Version.CURRENT;
-//     }
-
-//     /**
-//      * A helper method to send an exception and handle and log a subsequent exception
-//     */
-//     static void sendErrorResponse(ProtobufTransportChannel channel, String actionName, TransportRequest request, Exception e) {
-//         try {
-//             channel.sendResponse(e);
-//         } catch (Exception sendException) {
-//             sendException.addSuppressed(e);
-//             logger.warn(
-//                 () -> new ParameterizedMessage("Failed to send error response for action [{}] and request [{}]", actionName, request),
-//                 sendException
-//             );
-//         }
-//     }
-// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java
deleted file mode 100644
index 75481d6eaa6d1..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportConnectionListener.java
+++ /dev/null
@@ -1,43 +0,0 @@
-// /*
-// * 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.
-// */
-
-// package org.opensearch.transport;
-
-// import org.opensearch.cluster.node.DiscoveryNode;
-
-// /**
-//  * A listener interface that allows to react on transport events. All methods may be
-// * executed on network threads. Consumers must fork in the case of long running or blocking
-// * operations.
-// *
-// * @opensearch.internal
-// */
-// public interface ProtobufTransportConnectionListener {
-
-//     /**
-//      * Called once a connection was opened
-//     * @param connection the connection
-//     */
-//     default void onConnectionOpened(Transport.Connection connection) {}
-
-//     /**
-//      * Called once a connection ws closed.
-//     * @param connection the closed connection
-//     */
-//     default void onConnectionClosed(Transport.Connection connection) {}
-
-//     /**
-//      * Called once a node connection is opened and registered.
-//     */
-//     default void onNodeConnected(DiscoveryNode node, Transport.Connection connection) {}
-
-//     /**
-//      * Called once a node connection is closed and unregistered.
-//     */
-//     default void onNodeDisconnected(DiscoveryNode node, Transport.Connection connection) {}
-// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java
deleted file mode 100644
index 32d9c4bdb7a05..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportInterceptor.java
+++ /dev/null
@@ -1,59 +0,0 @@
-// /*
-// * 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.
-// */
-
-// package org.opensearch.transport;
-
-// import org.opensearch.cluster.node.DiscoveryNode;
-// import org.opensearch.common.io.stream.ProtobufWriteable.Reader;
-
-// /**
-//  * This interface allows plugins to intercept requests on both the sender and the receiver side.
-// *
-// * @opensearch.internal
-// */
-// public interface ProtobufTransportInterceptor {
-//     /**
-//      * This is called for each handler that is registered via
-//     * {@link ProtobufTransportService#registerRequestHandler(String, String, boolean, boolean, Reader, ProtobufTransportRequestHandler)} or
-//     * {@link ProtobufTransportService#registerRequestHandler(String, String, Reader, ProtobufTransportRequestHandler)}. The returned handler is
-//     * used instead of the passed in handler. By default the provided handler is returned.
-//     */
-//     default <T extends ProtobufTransportRequest> ProtobufTransportRequestHandler<T> interceptHandler(
-//         String action,
-//         String executor,
-//         boolean forceExecution,
-//         ProtobufTransportRequestHandler<T> actualHandler
-//     ) {
-//         return actualHandler;
-//     }
-
-//     /**
-//      * This is called up-front providing the actual low level {@link AsyncSender} that performs the low level send request.
-//     * The returned sender is used to send all requests that come in via
-//     * {@link ProtobufTransportService#sendRequest(DiscoveryNode, String, ProtobufTransportRequest, TransportResponseHandler)} or
-//     * {@link ProtobufTransportService#sendRequest(DiscoveryNode, String, ProtobufTransportRequest, TransportRequestOptions, TransportResponseHandler)}.
-//     * This allows plugins to perform actions on each send request including modifying the request context etc.
-//     */
-//     default AsyncSender interceptSender(AsyncSender sender) {
-//         return sender;
-//     }
-
-//     /**
-//      * A simple interface to decorate
-//     * {@link #sendRequest(Transport.Connection, String, ProtobufTransportRequest, TransportRequestOptions, TransportResponseHandler)}
-//     */
-//     interface AsyncSender {
-//         <T extends ProtobufTransportResponse> void sendRequest(
-//             Transport.Connection connection,
-//             String action,
-//             ProtobufTransportRequest request,
-//             TransportRequestOptions options,
-//             TransportResponseHandler<T> handler
-//         );
-//     }
-// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportMessage.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportMessage.java
deleted file mode 100644
index 7f5c4e3a66e91..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportMessage.java
+++ /dev/null
@@ -1,45 +0,0 @@
-// /*
-// * 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.
-// *
-// * Modifications Copyright OpenSearch Contributors. See
-// * GitHub history for details.
-// */
-
-// package org.opensearch.transport;
-
-// import com.google.protobuf.CodedInputStream;
-// import org.opensearch.common.io.stream.ProtobufWriteable;
-// import org.opensearch.common.transport.TransportAddress;
-
-// /**
-//  * Message over the transport interface with Protobuf serialization.
-// *
-// * @opensearch.internal
-// */
-// public abstract class ProtobufTransportMessage implements ProtobufWriteable {
-
-//     private TransportAddress remoteAddress;
-
-//     public void remoteAddress(TransportAddress remoteAddress) {
-//         this.remoteAddress = remoteAddress;
-//     }
-
-//     public TransportAddress remoteAddress() {
-//         return remoteAddress;
-//     }
-
-//     /**
-//      * Constructs a new empty transport message
-//     */
-//     public ProtobufTransportMessage() {}
-
-//     /**
-//      * Constructs a new transport message with the data from the {@link CodedInputStream}. This is
-//     * currently a no-op
-//     */
-//     public ProtobufTransportMessage(CodedInputStream in) {}
-// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java
deleted file mode 100644
index e71726a8b6435..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportMessageListener.java
+++ /dev/null
@@ -1,69 +0,0 @@
-// /*
-// * 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.
-// */
-
-// package org.opensearch.transport;
-
-// import org.opensearch.cluster.node.DiscoveryNode;
-
-// /**
-//  * Listens for transport messages
-// *
-// * @opensearch.internal
-// */
-// public interface ProtobufTransportMessageListener {
-
-//     ProtobufTransportMessageListener NOOP_LISTENER = new ProtobufTransportMessageListener() {
-//     };
-
-//     /**
-//      * Called once a request is received
-//     * @param requestId the internal request ID
-//     * @param action the request action
-//     *
-//     */
-//     default void onRequestReceived(long requestId, String action) {}
-
-//     /**
-//      * Called for every action response sent after the response has been passed to the underlying network implementation.
-//     * @param requestId the request ID (unique per client)
-//     * @param action the request action
-//     * @param response the response send
-//     */
-//     default void onResponseSent(long requestId, String action, TransportResponse response) {}
-
-//     /***
-//      * Called for every failed action response after the response has been passed to the underlying network implementation.
-//     * @param requestId the request ID (unique per client)
-//     * @param action the request action
-//     * @param error the error sent back to the caller
-//     */
-//     default void onResponseSent(long requestId, String action, Exception error) {}
-
-//     /**
-//      * Called for every request sent to a server after the request has been passed to the underlying network implementation
-//     * @param node the node the request was sent to
-//     * @param requestId the internal request id
-//     * @param action the action name
-//     * @param request the actual request
-//     * @param finalOptions the request options
-//     */
-//     default void onRequestSent(
-//         DiscoveryNode node,
-//         long requestId,
-//         String action,
-//         TransportRequest request,
-//         TransportRequestOptions finalOptions
-//     ) {}
-
-//     /**
-//      * Called for every response received
-//     * @param requestId the request id for this reponse
-//     * @param context the response context or null if the context was already processed ie. due to a timeout.
-//     */
-//     default void onResponseReceived(long requestId, Transport.ProtobufResponseContext context) {}
-// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportRequest.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportRequest.java
deleted file mode 100644
index c09bddc320a85..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportRequest.java
+++ /dev/null
@@ -1,60 +0,0 @@
-// /*
-// * 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.
-// *
-// * Modifications Copyright OpenSearch Contributors. See
-// * GitHub history for details.
-// */
-
-// package org.opensearch.transport;
-
-// import com.google.protobuf.CodedInputStream;
-// import com.google.protobuf.CodedOutputStream;
-// import org.opensearch.tasks.ProtobufTaskId;
-// import org.opensearch.tasks.ProtobufTaskAwareRequest;
-// import org.opensearch.tasks.TaskId;
-
-// import java.io.IOException;
-
-// /**
-//  * A transport request with Protobuf serialization.
-// *
-// * @opensearch.internal
-// */
-// public abstract class ProtobufTransportRequest extends ProtobufTransportMessage implements ProtobufTaskAwareRequest {
-
-//     /**
-//      * Parent of this request. Defaults to {@link TaskId#EMPTY_TASK_ID}, meaning "no parent".
-//     */
-//     private ProtobufTaskId parentTaskId = ProtobufTaskId.EMPTY_TASK_ID;
-
-//     public ProtobufTransportRequest() {}
-
-//     public ProtobufTransportRequest(CodedInputStream in) throws IOException {
-//         parentTaskId = ProtobufTaskId.readFromStream(in);
-//     }
-
-//     /**
-//      * Set a reference to task that created this request.
-//     */
-//     @Override
-//     public void setParentTask(ProtobufTaskId taskId) {
-//         this.parentTaskId = taskId;
-//     }
-
-//     /**
-//      * Get a reference to the task that created this request. Defaults to {@link TaskId#EMPTY_TASK_ID}, meaning "there is no parent".
-//     */
-//     @Override
-//     public ProtobufTaskId getParentTask() {
-//         return parentTaskId;
-//     }
-
-//     @Override
-//     public void writeTo(CodedOutputStream out) throws IOException {
-//         parentTaskId.writeTo(out);
-//     }
-// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportResponse.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportResponse.java
deleted file mode 100644
index 021e6c4c52ce4..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportResponse.java
+++ /dev/null
@@ -1,59 +0,0 @@
-// /*
-// * 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.
-// */
-
-// /*
-// * Modifications Copyright OpenSearch Contributors. See
-// * GitHub history for details.
-// */
-
-// package org.opensearch.transport;
-
-// import com.google.protobuf.CodedInputStream;
-// import com.google.protobuf.CodedOutputStream;
-// import org.opensearch.common.io.stream.StreamInput;
-
-// import java.io.IOException;
-
-// /**
-//  * Response over the transport interface
-// *
-// * @opensearch.internal
-// */
-// public abstract class ProtobufTransportResponse extends ProtobufTransportMessage {
-
-//     /**
-//      * Constructs a new empty transport response
-//     */
-//     public ProtobufTransportResponse() {}
-
-//     /**
-//      * Constructs a new transport response with the data from the {@link StreamInput}. This is
-//     * currently a no-op. However, this exists to allow extenders to call <code>super(in)</code>
-//     * so that reading can mirror writing where we often call <code>super.writeTo(out)</code>.
-//     */
-//     public ProtobufTransportResponse(CodedInputStream in) throws IOException {
-//         super(in);
-//     }
-
-//     /**
-//      * Empty transport response
-//     *
-//     * @opensearch.internal
-//     */
-//     public static class Empty extends ProtobufTransportResponse {
-//         public static final Empty INSTANCE = new Empty();
-
-//         @Override
-//         public String toString() {
-//             return "Empty{}";
-//         }
-
-//         @Override
-//         public void writeTo(CodedOutputStream out) throws IOException {}
-//     }
-// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportResponseHandler.java
deleted file mode 100644
index a0c5d0745522e..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportResponseHandler.java
+++ /dev/null
@@ -1,57 +0,0 @@
-// /*
-// * 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.
-// */
-
-// package org.opensearch.transport;
-
-// import com.google.protobuf.CodedInputStream;
-// import org.opensearch.common.io.stream.ProtobufWriteable;
-
-// import java.io.IOException;
-// import java.util.function.Function;
-
-// /**
-//  * Handles transport responses
-// *
-// * @opensearch.internal
-// */
-// public interface ProtobufTransportResponseHandler<T extends TransportResponse> extends ProtobufWriteable.Reader<T> {
-
-//     void handleResponse(T response);
-
-//     void handleException(ProtobufTransportException exp);
-
-//     String executor();
-
-//     default <Q extends TransportResponse> ProtobufTransportResponseHandler<Q> wrap(
-//         Function<Q, T> converter,
-//         ProtobufWriteable.Reader<Q> reader
-//     ) {
-//         final ProtobufTransportResponseHandler<T> self = this;
-//         return new ProtobufTransportResponseHandler<Q>() {
-//             @Override
-//             public void handleResponse(Q response) {
-//                 self.handleResponse(converter.apply(response));
-//             }
-
-//             @Override
-//             public void handleException(ProtobufTransportException exp) {
-//                 self.handleException(exp);
-//             }
-
-//             @Override
-//             public String executor() {
-//                 return self.executor();
-//             }
-
-//             @Override
-//             public Q read(CodedInputStream in) throws IOException {
-//                 return reader.read(in);
-//             }
-//         };
-//     }
-// }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java
deleted file mode 100644
index d87e7443a2dfd..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportService.java
+++ /dev/null
@@ -1,1610 +0,0 @@
-// /*
-// * 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.
-// */
-
-// package org.opensearch.transport;
-
-// import com.google.protobuf.CodedInputStream;
-// import com.google.protobuf.CodedOutputStream;
-// import org.apache.logging.log4j.LogManager;
-// import org.apache.logging.log4j.Logger;
-// import org.apache.logging.log4j.message.ParameterizedMessage;
-// import org.opensearch.Version;
-// import org.opensearch.action.ActionListener;
-// import org.opensearch.action.ProtobufActionListenerResponseHandler;
-// import org.opensearch.action.support.PlainActionFuture;
-// import org.opensearch.cluster.ClusterName;
-// import org.opensearch.cluster.node.DiscoveryNode;
-// import org.opensearch.common.Nullable;
-// import org.opensearch.common.Strings;
-// import org.opensearch.common.component.AbstractLifecycleComponent;
-// import org.opensearch.common.io.stream.ProtobufStreamInput;
-// import org.opensearch.common.io.stream.ProtobufStreamOutput;
-// import org.opensearch.common.io.stream.ProtobufWriteable;
-// import org.opensearch.common.lease.Releasable;
-// import org.opensearch.common.logging.Loggers;
-// import org.opensearch.common.regex.Regex;
-// import org.opensearch.common.settings.ClusterSettings;
-// import org.opensearch.common.settings.Settings;
-// import org.opensearch.common.transport.BoundTransportAddress;
-// import org.opensearch.common.transport.BoundTransportAddress;
-// import org.opensearch.common.transport.TransportAddress;
-// import org.opensearch.common.unit.TimeValue;
-// import org.opensearch.common.util.concurrent.AbstractRunnable;
-// import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
-// import org.opensearch.common.util.concurrent.ThreadContext;
-// import org.opensearch.common.util.io.IOUtils;
-// import org.opensearch.node.ProtobufNodeClosedException;
-// import org.opensearch.node.ProtobufReportingService;
-// import org.opensearch.tasks.ProtobufTask;
-// import org.opensearch.tasks.TaskManager;
-// import org.opensearch.threadpool.Scheduler;
-// import org.opensearch.threadpool.ThreadPool;
-
-// import java.io.IOException;
-// import java.io.UncheckedIOException;
-// import java.net.UnknownHostException;
-// import java.util.Arrays;
-// import java.util.Collections;
-// import java.util.HashSet;
-// import java.util.LinkedHashMap;
-// import java.util.List;
-// import java.util.Map;
-// import java.util.Objects;
-// import java.util.Set;
-// import java.util.concurrent.CopyOnWriteArrayList;
-// import java.util.concurrent.ExecutorService;
-// import java.util.concurrent.atomic.AtomicBoolean;
-// import java.util.function.Function;
-// import java.util.function.Predicate;
-// import java.util.function.Supplier;
-
-// /**
-//  * The main OpenSearch transport service
-// *
-// * @opensearch.internal
-// */
-// public class ProtobufTransportService extends AbstractLifecycleComponent
-//     implements
-//         ProtobufReportingService<ProtobufTransportInfo>,
-//         ProtobufTransportMessageListener,
-//         TransportConnectionListener {
-//     private static final Logger logger = LogManager.getLogger(ProtobufTransportService.class);
-
-//     public static final String DIRECT_RESPONSE_PROFILE = ".direct";
-//     public static final String HANDSHAKE_ACTION_NAME = "internal:transport/handshake";
-
-//     private final AtomicBoolean handleIncomingRequests = new AtomicBoolean();
-//     private final DelegatingTransportMessageListener messageListener = new DelegatingTransportMessageListener();
-//     protected final Transport transport;
-//     protected final ConnectionManager connectionManager;
-//     protected final ThreadPool threadPool;
-//     protected final ClusterName clusterName;
-//     protected final TaskManager taskManager;
-//     private final ProtobufTransportInterceptor.AsyncSender asyncSender;
-//     private final Function<BoundTransportAddress, DiscoveryNode> localNodeFactory;
-//     private final boolean remoteClusterClient;
-//     private final Transport.ProtobufResponseHandlers responseHandlers;
-//     private final ProtobufTransportInterceptor interceptor;
-
-//     // An LRU (don't really care about concurrency here) that holds the latest timed out requests so if they
-//     // do show up, we can print more descriptive information about them
-//     final Map<Long, TimeoutInfoHolder> timeoutInfoHandlers = Collections.synchronizedMap(
-//         new LinkedHashMap<Long, TimeoutInfoHolder>(100, .75F, true) {
-//             @Override
-//             protected boolean removeEldestEntry(Map.Entry eldest) {
-//                 return size() > 100;
-//             }
-//         }
-//     );
-
-//     public static final ProtobufTransportInterceptor NOOP_TRANSPORT_INTERCEPTOR = new ProtobufTransportInterceptor() {
-//     };
-
-//     // tracer log
-
-//     private final Logger tracerLog;
-
-//     volatile String[] tracerLogInclude;
-//     volatile String[] tracerLogExclude;
-
-//     private final RemoteClusterService remoteClusterService;
-
-//     /** if set will call requests sent to this id to shortcut and executed locally */
-//     volatile DiscoveryNode localNode = null;
-//     private final Transport.Connection localNodeConnection = new Transport.Connection() {
-//         @Override
-//         public DiscoveryNode getNode() {
-//             return localNode;
-//         }
-
-//         @Override
-//         public void sendRequestProtobuf(long requestId, String action, TransportRequest request, TransportRequestOptions options)
-//             throws ProtobufTransportException {
-//             sendLocalRequest(requestId, action, request, options);
-//         }
-
-//         @Override
-//         public void addCloseListener(ActionListener<Void> listener) {}
-
-//         @Override
-//         public boolean isClosed() {
-//             return false;
-//         }
-
-//         @Override
-//         public void close() {}
-
-//         @Override
-//         public void sendRequest(long requestId, String action, TransportRequest request,
-//                 TransportRequestOptions options) throws IOException, TransportException {
-//             // TODO Auto-generated method stub
-//             throw new UnsupportedOperationException("Unimplemented method 'sendRequest'");
-//         }
-//     };
-
-//     /**
-//      * Build the service.
-//     *
-//     * @param clusterSettings if non null, the {@linkplain ProtobufTransportService} will register with the {@link ClusterSettings} for settings
-//     *   *    updates for {@link TransportSettings#TRACE_LOG_EXCLUDE_SETTING} and {@link TransportSettings#TRACE_LOG_INCLUDE_SETTING}.
-//     */
-//     public ProtobufTransportService(
-//         Settings settings,
-//         Transport transport,
-//         ThreadPool threadPool,
-//         ProtobufTransportInterceptor transportInterceptor,
-//         Function<BoundTransportAddress, DiscoveryNode> localNodeFactory,
-//         @Nullable ClusterSettings clusterSettings,
-//         Set<String> taskHeaders
-//     ) {
-//         this(
-//             settings,
-//             transport,
-//             threadPool,
-//             transportInterceptor,
-//             localNodeFactory,
-//             clusterSettings,
-//             taskHeaders,
-//             new ClusterConnectionManager(settings, transport)
-//         );
-//     }
-
-//     public ProtobufTransportService(
-//         Settings settings,
-//         Transport transport,
-//         ThreadPool threadPool,
-//         ProtobufTransportInterceptor transportInterceptor,
-//         Function<BoundTransportAddress, DiscoveryNode> localNodeFactory,
-//         @Nullable ClusterSettings clusterSettings,
-//         Set<String> taskHeaders,
-//         ConnectionManager connectionManager
-//     ) {
-//         this.transport = transport;
-//         transport.setSlowLogThreshold(TransportSettings.SLOW_OPERATION_THRESHOLD_SETTING.get(settings));
-//         this.threadPool = threadPool;
-//         this.localNodeFactory = localNodeFactory;
-//         this.connectionManager = connectionManager;
-//         this.clusterName = ClusterName.CLUSTER_NAME_SETTING.get(settings);
-//         setTracerLogInclude(TransportSettings.TRACE_LOG_INCLUDE_SETTING.get(settings));
-//         setTracerLogExclude(TransportSettings.TRACE_LOG_EXCLUDE_SETTING.get(settings));
-//         tracerLog = Loggers.getLogger(logger, ".tracer");
-//         taskManager = createTaskManager(settings, clusterSettings, threadPool, taskHeaders);
-//         this.interceptor = transportInterceptor;
-//         this.asyncSender = interceptor.interceptSender(this::sendRequestInternal);
-//         this.remoteClusterClient = DiscoveryNode.isRemoteClusterClient(settings);
-//         remoteClusterService = new RemoteClusterService(settings, this);
-//         responseHandlers = transport.getProtobufResponseHandlers();
-//         if (clusterSettings != null) {
-//             clusterSettings.addSettingsUpdateConsumer(TransportSettings.TRACE_LOG_INCLUDE_SETTING, this::setTracerLogInclude);
-//             clusterSettings.addSettingsUpdateConsumer(TransportSettings.TRACE_LOG_EXCLUDE_SETTING, this::setTracerLogExclude);
-//             if (remoteClusterClient) {
-//                 remoteClusterService.listenForUpdates(clusterSettings);
-//             }
-//             clusterSettings.addSettingsUpdateConsumer(TransportSettings.SLOW_OPERATION_THRESHOLD_SETTING, transport::setSlowLogThreshold);
-//         }
-//         registerRequestHandler(
-//             HANDSHAKE_ACTION_NAME,
-//             ThreadPool.Names.SAME,
-//             false,
-//             false,
-//             HandshakeRequest::new,
-//             (request, channel, task) -> channel.sendResponse(new HandshakeResponse(localNode, clusterName, localNode.getVersion()))
-//         );
-//     }
-
-//     public RemoteClusterService getRemoteClusterService() {
-//         return remoteClusterService;
-//     }
-
-//     public DiscoveryNode getLocalNode() {
-//         return localNode;
-//     }
-
-//     public TaskManager getTaskManager() {
-//         return taskManager;
-//     }
-
-//     protected TaskManager createTaskManager(
-//         Settings settings,
-//         ClusterSettings clusterSettings,
-//         ThreadPool threadPool,
-//         Set<String> taskHeaders
-//     ) {
-//         if (clusterSettings != null) {
-//             return TaskManager.createTaskManagerWithClusterSettings(settings, clusterSettings, threadPool, taskHeaders);
-//         } else {
-//             return new TaskManager(settings, threadPool, taskHeaders);
-//         }
-//     }
-
-//     /**
-//      * The executor service for this transport service.
-//     *
-//     * @return the executor service
-//     */
-//     private ExecutorService getExecutorService() {
-//         return threadPool.generic();
-//     }
-
-//     void setTracerLogInclude(List<String> tracerLogInclude) {
-//         this.tracerLogInclude = tracerLogInclude.toArray(Strings.EMPTY_ARRAY);
-//     }
-
-//     void setTracerLogExclude(List<String> tracerLogExclude) {
-//         this.tracerLogExclude = tracerLogExclude.toArray(Strings.EMPTY_ARRAY);
-//     }
-
-//     @Override
-//     protected void doStart() {
-//         transport.setMessageListenerProtobuf(this);
-//         connectionManager.addListener(this);
-//         transport.start();
-//         if (transport.boundAddress() != null && logger.isInfoEnabled()) {
-//             logger.info("{}", transport.boundAddress());
-//             for (Map.Entry<String, BoundTransportAddress> entry : transport.profileBoundAddresses().entrySet()) {
-//                 logger.info("profile [{}]: {}", entry.getKey(), entry.getValue());
-//             }
-//         }
-
-//         localNode = localNodeFactory.apply(transport.boundAddress());
-
-//         if (remoteClusterClient) {
-//             // here we start to connect to the remote clusters
-//             remoteClusterService.initializeRemoteClusters();
-//         }
-//     }
-
-//     public void setLocalNode(DiscoveryNode localNode) {
-//         this.localNode = localNode;
-//     }
-
-//     @Override
-//     protected void doStop() {
-//         try {
-//             IOUtils.close(connectionManager, remoteClusterService, transport::stop);
-//         } catch (IOException e) {
-//             throw new UncheckedIOException(e);
-//         } finally {
-//             // in case the transport is not connected to our local node (thus cleaned on node disconnect)
-//             // make sure to clean any leftover on going handles
-//             for (final Transport.ProtobufResponseContext holderToNotify : responseHandlers.prune(h -> true)) {
-//                 // callback that an exception happened, but on a different thread since we don't
-//                 // want handlers to worry about stack overflows
-//                 getExecutorService().execute(new AbstractRunnable() {
-//                     @Override
-//                     public void onRejection(Exception e) {
-//                         // if we get rejected during node shutdown we don't wanna bubble it up
-//                         logger.debug(
-//                             () -> new ParameterizedMessage(
-//                                 "failed to notify response handler on rejection, action: {}",
-//                                 holderToNotify.action()
-//                             ),
-//                             e
-//                         );
-//                     }
-
-//                     @Override
-//                     public void onFailure(Exception e) {
-//                         logger.warn(
-//                             () -> new ParameterizedMessage(
-//                                 "failed to notify response handler on exception, action: {}",
-//                                 holderToNotify.action()
-//                             ),
-//                             e
-//                         );
-//                     }
-
-//                     @Override
-//                     public void doRun() {
-//                         ProtobufTransportException ex = new ProtobufSendRequestTransportException(
-//                             holderToNotify.connection().getNode(),
-//                             holderToNotify.action(),
-//                             new ProtobufNodeClosedException(localNode)
-//                         );
-//                         holderToNotify.handler().handleException(ex);
-//                     }
-//                 });
-//             }
-//         }
-//     }
-
-//     @Override
-//     protected void doClose() throws IOException {
-//         transport.close();
-//     }
-
-//     /**
-//      * start accepting incoming requests.
-//     * when the transport layer starts up it will block any incoming requests until
-//     * this method is called
-//     */
-//     public final void acceptIncomingRequests() {
-//         handleIncomingRequests.set(true);
-//     }
-
-//     @Override
-//     public ProtobufTransportInfo protobufInfo() {
-//         BoundTransportAddress boundTransportAddress = boundAddress();
-//         if (boundTransportAddress == null) {
-//             return null;
-//         }
-//         return new ProtobufTransportInfo(boundTransportAddress, transport.profileBoundAddresses());
-//     }
-
-//     public ProtobufTransportStats stats() {
-//         return transport.getProtobufStats();
-//     }
-
-//     public boolean isTransportSecure() {
-//         return transport.isSecure();
-//     }
-
-//     public BoundTransportAddress boundAddress() {
-//         return transport.boundAddress();
-//     }
-
-//     public List<String> getDefaultSeedAddresses() {
-//         return transport.getDefaultSeedAddresses();
-//     }
-
-//     /**
-//      * Returns <code>true</code> iff the given node is already connected.
-//     */
-//     public boolean nodeConnected(DiscoveryNode node) {
-//         return isLocalNode(node) || connectionManager.nodeConnected(node);
-//     }
-
-//     /**
-//      * Connect to the specified node with the default connection profile
-//     *
-//     * @param node the node to connect to
-//     */
-//     public void connectToNode(DiscoveryNode node) throws ProtobufConnectTransportException {
-//         connectToNode(node, (ConnectionProfile) null);
-//     }
-
-//     // We are skipping node validation for extensibility as extensionNode and opensearchNode(LocalNode) will have different ephemeral id's
-//     public void connectToExtensionNode(final DiscoveryNode node) {
-//         PlainActionFuture.get(fut -> connectToExtensionNode(node, (ConnectionProfile) null, ActionListener.map(fut, x -> null)));
-//     }
-
-//     /**
-//      * Connect to the specified node with the given connection profile
-//     *
-//     * @param node the node to connect to
-//     * @param connectionProfile the connection profile to use when connecting to this node
-//     */
-//     public void connectToNode(final DiscoveryNode node, ConnectionProfile connectionProfile) {
-//         PlainActionFuture.get(fut -> connectToNode(node, connectionProfile, ActionListener.map(fut, x -> null)));
-//     }
-
-//     public void connectToExtensionNode(final DiscoveryNode node, ConnectionProfile connectionProfile) {
-//         PlainActionFuture.get(fut -> connectToExtensionNode(node, connectionProfile, ActionListener.map(fut, x -> null)));
-//     }
-
-//     /**
-//      * Connect to the specified node with the given connection profile.
-//     * The ActionListener will be called on the calling thread or the generic thread pool.
-//     *
-//     * @param node the node to connect to
-//     * @param listener the action listener to notify
-//     */
-//     public void connectToNode(DiscoveryNode node, ActionListener<Void> listener) throws ProtobufConnectTransportException {
-//         connectToNode(node, null, listener);
-//     }
-
-//     public void connectToExtensionNode(DiscoveryNode node, ActionListener<Void> listener) throws ProtobufConnectTransportException {
-//         connectToExtensionNode(node, null, listener);
-//     }
-
-//     /**
-//      * Connect to the specified node with the given connection profile.
-//     * The ActionListener will be called on the calling thread or the generic thread pool.
-//     *
-//     * @param node the node to connect to
-//     * @param connectionProfile the connection profile to use when connecting to this node
-//     * @param listener the action listener to notify
-//     */
-//     public void connectToNode(final DiscoveryNode node, ConnectionProfile connectionProfile, ActionListener<Void> listener) {
-//         System.out.println("ProtobufTransportService.connectToNode");
-//         if (isLocalNode(node)) {
-//             listener.onResponse(null);
-//             return;
-//         }
-//         connectionManager.connectToNode(node, connectionProfile, connectionValidator(node), listener);
-//     }
-
-//     public void connectToExtensionNode(
-//         final DiscoveryNode node,
-//         ConnectionProfile connectionProfile,
-//         ActionListener<Void> listener
-//     ) {
-//         if (isLocalNode(node)) {
-//             listener.onResponse(null);
-//             return;
-//         }
-//         connectionManager.connectToNode(node, connectionProfile, extensionConnectionValidator(node), listener);
-//     }
-
-//     public ConnectionManager.ConnectionValidator connectionValidator(DiscoveryNode node) {
-//         return (newConnection, actualProfile, listener) -> {
-//             // We don't validate cluster names to allow for CCS connections.
-//             handshake(newConnection, actualProfile.getHandshakeTimeout().millis(), cn -> true, ActionListener.map(listener, resp -> {
-//                 final DiscoveryNode remote = resp.discoveryNode;
-
-//                 if (node.equals(remote) == false) {
-//                     throw new ProtobufConnectTransportException(node, "handshake failed. unexpected remote node " + remote);
-//                 }
-
-//                 return null;
-//             }));
-//         };
-//     }
-
-//     public ConnectionManager.ConnectionValidator extensionConnectionValidator(DiscoveryNode node) {
-//         return (newConnection, actualProfile, listener) -> {
-//             // We don't validate cluster names to allow for CCS connections.
-//             handshake(newConnection, actualProfile.getHandshakeTimeout().millis(), cn -> true, ActionListener.map(listener, resp -> {
-//                 final DiscoveryNode remote = resp.discoveryNode;
-//                 logger.info("Connection validation was skipped");
-//                 return null;
-//             }));
-//         };
-//     }
-
-//     /**
-//      * Establishes and returns a new connection to the given node. The connection is NOT maintained by this service, it's the callers
-//     * responsibility to close the connection once it goes out of scope.
-//     * The ActionListener will be called on the calling thread or the generic thread pool.
-//     * @param node the node to connect to
-//     * @param connectionProfile the connection profile to use
-//     */
-//     public Transport.Connection openConnection(final DiscoveryNode node, ConnectionProfile connectionProfile) {
-//         return PlainActionFuture.get(fut -> openConnection(node, connectionProfile, fut));
-//     }
-
-//     /**
-//      * Establishes a new connection to the given node. The connection is NOT maintained by this service, it's the callers
-//     * responsibility to close the connection once it goes out of scope.
-//     * The ActionListener will be called on the calling thread or the generic thread pool.
-//     * @param node the node to connect to
-//     * @param connectionProfile the connection profile to use
-//     * @param listener the action listener to notify
-//     */
-//     public void openConnection(
-//         final DiscoveryNode node,
-//         ConnectionProfile connectionProfile,
-//         ActionListener<Transport.Connection> listener
-//     ) {
-//         if (isLocalNode(node)) {
-//             listener.onResponse(localNodeConnection);
-//         } else {
-//             connectionManager.openConnection(node, connectionProfile, listener);
-//         }
-//     }
-
-//     /**
-//      * Executes a high-level handshake using the given connection
-//     * and returns the discovery node of the node the connection
-//     * was established with. The handshake will fail if the cluster
-//     * name on the target node mismatches the local cluster name.
-//     * The ActionListener will be called on the calling thread or the generic thread pool.
-//     *
-//     * @param connection       the connection to a specific node
-//     * @param handshakeTimeout handshake timeout
-//     * @param listener         action listener to notify
-//     * @throws ProtobufConnectTransportException if the connection failed
-//     * @throws IllegalStateException if the handshake failed
-//     */
-//     public void handshake(
-//         final Transport.Connection connection,
-//         final long handshakeTimeout,
-//         final ActionListener<DiscoveryNode> listener
-//     ) {
-//         handshake(
-//             connection,
-//             handshakeTimeout,
-//             clusterName.getEqualityPredicate(),
-//             ActionListener.map(listener, HandshakeResponse::getDiscoveryNode)
-//         );
-//     }
-
-//     /**
-//      * Executes a high-level handshake using the given connection
-//     * and returns the discovery node of the node the connection
-//     * was established with. The handshake will fail if the cluster
-//     * name on the target node doesn't match the local cluster name.
-//     * The ActionListener will be called on the calling thread or the generic thread pool.
-//     *
-//     * @param connection       the connection to a specific node
-//     * @param handshakeTimeout handshake timeout
-//     * @param clusterNamePredicate cluster name validation predicate
-//     * @param listener         action listener to notify
-//     * @throws IllegalStateException if the handshake failed
-//     */
-//     public void handshake(
-//         final Transport.Connection connection,
-//         final long handshakeTimeout,
-//         Predicate<ClusterName> clusterNamePredicate,
-//         final ActionListener<HandshakeResponse> listener
-//     ) {
-//         final DiscoveryNode node = connection.getNode();
-//         sendRequest(
-//             connection,
-//             HANDSHAKE_ACTION_NAME,
-//             HandshakeRequest.INSTANCE,
-//             TransportRequestOptions.builder().withTimeout(handshakeTimeout).build(),
-//             new ProtobufActionListenerResponseHandler<>(new ActionListener<HandshakeResponse>() {
-//                 @Override
-//                 public void onResponse(HandshakeResponse response) {
-//                     if (clusterNamePredicate.test(response.clusterName) == false) {
-//                         listener.onFailure(
-//                             new IllegalStateException(
-//                                 "handshake with ["
-//                                     + node
-//                                     + "] failed: remote cluster name ["
-//                                     + response.clusterName.value()
-//                                     + "] does not match "
-//                                     + clusterNamePredicate
-//                             )
-//                         );
-//                     } else if (response.version.isCompatible(localNode.getVersion()) == false) {
-//                         listener.onFailure(
-//                             new IllegalStateException(
-//                                 "handshake with ["
-//                                     + node
-//                                     + "] failed: remote node version ["
-//                                     + response.version
-//                                     + "] is incompatible with local node version ["
-//                                     + localNode.getVersion()
-//                                     + "]"
-//                             )
-//                         );
-//                     } else {
-//                         listener.onResponse(response);
-//                     }
-//                 }
-
-//                 @Override
-//                 public void onFailure(Exception e) {
-//                     listener.onFailure(e);
-//                 }
-//             }, HandshakeResponse::new, ThreadPool.Names.GENERIC)
-//         );
-//     }
-
-//     public ConnectionManager getConnectionManager() {
-//         return connectionManager;
-//     }
-
-//     /**
-//      * Internal Handshake request
-//     *
-//     * @opensearch.internal
-//     */
-//     static class HandshakeRequest extends TransportRequest {
-
-//         public static final HandshakeRequest INSTANCE = new HandshakeRequest();
-
-//         HandshakeRequest(CodedInputStream in) throws IOException {
-//             super(in);
-//         }
-
-//         private HandshakeRequest() {}
-
-//     }
-
-//     /**
-//      * Internal handshake response
-//     *
-//     * @opensearch.internal
-//     */
-//     public static class HandshakeResponse extends TransportResponse {
-//         private final DiscoveryNode discoveryNode;
-//         private final ClusterName clusterName;
-//         private final Version version;
-
-//         public HandshakeResponse(DiscoveryNode discoveryNode, ClusterName clusterName, Version version) {
-//             this.discoveryNode = discoveryNode;
-//             this.version = version;
-//             this.clusterName = clusterName;
-//         }
-
-//         public HandshakeResponse(CodedInputStream in) throws IOException {
-//             super(in);
-//             ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-//             discoveryNode = protobufStreamInput.readOptionalWriteable(DiscoveryNode::new);
-//             clusterName = new ClusterName(in);
-//             version = Version.readVersionProtobuf(in);
-//         }
-
-//         @Override
-//         public void writeTo(CodedOutputStream out) throws IOException {
-//             ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-//             protobufStreamOutput.writeOptionalWriteable(discoveryNode);
-//             clusterName.writeTo(out);
-//             out.writeInt32NoTag(version.id);
-//         }
-
-//         public DiscoveryNode getDiscoveryNode() {
-//             return discoveryNode;
-//         }
-
-//         public ClusterName getClusterName() {
-//             return clusterName;
-//         }
-//     }
-
-//     public void disconnectFromNode(DiscoveryNode node) {
-//         if (isLocalNode(node)) {
-//             return;
-//         }
-//         connectionManager.disconnectFromNode(node);
-//     }
-
-//     public void addMessageListener(ProtobufTransportMessageListener listener) {
-//         messageListener.listeners.add(listener);
-//     }
-
-//     public boolean removeMessageListener(ProtobufTransportMessageListener listener) {
-//         return messageListener.listeners.remove(listener);
-//     }
-
-//     public void addConnectionListener(TransportConnectionListener listener) {
-//         connectionManager.addListener(listener);
-//     }
-
-//     public void removeConnectionListener(TransportConnectionListener listener) {
-//         connectionManager.removeListener(listener);
-//     }
-
-//     public <T extends TransportResponse> TransportFuture<T> submitRequest(
-//         DiscoveryNode node,
-//         String action,
-//         TransportRequest request,
-//         ProtobufTransportResponseHandler<T> handler
-//     ) throws ProtobufTransportException {
-//         return submitRequest(node, action, request, TransportRequestOptions.EMPTY, handler);
-//     }
-
-//     public <T extends TransportResponse> TransportFuture<T> submitRequest(
-//         DiscoveryNode node,
-//         String action,
-//         TransportRequest request,
-//         TransportRequestOptions options,
-//         ProtobufTransportResponseHandler<T> handler
-//     ) throws ProtobufTransportException {
-//         ProtobufPlainTransportFuture<T> futureHandler = new ProtobufPlainTransportFuture<>(handler);
-//         try {
-//             Transport.Connection connection = getConnection(node);
-//             sendRequest(connection, action, request, options, futureHandler);
-//         } catch (ProtobufNodeNotConnectedException ex) {
-//             // the caller might not handle this so we invoke the handler
-//             futureHandler.handleException(ex);
-//         }
-//         return futureHandler;
-//     }
-
-//     public <T extends TransportResponse> void sendRequest(
-//         final DiscoveryNode node,
-//         final String action,
-//         final TransportRequest request,
-//         final ProtobufTransportResponseHandler<T> handler
-//     ) {
-//         final Transport.Connection connection;
-//         try {
-//             connection = getConnection(node);
-//         } catch (final ProtobufNodeNotConnectedException ex) {
-//             // the caller might not handle this so we invoke the handler
-//             handler.handleException(ex);
-//             return;
-//         }
-//         sendRequest(connection, action, request, TransportRequestOptions.EMPTY, handler);
-//     }
-
-//     public final <T extends TransportResponse> void sendRequest(
-//         final DiscoveryNode node,
-//         final String action,
-//         final TransportRequest request,
-//         final TransportRequestOptions options,
-//         ProtobufTransportResponseHandler<T> handler
-//     ) {
-//         final Transport.Connection connection;
-//         try {
-//             connection = getConnection(node);
-//         } catch (final ProtobufNodeNotConnectedException ex) {
-//             // the caller might not handle this so we invoke the handler
-//             handler.handleException(ex);
-//             return;
-//         }
-//         sendRequest(connection, action, request, options, handler);
-//     }
-
-//     /**
-//      * Sends a request on the specified connection. If there is a failure sending the request, the specified handler is invoked.
-//     *
-//     * @param connection the connection to send the request on
-//     * @param action     the name of the action
-//     * @param request    the request
-//     * @param options    the options for this request
-//     * @param handler    the response handler
-//     * @param <T>        the type of the transport response
-//     */
-//     public final <T extends TransportResponse> void sendRequest(
-//         final Transport.Connection connection,
-//         final String action,
-//         final TransportRequest request,
-//         final TransportRequestOptions options,
-//         final ProtobufTransportResponseHandler<T> handler
-//     ) {
-//         try {
-//             logger.debug("Action: " + action);
-//             final ProtobufTransportResponseHandler<T> delegate;
-//             if (request.getParentTask().isSet()) {
-//                 // TODO: capture the connection instead so that we can cancel child tasks on the remote connections.
-//                 final Releasable unregisterChildNode = taskManager.registerProtobufChildNode(
-//                     request.getParentTask().getId(),
-//                     connection.getNode()
-//                 );
-//                 delegate = new ProtobufTransportResponseHandler<T>() {
-//                     @Override
-//                     public void handleResponse(T response) {
-//                         unregisterChildNode.close();
-//                         handler.handleResponse(response);
-//                     }
-
-//                     @Override
-//                     public void handleException(ProtobufTransportException exp) {
-//                         unregisterChildNode.close();
-//                         handler.handleException(exp);
-//                     }
-
-//                     @Override
-//                     public String executor() {
-//                         return handler.executor();
-//                     }
-
-//                     @Override
-//                     public T read(CodedInputStream in) throws IOException {
-//                         return handler.read(in);
-//                     }
-
-//                     @Override
-//                     public String toString() {
-//                         return getClass().getName() + "/[" + action + "]:" + handler.toString();
-//                     }
-//                 };
-//             } else {
-//                 delegate = handler;
-//             }
-//             asyncSender.sendRequest(connection, action, request, options, delegate);
-//         } catch (final Exception ex) {
-//             // the caller might not handle this so we invoke the handler
-//             final ProtobufTransportException te;
-//             if (ex instanceof ProtobufTransportException) {
-//                 te = (ProtobufTransportException) ex;
-//             } else {
-//                 te = new ProtobufTransportException("failure to send", ex);
-//             }
-//             handler.handleException(te);
-//         }
-//     }
-
-//     /**
-//      * Returns either a real transport connection or a local node connection if we are using the local node optimization.
-//     * @throws ProtobufNodeNotConnectedException if the given node is not connected
-//     */
-//     public Transport.Connection getConnection(DiscoveryNode node) {
-//         System.out.println("Protobuf transport service");
-//         System.out.println("Getting connection for node " + node);
-//         if (isLocalNode(node)) {
-//             System.out.println("Is local node");
-//             return localNodeConnection;
-//         } else {
-//             System.out.println("Not local node");
-//             return connectionManager.getConnection(node);
-//         }
-//     }
-
-//     public final <T extends TransportResponse> void sendChildRequest(
-//         final DiscoveryNode node,
-//         final String action,
-//         final TransportRequest request,
-//         final ProtobufTask parentTask,
-//         final TransportRequestOptions options,
-//         final ProtobufTransportResponseHandler<T> handler
-//     ) {
-//         final Transport.Connection connection;
-//         try {
-//             connection = getConnection(node);
-//         } catch (final ProtobufNodeNotConnectedException ex) {
-//             // the caller might not handle this so we invoke the handler
-//             handler.handleException(ex);
-//             return;
-//         }
-//         sendChildRequest(connection, action, request, parentTask, options, handler);
-//     }
-
-//     public <T extends TransportResponse> void sendChildRequest(
-//         final Transport.Connection connection,
-//         final String action,
-//         final TransportRequest request,
-//         final ProtobufTask parentTask,
-//         final ProtobufTransportResponseHandler<T> handler
-//     ) {
-//         sendChildRequest(connection, action, request, parentTask, TransportRequestOptions.EMPTY, handler);
-//     }
-
-//     public <T extends TransportResponse> void sendChildRequest(
-//         final Transport.Connection connection,
-//         final String action,
-//         final TransportRequest request,
-//         final ProtobufTask parentTask,
-//         final TransportRequestOptions options,
-//         final ProtobufTransportResponseHandler<T> handler
-//     ) {
-//         request.setParentTask(localNode.getId(), parentTask.getId());
-//         sendRequest(connection, action, request, options, handler);
-//     }
-
-//     private <T extends TransportResponse> void sendRequestInternal(
-//         final Transport.Connection connection,
-//         final String action,
-//         final TransportRequest request,
-//         final TransportRequestOptions options,
-//         ProtobufTransportResponseHandler<T> handler
-//     ) {
-//         if (connection == null) {
-//             throw new IllegalStateException("can't send request to a null connection");
-//         }
-//         DiscoveryNode node = connection.getNode();
-
-//         Supplier<ThreadContext.StoredContext> storedContextSupplier = threadPool.getThreadContext().newRestorableContext(true);
-//         ContextRestoreResponseHandler<T> responseHandler = new ContextRestoreResponseHandler<>(storedContextSupplier, handler);
-//         // TODO we can probably fold this entire request ID dance into connection.sendReqeust but it will be a bigger refactoring
-//         final long requestId = responseHandlers.add(new Transport.ProtobufResponseContext<>(responseHandler, connection, action));
-//         final TimeoutHandler timeoutHandler;
-//         if (options.timeout() != null) {
-//             timeoutHandler = new TimeoutHandler(requestId, connection.getNode(), action);
-//             responseHandler.setTimeoutHandler(timeoutHandler);
-//         } else {
-//             timeoutHandler = null;
-//         }
-//         try {
-//             if (lifecycle.stoppedOrClosed()) {
-//                 /*
-//                 * If we are not started the exception handling will remove the request holder again and calls the handler to notify the
-//                 * caller. It will only notify if toStop hasn't done the work yet.
-//                 */
-//                 throw new ProtobufNodeClosedException(localNode);
-//             }
-//             if (timeoutHandler != null) {
-//                 assert options.timeout() != null;
-//                 timeoutHandler.scheduleTimeout(options.timeout());
-//             }
-//             connection.sendRequestProtobuf(requestId, action, request, options); // local node optimization happens upstream
-//         } catch (final Exception e) {
-//             // usually happen either because we failed to connect to the node
-//             // or because we failed serializing the message
-//             final Transport.ProtobufResponseContext<? extends TransportResponse> contextToNotify = responseHandlers.remove(
-//                 requestId
-//             );
-//             // If holderToNotify == null then handler has already been taken care of.
-//             if (contextToNotify != null) {
-//                 if (timeoutHandler != null) {
-//                     timeoutHandler.cancel();
-//                 }
-//                 // callback that an exception happened, but on a different thread since we don't
-//                 // want handlers to worry about stack overflows. In the special case of running into a closing node we run on the current
-//                 // thread on a best effort basis though.
-//                 final ProtobufSendRequestTransportException sendRequestException = new ProtobufSendRequestTransportException(
-//                     node,
-//                     action,
-//                     e
-//                 );
-//                 final String executor = lifecycle.stoppedOrClosed() ? ThreadPool.Names.SAME : ThreadPool.Names.GENERIC;
-//                 threadPool.executor(executor).execute(new AbstractRunnable() {
-//                     @Override
-//                     public void onRejection(Exception e) {
-//                         // if we get rejected during node shutdown we don't wanna bubble it up
-//                         logger.debug(
-//                             () -> new ParameterizedMessage(
-//                                 "failed to notify response handler on rejection, action: {}",
-//                                 contextToNotify.action()
-//                             ),
-//                             e
-//                         );
-//                     }
-
-//                     @Override
-//                     public void onFailure(Exception e) {
-//                         logger.warn(
-//                             () -> new ParameterizedMessage(
-//                                 "failed to notify response handler on exception, action: {}",
-//                                 contextToNotify.action()
-//                             ),
-//                             e
-//                         );
-//                     }
-
-//                     @Override
-//                     protected void doRun() throws Exception {
-//                         contextToNotify.handler().handleException(sendRequestException);
-//                     }
-//                 });
-//             } else {
-//                 logger.debug("Exception while sending request, handler likely already notified due to timeout", e);
-//             }
-//         }
-//     }
-
-//     private void sendLocalRequest(
-//         long requestId,
-//         final String action,
-//         final TransportRequest request,
-//         TransportRequestOptions options
-//     ) {
-//         final DirectResponseChannel channel = new DirectResponseChannel(localNode, action, requestId, this, threadPool);
-//         try {
-//             onRequestSent(localNode, requestId, action, request, options);
-//             onRequestReceived(requestId, action);
-//             final ProtobufRequestHandlerRegistry reg = getRequestHandler(action);
-//             if (reg == null) {
-//                 throw new ActionNotFoundTransportException("Action [" + action + "] not found");
-//             }
-//             final String executor = reg.getExecutor();
-//             if (ThreadPool.Names.SAME.equals(executor)) {
-//                 // noinspection unchecked
-//                 reg.processMessageReceived(request, channel);
-//             } else {
-//                 threadPool.executor(executor).execute(new AbstractRunnable() {
-//                     @Override
-//                     protected void doRun() throws Exception {
-//                         // noinspection unchecked
-//                         reg.processMessageReceived(request, channel);
-//                     }
-
-//                     @Override
-//                     public boolean isForceExecution() {
-//                         return reg.isForceExecution();
-//                     }
-
-//                     @Override
-//                     public void onFailure(Exception e) {
-//                         try {
-//                             channel.sendResponse(e);
-//                         } catch (Exception inner) {
-//                             inner.addSuppressed(e);
-//                             logger.warn(
-//                                 () -> new ParameterizedMessage("failed to notify channel of error message for action [{}]", action),
-//                                 inner
-//                             );
-//                         }
-//                     }
-
-//                     @Override
-//                     public String toString() {
-//                         return "processing of [" + requestId + "][" + action + "]: " + request;
-//                     }
-//                 });
-//             }
-
-//         } catch (Exception e) {
-//             try {
-//                 channel.sendResponse(e);
-//             } catch (Exception inner) {
-//                 inner.addSuppressed(e);
-//                 logger.warn(() -> new ParameterizedMessage("failed to notify channel of error message for action [{}]", action), inner);
-//             }
-//         }
-//     }
-
-//     private boolean shouldTraceAction(String action) {
-//         return shouldTraceAction(action, tracerLogInclude, tracerLogExclude);
-//     }
-
-//     public static boolean shouldTraceAction(String action, String[] include, String[] exclude) {
-//         if (include.length > 0) {
-//             if (Regex.simpleMatch(include, action) == false) {
-//                 return false;
-//             }
-//         }
-//         if (exclude.length > 0) {
-//             return !Regex.simpleMatch(exclude, action);
-//         }
-//         return true;
-//     }
-
-//     public TransportAddress[] addressesFromString(String address) throws UnknownHostException {
-//         return transport.addressesFromString(address);
-//     }
-
-//     /**
-//      * A set of all valid action prefixes.
-//     */
-//     public static final Set<String> VALID_ACTION_PREFIXES = Collections.unmodifiableSet(
-//         new HashSet<>(
-//             Arrays.asList(
-//                 "indices:admin",
-//                 "indices:monitor",
-//                 "indices:data/write",
-//                 "indices:data/read",
-//                 "indices:internal",
-//                 "cluster:admin",
-//                 "cluster:monitor",
-//                 "cluster:internal",
-//                 "internal:"
-//             )
-//         )
-//     );
-
-//     private void validateActionName(String actionName) {
-//         // TODO we should makes this a hard validation and throw an exception but we need a good way to add backwards layer
-//         // for it. Maybe start with a deprecation layer
-//         if (isValidActionName(actionName) == false) {
-//             logger.warn(
-//                 "invalid action name [" + actionName + "] must start with one of: " + ProtobufTransportService.VALID_ACTION_PREFIXES
-//             );
-//         }
-//     }
-
-//     /**
-//      * Returns <code>true</code> iff the action name starts with a valid prefix.
-//     *
-//     * @see #VALID_ACTION_PREFIXES
-//     */
-//     public static boolean isValidActionName(String actionName) {
-//         for (String prefix : VALID_ACTION_PREFIXES) {
-//             if (actionName.startsWith(prefix)) {
-//                 return true;
-//             }
-//         }
-//         return false;
-//     }
-
-//     /**
-//      * Registers a new request handler
-//     *
-//     * @param action         The action the request handler is associated with
-//     * @param requestReader  a callable to be used construct new instances for streaming
-//     * @param executor       The executor the request handling will be executed on
-//     * @param handler        The handler itself that implements the request handling
-//     */
-//     public <Request extends TransportRequest> void registerRequestHandler(
-//         String action,
-//         String executor,
-//         ProtobufWriteable.Reader<Request> requestReader,
-//         TransportRequestHandler<Request> handler
-//     ) {
-//         validateActionName(action);
-//         handler = interceptor.interceptHandler(action, executor, false, handler);
-//         ProtobufRequestHandlerRegistry<Request> reg = new ProtobufRequestHandlerRegistry<>(
-//             action,
-//             requestReader,
-//             taskManager,
-//             handler,
-//             executor,
-//             false,
-//             true
-//         );
-//         transport.registerProtobufRequestHandler(reg);
-//     }
-
-//     /**
-//      * Registers a new request handler
-//     *
-//     * @param action                The action the request handler is associated with
-//     * @param requestReader               The request class that will be used to construct new instances for streaming
-//     * @param executor              The executor the request handling will be executed on
-//     * @param forceExecution        Force execution on the executor queue and never reject it
-//     * @param canTripCircuitBreaker Check the request size and raise an exception in case the limit is breached.
-//     * @param handler               The handler itself that implements the request handling
-//     */
-//     public <Request extends TransportRequest> void registerRequestHandler(
-//         String action,
-//         String executor,
-//         boolean forceExecution,
-//         boolean canTripCircuitBreaker,
-//         ProtobufWriteable.Reader<Request> requestReader,
-//         TransportRequestHandler<Request> handler
-//     ) {
-//         validateActionName(action);
-//         handler = interceptor.interceptHandler(action, executor, forceExecution, handler);
-//         ProtobufRequestHandlerRegistry<Request> reg = new ProtobufRequestHandlerRegistry<>(
-//             action,
-//             requestReader,
-//             taskManager,
-//             handler,
-//             executor,
-//             forceExecution,
-//             canTripCircuitBreaker
-//         );
-//         transport.registerProtobufRequestHandler(reg);
-//     }
-
-//     /**
-//      * called by the {@link Transport} implementation when an incoming request arrives but before
-//     * any parsing of it has happened (with the exception of the requestId and action)
-//     */
-//     @Override
-//     public void onRequestReceived(long requestId, String action) {
-//         if (handleIncomingRequests.get() == false) {
-//             throw new IllegalStateException("transport not ready yet to handle incoming requests");
-//         }
-//         if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
-//             tracerLog.trace("[{}][{}] received request", requestId, action);
-//         }
-//         messageListener.onRequestReceived(requestId, action);
-//     }
-
-//     /** called by the {@link Transport} implementation once a request has been sent */
-//     @Override
-//     public void onRequestSent(
-//         DiscoveryNode node,
-//         long requestId,
-//         String action,
-//         TransportRequest request,
-//         TransportRequestOptions options
-//     ) {
-//         if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
-//             tracerLog.trace("[{}][{}] sent to [{}] (timeout: [{}])", requestId, action, node, options.timeout());
-//         }
-//         messageListener.onRequestSent(node, requestId, action, request, options);
-//     }
-
-//     @Override
-//     public void onResponseReceived(long requestId, Transport.ProtobufResponseContext holder) {
-//         if (holder == null) {
-//             checkForTimeout(requestId);
-//         } else if (tracerLog.isTraceEnabled() && shouldTraceAction(holder.action())) {
-//             tracerLog.trace("[{}][{}] received response from [{}]", requestId, holder.action(), holder.connection().getNode());
-//         }
-//         messageListener.onResponseReceived(requestId, holder);
-//     }
-
-//     /** called by the {@link Transport} implementation once a response was sent to calling node */
-//     @Override
-//     public void onResponseSent(long requestId, String action, TransportResponse response) {
-//         if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
-//             tracerLog.trace("[{}][{}] sent response", requestId, action);
-//         }
-//         messageListener.onResponseSent(requestId, action, response);
-//     }
-
-//     /** called by the {@link Transport} implementation after an exception was sent as a response to an incoming request */
-//     @Override
-//     public void onResponseSent(long requestId, String action, Exception e) {
-//         if (tracerLog.isTraceEnabled() && shouldTraceAction(action)) {
-//             tracerLog.trace(() -> new ParameterizedMessage("[{}][{}] sent error response", requestId, action), e);
-//         }
-//         messageListener.onResponseSent(requestId, action, e);
-//     }
-
-//     public ProtobufRequestHandlerRegistry<? extends TransportRequest> getRequestHandler(String action) {
-//         return transport.getProtobufRequestHandlers().getHandler(action);
-//     }
-
-//     private void checkForTimeout(long requestId) {
-//         // lets see if its in the timeout holder, but sync on mutex to make sure any ongoing timeout handling has finished
-//         final DiscoveryNode sourceNode;
-//         final String action;
-//         assert responseHandlers.contains(requestId) == false;
-//         TimeoutInfoHolder timeoutInfoHolder = timeoutInfoHandlers.remove(requestId);
-//         if (timeoutInfoHolder != null) {
-//             long time = threadPool.relativeTimeInMillis();
-//             logger.warn(
-//                 "Received response for a request that has timed out, sent [{}ms] ago, timed out [{}ms] ago, "
-//                     + "action [{}], node [{}], id [{}]",
-//                 time - timeoutInfoHolder.sentTime(),
-//                 time - timeoutInfoHolder.timeoutTime(),
-//                 timeoutInfoHolder.action(),
-//                 timeoutInfoHolder.node(),
-//                 requestId
-//             );
-//             action = timeoutInfoHolder.action();
-//             sourceNode = timeoutInfoHolder.node();
-//         } else {
-//             logger.warn("ProtobufTransport response handler not found of id [{}]", requestId);
-//             action = null;
-//             sourceNode = null;
-//         }
-//         // call tracer out of lock
-//         if (tracerLog.isTraceEnabled() == false) {
-//             return;
-//         }
-//         if (action == null) {
-//             assert sourceNode == null;
-//             tracerLog.trace("[{}] received response but can't resolve it to a request", requestId);
-//         } else if (shouldTraceAction(action)) {
-//             tracerLog.trace("[{}][{}] received response from [{}]", requestId, action, sourceNode);
-//         }
-//     }
-
-//     @Override
-//     public void onConnectionClosed(Transport.Connection connection) {
-//         try {
-//             List<Transport.ProtobufResponseContext<? extends TransportResponse>> pruned = responseHandlers.prune(
-//                 h -> h.connection().getCacheKey().equals(connection.getCacheKey())
-//             );
-//             // callback that an exception happened, but on a different thread since we don't
-//             // want handlers to worry about stack overflows
-//             getExecutorService().execute(new Runnable() {
-//                 @Override
-//                 public void run() {
-//                     for (Transport.ProtobufResponseContext holderToNotify : pruned) {
-//                         holderToNotify.handler()
-//                             .handleException(new ProtobufNodeDisconnectedException(connection.getNode(), holderToNotify.action()));
-//                     }
-//                 }
-
-//                 @Override
-//                 public String toString() {
-//                     return "onConnectionClosed(" + connection.getNode() + ")";
-//                 }
-//             });
-//         } catch (OpenSearchRejectedExecutionException ex) {
-//             logger.debug("Rejected execution on onConnectionClosed", ex);
-//         }
-//     }
-
-//     final class TimeoutHandler implements Runnable {
-
-//         private final long requestId;
-//         private final long sentTime = threadPool.relativeTimeInMillis();
-//         private final String action;
-//         private final DiscoveryNode node;
-//         volatile Scheduler.Cancellable cancellable;
-
-//         TimeoutHandler(long requestId, DiscoveryNode node, String action) {
-//             this.requestId = requestId;
-//             this.node = node;
-//             this.action = action;
-//         }
-
-//         @Override
-//         public void run() {
-//             if (responseHandlers.contains(requestId)) {
-//                 long timeoutTime = threadPool.relativeTimeInMillis();
-//                 timeoutInfoHandlers.put(requestId, new TimeoutInfoHolder(node, action, sentTime, timeoutTime));
-//                 // now that we have the information visible via timeoutInfoHandlers, we try to remove the request id
-//                 final Transport.ProtobufResponseContext<? extends TransportResponse> holder = responseHandlers.remove(requestId);
-//                 if (holder != null) {
-//                     assert holder.action().equals(action);
-//                     assert holder.connection().getNode().equals(node);
-//                     holder.handler()
-//                         .handleException(
-//                             new ProtobufReceiveTimeoutTransportException(
-//                                 holder.connection().getNode(),
-//                                 holder.action(),
-//                                 "request_id [" + requestId + "] timed out after [" + (timeoutTime - sentTime) + "ms]"
-//                             )
-//                         );
-//                 } else {
-//                     // response was processed, remove timeout info.
-//                     timeoutInfoHandlers.remove(requestId);
-//                 }
-//             }
-//         }
-
-//         /**
-//          * cancels timeout handling. this is a best effort only to avoid running it. remove the requestId from {@link #responseHandlers}
-//         * to make sure this doesn't run.
-//         */
-//         public void cancel() {
-//             assert responseHandlers.contains(requestId) == false : "cancel must be called after the requestId ["
-//                 + requestId
-//                 + "] has been removed from clientHandlers";
-//             if (cancellable != null) {
-//                 cancellable.cancel();
-//             }
-//         }
-
-//         @Override
-//         public String toString() {
-//             return "timeout handler for [" + requestId + "][" + action + "]";
-//         }
-
-//         private void scheduleTimeout(TimeValue timeout) {
-//             this.cancellable = threadPool.schedule(this, timeout, ThreadPool.Names.GENERIC);
-//         }
-//     }
-
-//     /**
-//      * Holder for timeout information
-//     *
-//     * @opensearch.internal
-//     */
-//     static class TimeoutInfoHolder {
-
-//         private final DiscoveryNode node;
-//         private final String action;
-//         private final long sentTime;
-//         private final long timeoutTime;
-
-//         TimeoutInfoHolder(DiscoveryNode node, String action, long sentTime, long timeoutTime) {
-//             this.node = node;
-//             this.action = action;
-//             this.sentTime = sentTime;
-//             this.timeoutTime = timeoutTime;
-//         }
-
-//         public DiscoveryNode node() {
-//             return node;
-//         }
-
-//         public String action() {
-//             return action;
-//         }
-
-//         public long sentTime() {
-//             return sentTime;
-//         }
-
-//         public long timeoutTime() {
-//             return timeoutTime;
-//         }
-//     }
-
-//     /**
-//      * This handler wrapper ensures that the response thread executes with the correct thread context. Before any of the handle methods
-//     * are invoked we restore the context.
-//     */
-//     public static final class ContextRestoreResponseHandler<T extends TransportResponse>
-//         implements
-//             ProtobufTransportResponseHandler<T> {
-
-//         private final ProtobufTransportResponseHandler<T> delegate;
-//         private final Supplier<ThreadContext.StoredContext> contextSupplier;
-//         private volatile TimeoutHandler handler;
-
-//         public ContextRestoreResponseHandler(
-//             Supplier<ThreadContext.StoredContext> contextSupplier,
-//             ProtobufTransportResponseHandler<T> delegate
-//         ) {
-//             this.delegate = delegate;
-//             this.contextSupplier = contextSupplier;
-//         }
-
-//         @Override
-//         public T read(CodedInputStream in) throws IOException {
-//             return delegate.read(in);
-//         }
-
-//         @Override
-//         public void handleResponse(T response) {
-//             if (handler != null) {
-//                 handler.cancel();
-//             }
-//             try (ThreadContext.StoredContext ignore = contextSupplier.get()) {
-//                 delegate.handleResponse(response);
-//             }
-//         }
-
-//         @Override
-//         public void handleException(ProtobufTransportException exp) {
-//             if (handler != null) {
-//                 handler.cancel();
-//             }
-//             try (ThreadContext.StoredContext ignore = contextSupplier.get()) {
-//                 delegate.handleException(exp);
-//             }
-//         }
-
-//         @Override
-//         public String executor() {
-//             return delegate.executor();
-//         }
-
-//         @Override
-//         public String toString() {
-//             return getClass().getName() + "/" + delegate.toString();
-//         }
-
-//         void setTimeoutHandler(TimeoutHandler handler) {
-//             this.handler = handler;
-//         }
-
-//     }
-
-//     /**
-//      * A channel for a direct response
-//     *
-//     * @opensearch.internal
-//     */
-//     static class DirectResponseChannel implements ProtobufTransportChannel {
-//         final DiscoveryNode localNode;
-//         private final String action;
-//         private final long requestId;
-//         final ProtobufTransportService service;
-//         final ThreadPool threadPool;
-
-//         DirectResponseChannel(
-//             DiscoveryNode localNode,
-//             String action,
-//             long requestId,
-//             ProtobufTransportService service,
-//             ThreadPool threadPool
-//         ) {
-//             this.localNode = localNode;
-//             this.action = action;
-//             this.requestId = requestId;
-//             this.service = service;
-//             this.threadPool = threadPool;
-//         }
-
-//         @Override
-//         public String getProfileName() {
-//             return DIRECT_RESPONSE_PROFILE;
-//         }
-
-//         @Override
-//         public void sendResponse(TransportResponse response) throws IOException {
-//             service.onResponseSent(requestId, action, response);
-//             final ProtobufTransportResponseHandler handler = service.responseHandlers.onResponseReceived(requestId, service);
-//             // ignore if its null, the service logs it
-//             if (handler != null) {
-//                 final String executor = handler.executor();
-//                 if (ThreadPool.Names.SAME.equals(executor)) {
-//                     processResponse(handler, response);
-//                 } else {
-//                     threadPool.executor(executor).execute(new Runnable() {
-//                         @Override
-//                         public void run() {
-//                             processResponse(handler, response);
-//                         }
-
-//                         @Override
-//                         public String toString() {
-//                             return "delivery of response to [" + requestId + "][" + action + "]: " + response;
-//                         }
-//                     });
-//                 }
-//             }
-//         }
-
-//         @SuppressWarnings("unchecked")
-//         protected void processResponse(ProtobufTransportResponseHandler handler, TransportResponse response) {
-//             try {
-//                 handler.handleResponse(response);
-//             } catch (Exception e) {
-//                 processException(handler, wrapInRemote(new ResponseHandlerFailureTransportException(e)));
-//             }
-//         }
-
-//         @Override
-//         public void sendResponse(Exception exception) throws IOException {
-//             service.onResponseSent(requestId, action, exception);
-//             final ProtobufTransportResponseHandler handler = service.responseHandlers.onResponseReceived(requestId, service);
-//             // ignore if its null, the service logs it
-//             if (handler != null) {
-//                 final ProtobufRemoteTransportException rtx = wrapInRemote(exception);
-//                 final String executor = handler.executor();
-//                 if (ThreadPool.Names.SAME.equals(executor)) {
-//                     processException(handler, rtx);
-//                 } else {
-//                     threadPool.executor(handler.executor()).execute(new Runnable() {
-//                         @Override
-//                         public void run() {
-//                             processException(handler, rtx);
-//                         }
-
-//                         @Override
-//                         public String toString() {
-//                             return "delivery of failure response to [" + requestId + "][" + action + "]: " + exception;
-//                         }
-//                     });
-//                 }
-//             }
-//         }
-
-//         protected ProtobufRemoteTransportException wrapInRemote(Exception e) {
-//             if (e instanceof ProtobufRemoteTransportException) {
-//                 return (ProtobufRemoteTransportException) e;
-//             }
-//             return new ProtobufRemoteTransportException(localNode.getName(), localNode.getAddress(), action, e);
-//         }
-
-//         protected void processException(final ProtobufTransportResponseHandler handler, final ProtobufRemoteTransportException rtx) {
-//             try {
-//                 handler.handleException(rtx);
-//             } catch (Exception e) {
-//                 logger.error(
-//                     () -> new ParameterizedMessage("failed to handle exception for action [{}], handler [{}]", action, handler),
-//                     e
-//                 );
-//             }
-//         }
-
-//         @Override
-//         public String getChannelType() {
-//             return "direct";
-//         }
-
-//         @Override
-//         public Version getVersion() {
-//             return localNode.getVersion();
-//         }
-//     }
-
-//     /**
-//      * Returns the internal thread pool
-//     */
-//     public ThreadPool getThreadPool() {
-//         return threadPool;
-//     }
-
-//     private boolean isLocalNode(DiscoveryNode discoveryNode) {
-//         return Objects.requireNonNull(discoveryNode, "discovery node must not be null").equals(localNode);
-//     }
-
-//     private static final class DelegatingTransportMessageListener implements ProtobufTransportMessageListener {
-
-//         private final List<ProtobufTransportMessageListener> listeners = new CopyOnWriteArrayList<>();
-
-//         @Override
-//         public void onRequestReceived(long requestId, String action) {
-//             for (ProtobufTransportMessageListener listener : listeners) {
-//                 listener.onRequestReceived(requestId, action);
-//             }
-//         }
-
-//         @Override
-//         public void onResponseSent(long requestId, String action, TransportResponse response) {
-//             for (ProtobufTransportMessageListener listener : listeners) {
-//                 listener.onResponseSent(requestId, action, response);
-//             }
-//         }
-
-//         @Override
-//         public void onResponseSent(long requestId, String action, Exception error) {
-//             for (ProtobufTransportMessageListener listener : listeners) {
-//                 listener.onResponseSent(requestId, action, error);
-//             }
-//         }
-
-//         @Override
-//         public void onRequestSent(
-//             DiscoveryNode node,
-//             long requestId,
-//             String action,
-//             TransportRequest request,
-//             TransportRequestOptions finalOptions
-//         ) {
-//             for (ProtobufTransportMessageListener listener : listeners) {
-//                 listener.onRequestSent(node, requestId, action, request, finalOptions);
-//             }
-//         }
-
-//         @Override
-//         public void onResponseReceived(long requestId, Transport.ProtobufResponseContext holder) {
-//             for (ProtobufTransportMessageListener listener : listeners) {
-//                 listener.onResponseReceived(requestId, holder);
-//             }
-//         }
-//     }
-// }
diff --git a/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java b/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java
index c66b5d5fed21d..66961c2490f3a 100644
--- a/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java
+++ b/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java
@@ -184,6 +184,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
                             // TODO Auto-generated method stub
                             throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
                         }
+
+                        @Override
+                        public ClusterStateResponse read(byte[] in) throws IOException {
+                            // TODO Auto-generated method stub
+                            throw new UnsupportedOperationException("Unimplemented method 'read'");
+                        }
                     }
                 );
             }
diff --git a/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java
index c01cd7d212dc9..bf2b97aebba29 100644
--- a/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java
+++ b/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java
@@ -485,6 +485,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
             // TODO Auto-generated method stub
             throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
         }
+
+        @Override
+        public ClusterStateResponse read(byte[] in) throws IOException {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'read'");
+        }
     }
 
     private Predicate<ClusterName> getRemoteClusterNamePredicate() {
diff --git a/server/src/main/java/org/opensearch/transport/TransportActionProxy.java b/server/src/main/java/org/opensearch/transport/TransportActionProxy.java
index 8ddbd870e4cab..126d090db2636 100644
--- a/server/src/main/java/org/opensearch/transport/TransportActionProxy.java
+++ b/server/src/main/java/org/opensearch/transport/TransportActionProxy.java
@@ -143,6 +143,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
             // TODO Auto-generated method stub
             throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
         }
+
+        @Override
+        public T read(byte[] in) throws IOException {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'read'");
+        }
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/transport/TransportHandshaker.java b/server/src/main/java/org/opensearch/transport/TransportHandshaker.java
index 0e6d038be88f9..750cc4a4e19de 100644
--- a/server/src/main/java/org/opensearch/transport/TransportHandshaker.java
+++ b/server/src/main/java/org/opensearch/transport/TransportHandshaker.java
@@ -200,6 +200,12 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
             // TODO Auto-generated method stub
             throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
         }
+
+        @Override
+        public HandshakeResponse read(byte[] in) throws IOException {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'read'");
+        }
     }
 
     static final class HandshakeRequest extends TransportRequest {
diff --git a/server/src/main/java/org/opensearch/transport/TransportRequest.java b/server/src/main/java/org/opensearch/transport/TransportRequest.java
index 2214b32da8b29..3194d7da970ea 100644
--- a/server/src/main/java/org/opensearch/transport/TransportRequest.java
+++ b/server/src/main/java/org/opensearch/transport/TransportRequest.java
@@ -32,8 +32,11 @@
 
 package org.opensearch.transport;
 
+import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.server.proto.TransportRequestProto;
+import org.opensearch.server.proto.TransportRequestProto.TransportReq;
 import org.opensearch.tasks.ProtobufTaskAwareRequest;
 import org.opensearch.tasks.ProtobufTaskId;
 import org.opensearch.tasks.TaskAwareRequest;
@@ -50,6 +53,8 @@
  * @opensearch.internal
  */
 public abstract class TransportRequest extends TransportMessage implements TaskAwareRequest, ProtobufTaskAwareRequest {
+
+    private TransportRequestProto.TransportReq transportReq;
     /**
      * Empty transport request
      *
@@ -81,6 +86,10 @@ public Empty(CodedInputStream in) throws IOException {
 
     public TransportRequest() {}
 
+    public TransportRequest(ProtobufClusterStateRequest clusterStateRequest) {
+        this.transportReq = TransportReq.newBuilder().setClusterStateRequest(clusterStateRequest.request()).build();
+    }
+
     public TransportRequest(StreamInput in) throws IOException {
         parentTaskId = TaskId.readFromStream(in);
     }
@@ -130,4 +139,8 @@ public void writeTo(StreamOutput out) throws IOException {
     public void writeTo(CodedOutputStream out) throws IOException {
         protobufParentTaskId.writeTo(out);
     }
+
+    public TransportReq transportReq() {
+        return transportReq;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java
index 7e21af3d274ba..b657a755702f8 100644
--- a/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java
+++ b/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java
@@ -34,6 +34,7 @@
 
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.core.common.io.stream.Writeable;
 
 import com.google.protobuf.CodedInputStream;
@@ -46,7 +47,7 @@
  *
  * @opensearch.internal
  */
-public interface TransportResponseHandler<T extends TransportResponse> extends Writeable.Reader<T>, ProtobufWriteable.Reader<T> {
+public interface TransportResponseHandler<T extends TransportResponse> extends Writeable.Reader<T>, ProtobufWriteable.Reader<T>, TryWriteable.Reader<T> {
 
     void handleResponse(T response);
 
@@ -90,12 +91,18 @@ public Q read(CodedInputStream in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
+
+            @Override
+            public Q read(byte[] in) throws IOException {
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
+            }
         };
     }
 
     default <Q extends TransportResponse> TransportResponseHandler<Q> wrapProtobuf(
         Function<Q, T> converter,
-        ProtobufWriteable.Reader<Q> reader
+        TryWriteable.Reader<Q> reader
     ) {
         final TransportResponseHandler<T> self = this;
         return new TransportResponseHandler<Q>() {
@@ -116,7 +123,8 @@ public String executor() {
 
             @Override
             public Q read(CodedInputStream in) throws IOException {
-                return reader.read(in);
+                // TODO Auto-generated method stub
+                throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
             @Override
@@ -130,6 +138,11 @@ public void handleException(TransportException exp) {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'handleException'");
             }
+
+            @Override
+            public Q read(byte[] in) throws IOException {
+                return reader.read(in);
+            }
         };
     }
 }
diff --git a/server/src/main/java/org/opensearch/transport/TransportService.java b/server/src/main/java/org/opensearch/transport/TransportService.java
index b1da4fec40866..3a6679462932d 100644
--- a/server/src/main/java/org/opensearch/transport/TransportService.java
+++ b/server/src/main/java/org/opensearch/transport/TransportService.java
@@ -119,11 +119,9 @@ public class TransportService extends AbstractLifecycleComponent
     protected final ClusterName clusterName;
     protected final TaskManager taskManager;
     private final TransportInterceptor.AsyncSender asyncSender;
-    // private final TransportInterceptor.AsyncSenderProtobuf asyncSenderProtobuf;
     private final Function<BoundTransportAddress, DiscoveryNode> localNodeFactory;
     private final boolean remoteClusterClient;
     private final Transport.ResponseHandlers responseHandlers;
-    // private final Transport.ProtobufResponseHandlers responseHandlersProtobuf;
     private final TransportInterceptor interceptor;
 
     // An LRU (don't really care about concurrency here) that holds the latest timed out requests so if they
@@ -173,14 +171,6 @@ public boolean isClosed() {
 
         @Override
         public void close() {}
-
-        // @Override
-        // public void sendRequestProtobuf(long requestId, String action, ProtobufTransportRequest request,
-        //         TransportRequestOptions options) throws IOException, TransportException {
-        //     // // TODO Auto-generated method stub
-        //     // throw new UnsupportedOperationException("Unimplemented method 'sendRequestProtobuf'");
-        //     sendLocalRequest(requestId, action, request, options);
-        // }
     };
 
     static {
@@ -391,47 +381,6 @@ public void doRun() {
                     }
                 });
             }
-
-            // // in case the transport is not connected to our local node (thus cleaned on node disconnect)
-            // // make sure to clean any leftover on going handles
-            // for (final Transport.ProtobufResponseContext holderToNotify : responseHandlersProtobuf.prune(h -> true)) {
-            //     // callback that an exception happened, but on a different thread since we don't
-            //     // want handlers to worry about stack overflows
-            //     getExecutorService().execute(new AbstractRunnable() {
-            //         @Override
-            //         public void onRejection(Exception e) {
-            //             // if we get rejected during node shutdown we don't wanna bubble it up
-            //             logger.debug(
-            //                 () -> new ParameterizedMessage(
-            //                     "failed to notify response handler on rejection, action: {}",
-            //                     holderToNotify.action()
-            //                 ),
-            //                 e
-            //             );
-            //         }
-
-            //         @Override
-            //         public void onFailure(Exception e) {
-            //             logger.warn(
-            //                 () -> new ParameterizedMessage(
-            //                     "failed to notify response handler on exception, action: {}",
-            //                     holderToNotify.action()
-            //                 ),
-            //                 e
-            //             );
-            //         }
-
-            //         @Override
-            //         public void doRun() {
-            //             ProtobufTransportException ex = new ProtobufSendRequestTransportException(
-            //                 holderToNotify.connection().getNode(),
-            //                 holderToNotify.action(),
-            //                 new ProtobufNodeClosedException(localNode)
-            //             );
-            //             holderToNotify.handler().handleException(ex);
-            //         }
-            //     });
-            // }
         }
     }
 
@@ -778,48 +727,6 @@ public void onFailure(Exception e) {
                 }
             }, HandshakeResponse::new, ThreadPool.Names.GENERIC)
         );
-        // sendRequestProtobuf(
-        //     connection,
-        //     HANDSHAKE_ACTION_NAME,
-        //     HandshakeRequest.INSTANCE,
-        //     TransportRequestOptions.builder().withTimeout(handshakeTimeout).build(),
-        //     new ProtobufActionListenerResponseHandler<>(new ActionListener<HandshakeResponse>() {
-        //         @Override
-        //         public void onResponse(HandshakeResponse response) {
-        //             if (clusterNamePredicate.test(response.clusterName) == false) {
-        //                 listener.onFailure(
-        //                     new IllegalStateException(
-        //                         "handshake with ["
-        //                             + node
-        //                             + "] failed: remote cluster name ["
-        //                             + response.clusterName.value()
-        //                             + "] does not match "
-        //                             + clusterNamePredicate
-        //                     )
-        //                 );
-        //             } else if (response.version.isCompatible(localNode.getVersion()) == false) {
-        //                 listener.onFailure(
-        //                     new IllegalStateException(
-        //                         "handshake with ["
-        //                             + node
-        //                             + "] failed: remote node version ["
-        //                             + response.version
-        //                             + "] is incompatible with local node version ["
-        //                             + localNode.getVersion()
-        //                             + "]"
-        //                     )
-        //                 );
-        //             } else {
-        //                 listener.onResponse(response);
-        //             }
-        //         }
-
-        //         @Override
-        //         public void onFailure(Exception e) {
-        //             listener.onFailure(e);
-        //         }
-        //     }, HandshakeResponse::new, ThreadPool.Names.GENERIC)
-        // );
     }
 
     public ConnectionManager getConnectionManager() {
@@ -847,23 +754,6 @@ private HandshakeRequest() {}
 
     }
 
-    // /**
-    //  * Internal Handshake request
-    // *
-    // * @opensearch.internal
-    // */
-    // static class ProtobufHandshakeRequest extends ProtobufTransportRequest {
-
-    //     public static final ProtobufHandshakeRequest INSTANCE = new ProtobufHandshakeRequest();
-
-    //     ProtobufHandshakeRequest(CodedInputStream in) throws IOException {
-    //         super(in);
-    //     }
-
-    //     private ProtobufHandshakeRequest() {}
-
-    // }
-
     /**
      * Internal handshake response
      *
@@ -919,48 +809,6 @@ public ClusterName getClusterName() {
         }
     }
 
-    // /**
-    //  * Internal handshake response
-    // *
-    // * @opensearch.internal
-    // */
-    // public static class ProtobufHandshakeResponse extends ProtobufTransportResponse {
-    //     private final DiscoveryNode discoveryNode;
-    //     private final ClusterName clusterName;
-    //     private final Version version;
-
-    //     public ProtobufHandshakeResponse(DiscoveryNode discoveryNode, ClusterName clusterName, Version version) {
-    //         this.discoveryNode = discoveryNode;
-    //         this.version = version;
-    //         this.clusterName = clusterName;
-    //     }
-
-    //     public ProtobufHandshakeResponse(CodedInputStream in) throws IOException {
-    //         super(in);
-    //         ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-    //         discoveryNode = protobufStreamInput.readOptionalWriteable(DiscoveryNode::new);
-    //         clusterName = new ClusterName(in);
-    //         version = Version.readVersionProtobuf(in);
-    //     }
-
-    //     @Override
-    //     public void writeTo(CodedOutputStream out) throws IOException {
-    //         ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-    //         protobufStreamOutput.writeOptionalWriteable(discoveryNode);
-    //         clusterName.writeTo(out);
-    //         out.writeInt32NoTag(version.id);
-    //     }
-
-    //     public DiscoveryNode getDiscoveryNode() {
-    //         return discoveryNode;
-    //     }
-
-    //     public ClusterName getClusterName() {
-    //         return clusterName;
-    //     }
-    // }
-
-
     public void disconnectFromNode(DiscoveryNode node) {
         if (isLocalNode(node)) {
             return;
@@ -972,18 +820,10 @@ public void addMessageListener(TransportMessageListener listener) {
         messageListener.listeners.add(listener);
     }
 
-    // public void addMessageListenerProtobuf(ProtobufTransportMessageListener listener) {
-    //     messageListener.listeners.add(listener);
-    // }
-
     public boolean removeMessageListener(TransportMessageListener listener) {
         return messageListener.listeners.remove(listener);
     }
 
-    // public boolean removeMessageListenerProtobuf(ProtobufTransportMessageListener listener) {
-    //     return messageListener.listeners.remove(listener);
-    // }
-
     public void addConnectionListener(TransportConnectionListener listener) {
         connectionManager.addListener(listener);
     }
@@ -1119,6 +959,11 @@ public T read(CodedInputStream in) throws IOException {
                     public void handleExceptionProtobuf(ProtobufTransportException exp) {
                         handler.handleExceptionProtobuf(exp);
                     }
+
+                    @Override
+                    public T read(byte[] in) throws IOException {
+                        return handler.read(in);
+                    }
                 };
             } else {
                 delegate = handler;
@@ -1136,138 +981,6 @@ public void handleExceptionProtobuf(ProtobufTransportException exp) {
         }
     }
 
-    // public <T extends ProtobufTransportResponse> TransportFuture<T> submitRequestProtobuf(
-    //     DiscoveryNode node,
-    //     String action,
-    //     ProtobufTransportRequest request,
-    //     ProtobufTransportResponseHandler<T> handler
-    // ) throws ProtobufTransportException {
-    //     return submitRequestProtobuf(node, action, request, TransportRequestOptions.EMPTY, handler);
-    // }
-
-    // public <T extends ProtobufTransportResponse> TransportFuture<T> submitRequestProtobuf(
-    //     DiscoveryNode node,
-    //     String action,
-    //     ProtobufTransportRequest request,
-    //     TransportRequestOptions options,
-    //     ProtobufTransportResponseHandler<T> handler
-    // ) throws ProtobufTransportException {
-    //     ProtobufPlainTransportFuture<T> futureHandler = new ProtobufPlainTransportFuture<>(handler);
-    //     try {
-    //         Transport.Connection connection = getConnection(node);
-    //         sendRequestProtobuf(connection, action, request, options, futureHandler);
-    //     } catch (ProtobufNodeNotConnectedException ex) {
-    //         // the caller might not handle this so we invoke the handler
-    //         futureHandler.handleException(ex);
-    //     }
-    //     return futureHandler;
-    // }
-
-    // public <T extends ProtobufTransportResponse> void sendRequestProtobuf(
-    //     final DiscoveryNode node,
-    //     final String action,
-    //     final ProtobufTransportRequest request,
-    //     final ProtobufTransportResponseHandler<T> handler
-    // ) {
-    //     final Transport.Connection connection;
-    //     try {
-    //         connection = getConnection(node);
-    //     } catch (final ProtobufNodeNotConnectedException ex) {
-    //         // the caller might not handle this so we invoke the handler
-    //         handler.handleException(ex);
-    //         return;
-    //     }
-    //     sendRequestProtobuf(connection, action, request, TransportRequestOptions.EMPTY, handler);
-    // }
-
-    // public final <T extends ProtobufTransportResponse> void sendRequestProtobuf(
-    //     final DiscoveryNode node,
-    //     final String action,
-    //     final ProtobufTransportRequest request,
-    //     final TransportRequestOptions options,
-    //     ProtobufTransportResponseHandler<T> handler
-    // ) {
-    //     final Transport.Connection connection;
-    //     try {
-    //         connection = getConnection(node);
-    //     } catch (final ProtobufNodeNotConnectedException ex) {
-    //         // the caller might not handle this so we invoke the handler
-    //         handler.handleException(ex);
-    //         return;
-    //     }
-    //     sendRequestProtobuf(connection, action, request, options, handler);
-    // }
-
-    // /**
-    //  * Sends a request on the specified connection. If there is a failure sending the request, the specified handler is invoked.
-    // *
-    // * @param connection the connection to send the request on
-    // * @param action     the name of the action
-    // * @param request    the request
-    // * @param options    the options for this request
-    // * @param handler    the response handler
-    // * @param <T>        the type of the transport response
-    // */
-    // public final <T extends ProtobufTransportResponse> void sendRequestProtobuf(
-    //     final Transport.Connection connection,
-    //     final String action,
-    //     final ProtobufTransportRequest request,
-    //     final TransportRequestOptions options,
-    //     final ProtobufTransportResponseHandler<T> handler
-    // ) {
-    //     try {
-    //         logger.debug("Action: " + action);
-    //         final ProtobufTransportResponseHandler<T> delegate;
-    //         if (request.getParentTask().isSet()) {
-    //             // TODO: capture the connection instead so that we can cancel child tasks on the remote connections.
-    //             final Releasable unregisterChildNode = taskManager.registerProtobufChildNode(
-    //                 request.getParentTask().getId(),
-    //                 connection.getNode()
-    //             );
-    //             delegate = new ProtobufTransportResponseHandler<T>() {
-    //                 @Override
-    //                 public void handleResponse(T response) {
-    //                     unregisterChildNode.close();
-    //                     handler.handleResponse(response);
-    //                 }
-
-    //                 @Override
-    //                 public void handleException(ProtobufTransportException exp) {
-    //                     unregisterChildNode.close();
-    //                     handler.handleException(exp);
-    //                 }
-
-    //                 @Override
-    //                 public String executor() {
-    //                     return handler.executor();
-    //                 }
-
-    //                 @Override
-    //                 public T read(CodedInputStream in) throws IOException {
-    //                     return handler.read(in);
-    //                 }
-
-    //                 @Override
-    //                 public String toString() {
-    //                     return getClass().getName() + "/[" + action + "]:" + handler.toString();
-    //                 }
-    //             };
-    //         } else {
-    //             delegate = handler;
-    //         }
-    //         asyncSenderProtobuf.sendRequest(connection, action, request, options, delegate);
-    //     } catch (final Exception ex) {
-    //         // the caller might not handle this so we invoke the handler
-    //         final ProtobufTransportException te;
-    //         if (ex instanceof ProtobufTransportException) {
-    //             te = (ProtobufTransportException) ex;
-    //         } else {
-    //             te = new ProtobufTransportException("failure to send", ex);
-    //         }
-    //         handler.handleException(te);
-    //     }
-    // }
-
     /**
      * Returns either a real transport connection or a local node connection if we are using the local node optimization.
      * @throws NodeNotConnectedException if the given node is not connected
@@ -1985,6 +1698,11 @@ public T read(CodedInputStream in) throws IOException {
             return delegate.read(in);
         }
 
+        @Override
+        public T read(byte[] in) throws IOException {
+            return delegate.read(in);
+        }
+
         @Override
         public void handleExceptionProtobuf(ProtobufTransportException exp) {
             if (handler != null) {
diff --git a/server/src/main/proto/server/ClusterStateRequestProto.proto b/server/src/main/proto/server/ClusterStateRequestProto.proto
new file mode 100644
index 0000000000000..ea323564b2392
--- /dev/null
+++ b/server/src/main/proto/server/ClusterStateRequestProto.proto
@@ -0,0 +1,26 @@
+/*
+ * 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.
+ *
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+syntax = "proto3";
+package org.opensearch.server.proto;
+
+option java_outer_classname = "ClusterStateRequestProto";
+
+message ClusterStateReq {
+  bool routingTable = 1;
+  bool nodes = 2;
+  bool metadata = 3;
+  bool blocks = 4;
+  bool customs = 5;
+  int64 waitForMetadataVersion = 6;
+  string waitForTimeout = 7;
+  repeated string indices = 8;
+}
diff --git a/server/src/main/proto/server/ClusterStateResponseProto.proto b/server/src/main/proto/server/ClusterStateResponseProto.proto
new file mode 100644
index 0000000000000..686790a166bab
--- /dev/null
+++ b/server/src/main/proto/server/ClusterStateResponseProto.proto
@@ -0,0 +1,59 @@
+/*
+ * 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.
+ *
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+syntax = "proto3";
+package org.opensearch.server.proto;
+
+option java_outer_classname = "ClusterStateResponseProto";
+
+message ClusterStateRes {
+  string clusterName = 1;
+  ClusterState clusterState = 2;
+  bool waitForTimedOut = 3;
+
+  message ClusterState {
+    string clusterName = 1;
+    int64 version = 2;
+    string stateUUID = 3;
+    DiscoveryNodes nodes = 4;
+
+    message DiscoveryNodes {
+        map<string, Node> allNodes = 1;
+        string clusterManagerNodeId = 2;
+        string localNodeId = 3;
+        string minNonClientNodeVersion = 4;
+        string maxNonClientNodeVersion = 5;
+        string maxNodeVersion = 6;
+        string minNodeVersion = 7;
+
+        message Node {
+            string nodeName = 1;
+            string nodeId = 2;
+            string ephemeralId = 3;
+            string hostName = 4;
+            string hostAddress = 5;
+            string transportAddress = 6;
+            map<string, string> attributes = 7;
+            repeated NodeRole roles = 8;
+            string version = 9;
+
+            message NodeRole {
+                bool isKnownRole = 1;
+                bool isDynamicRole = 2;
+                string roleName = 3;
+                string roleNameAbbreviation = 4;
+                bool canContainData = 5;
+            }
+        }
+    }  
+  }
+  
+}
diff --git a/server/src/main/proto/server/NodesInfoProto.proto b/server/src/main/proto/server/NodesInfoProto.proto
new file mode 100644
index 0000000000000..af5f6853760a6
--- /dev/null
+++ b/server/src/main/proto/server/NodesInfoProto.proto
@@ -0,0 +1,25 @@
+/*
+ * 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.
+ *
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+syntax = "proto3";
+package org.opensearch.server.proto;
+
+option java_outer_classname = "NodesInfoProto";
+
+message NodesInfo {
+  string nodeId = 1;
+  int64 processId = 2;
+  string address = 3;
+  string displayName = 4;
+  string hash = 5;
+  string jvmInfoVersion = 6;
+  string jvmHeapMax = 7;
+}
diff --git a/server/src/main/proto/server/NodesInfoRequestProto.proto b/server/src/main/proto/server/NodesInfoRequestProto.proto
new file mode 100644
index 0000000000000..a36d93bf55539
--- /dev/null
+++ b/server/src/main/proto/server/NodesInfoRequestProto.proto
@@ -0,0 +1,20 @@
+/*
+ * 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.
+ *
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+syntax = "proto3";
+package org.opensearch.server.proto;
+
+option java_outer_classname = "NodesInfoRequestProto";
+
+message NodesInfoReq {
+  repeated string requestedMetrics = 1;
+  string timeout = 2;
+}
diff --git a/server/src/main/proto/server/NodesInfoResponseProto.proto b/server/src/main/proto/server/NodesInfoResponseProto.proto
new file mode 100644
index 0000000000000..ceb3c4b064cca
--- /dev/null
+++ b/server/src/main/proto/server/NodesInfoResponseProto.proto
@@ -0,0 +1,22 @@
+/*
+ * 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.
+ *
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+syntax = "proto3";
+package org.opensearch.server.proto;
+
+import "server/NodesInfoProto.proto";
+
+option java_outer_classname = "NodesInfoResponseProto";
+
+message NodesInfoRes {
+  string clusterName = 1;
+  repeated NodesInfo nodesInfo = 2;
+}
diff --git a/server/src/main/proto/server/NodesStatsProto.proto b/server/src/main/proto/server/NodesStatsProto.proto
new file mode 100644
index 0000000000000..6c040ccf4a33e
--- /dev/null
+++ b/server/src/main/proto/server/NodesStatsProto.proto
@@ -0,0 +1,147 @@
+/*
+ * 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.
+ *
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+syntax = "proto3";
+package org.opensearch.server.proto;
+
+option java_outer_classname = "NodesStatsProto";
+
+message NodesStats {
+  string nodeId = 1;
+  int64 jvmHeapUsed = 2;
+  string jvmHeapUsedPercent = 3;
+  int64 jvmUpTime = 4;
+  int64 diskTotal = 5;
+  int64 diskAvailable = 6;
+  int64 osMemUsed = 7;
+  string osMemUsedPercent = 8;
+  int64 osMemTotal = 9;
+  string osCpuPercent = 10;
+  repeated double osCpuLoadAverage = 11;
+  int64 processOpenFileDescriptors = 12;
+  int64 processMaxFileDescriptors = 13;
+  CompletionStats completionStats = 14;
+  FieldDataStats fieldDataStats = 15;
+  QueryCacheStats queryCacheStats = 16;
+  RequestCacheStats requestCacheStats = 17;
+  FlushStats flushStats = 18;
+  GetStats getStats = 19;
+  IndexingStats indexingStats = 20;
+  MergeStats mergeStats = 21;
+  RefreshStats refreshStats = 22;
+  ScriptStats scriptStats = 23;
+  SearchStats searchStats = 24;
+  SegmentStats segmentStats = 25;
+
+  message CompletionStats {
+    int64 size = 1;
+  }
+
+  message FieldDataStats {
+    int64 memSize = 1;
+    int64 evictions = 2;
+  }
+
+  message QueryCacheStats {
+    int64 ramBytesUsed = 1;
+    int64 hitCount = 2;
+    int64 missCount = 3;
+    int64 cacheCount = 4;
+    int64 cacheSize = 5;
+  }
+
+  message RequestCacheStats {
+    int64 memorySize = 1;
+    int64 evictions = 2;
+    int64 hitCount = 3;
+    int64 missCount = 4;
+  }
+
+  message FlushStats {
+    int64 total = 1;
+    int64 periodic = 2;
+    int64 totalTimeInMillis = 3;
+  }
+
+  message GetStats {
+    int64 existsCount = 1;
+    int64 existsTimeInMillis = 2;
+    int64 missingCount = 3;
+    int64 missingTimeInMillis = 4;
+    int64 current = 5;
+    int64 count = 6;
+    int64 time = 7;
+  }
+
+  message IndexingStats {
+    int64 indexCount = 1;
+    int64 indexTimeInMillis = 2;
+    int64 indexCurrent = 3;
+    int64 indexFailedCount = 4;
+    int64 deleteCount = 5;
+    int64 deleteTimeInMillis = 6;
+    int64 deleteCurrent = 7;
+    int64 noopUpdateCount = 8;
+    int64 throttleTimeInMillis = 9;
+    bool isThrottled = 10;
+  }
+
+  message MergeStats {
+    int64 total = 1;
+    int64 totalTimeInMillis = 2;
+    int64 totalNumDocs = 3;
+    int64 totalSizeInBytes = 4;
+    int64 current = 5;
+    int64 currentNumDocs = 6;
+    int64 currentSizeInBytes = 7;
+  }
+
+  message RefreshStats {
+    int64 total = 1;
+    int64 totalTimeInMillis = 2;
+    int64 externalTotal = 3;
+    int64 externalTotalTimeInMillis = 4;
+    int32 listeners = 5;
+  }
+
+  message ScriptStats { 
+    int64 compilations = 1;
+    int64 cacheEvictions = 2;
+    int64 compilationLimitTriggered = 3;
+  }
+
+  message SearchStats {
+    int64 queryCount = 1;
+    int64 queryTimeInMillis = 2;
+    int64 queryCurrent = 3;
+    int64 fetchCount = 4;
+    int64 fetchTimeInMillis = 5;
+    int64 fetchCurrent = 6;
+    int64 scrollCount = 7;
+    int64 scrollTimeInMillis = 8;
+    int64 scrollCurrent = 9;
+    int64 suggestCount = 10;
+    int64 suggestTimeInMillis = 11;
+    int64 suggestCurrent = 12;
+    int64 pitCount = 13;
+    int64 pitTimeInMillis = 14;
+    int64 pitCurrent = 15;
+    int64 openContexts = 16;
+  }
+
+  message SegmentStats {
+    int64 count = 1;
+    int64 indexWriterMemoryInBytes = 2;
+    int64 versionMapMemoryInBytes = 3;
+    int64 maxUnsafeAutoIdTimestamp = 4;
+    int64 bitsetMemoryInBytes = 5;
+  }
+}
diff --git a/server/src/main/proto/server/NodesStatsRequestProto.proto b/server/src/main/proto/server/NodesStatsRequestProto.proto
new file mode 100644
index 0000000000000..25228c409634e
--- /dev/null
+++ b/server/src/main/proto/server/NodesStatsRequestProto.proto
@@ -0,0 +1,20 @@
+/*
+ * 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.
+ *
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+syntax = "proto3";
+package org.opensearch.server.proto;
+
+option java_outer_classname = "NodesStatsRequestProto";
+
+message NodesStatsReq {
+  repeated string requestedMetrics = 1;
+  string timeout = 2;
+}
diff --git a/server/src/main/proto/server/NodesStatsResponseProto.proto b/server/src/main/proto/server/NodesStatsResponseProto.proto
new file mode 100644
index 0000000000000..ba3d694444c31
--- /dev/null
+++ b/server/src/main/proto/server/NodesStatsResponseProto.proto
@@ -0,0 +1,22 @@
+/*
+ * 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.
+ *
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+syntax = "proto3";
+package org.opensearch.server.proto;
+
+import "server/NodesStatsProto.proto";
+
+option java_outer_classname = "NodesStatsResponseProto";
+
+message NodesStatsRes {
+  string clusterName = 1;
+  repeated NodesStats nodesStats = 2;
+}
diff --git a/server/src/main/proto/examples/OutboundMessageProto.proto b/server/src/main/proto/server/OutboundMessageProto.proto
similarity index 59%
rename from server/src/main/proto/examples/OutboundMessageProto.proto
rename to server/src/main/proto/server/OutboundMessageProto.proto
index 68721910c3f89..be69c1d54ebb9 100644
--- a/server/src/main/proto/examples/OutboundMessageProto.proto
+++ b/server/src/main/proto/server/OutboundMessageProto.proto
@@ -10,9 +10,16 @@
  */
 
 syntax = "proto3";
-package org.opensearch.example.proto;
+package org.opensearch.server.proto;
 
 import "examples/ExampleRequestProto.proto";
+import "server/TransportRequestProto.proto";
+import "server/ClusterStateRequestProto.proto";
+import "server/ClusterStateResponseProto.proto";
+import "server/NodesInfoRequestProto.proto";
+import "server/NodesInfoProto.proto";
+import "server/NodesStatsRequestProto.proto";
+import "server/NodesStatsProto.proto";
 
 option java_outer_classname = "OutboundMessageProto";
 
@@ -25,8 +32,15 @@ message OutboundMsg {
   bytes status = 6;
   string action = 7;
   int64 requestId = 8;
-  ExampleRequest message = 9;
-  bool isProtobuf = 10;
+  oneof message {
+    ClusterStateReq clusterStateReq = 9;
+    ClusterStateRes clusterStateRes = 10;
+    NodesInfoReq nodesInfoReq = 11;
+    NodesInfo nodesInfoRes = 12;
+    NodesStatsReq nodesStatsReq = 13;
+    NodesStats nodesStatsRes = 14;
+  }
+  bool isProtobuf = 15;
   
   message Header {
     repeated bytes prefix = 1;
diff --git a/server/src/main/proto/server/TransportRequestProto.proto b/server/src/main/proto/server/TransportRequestProto.proto
new file mode 100644
index 0000000000000..636e37d33edd2
--- /dev/null
+++ b/server/src/main/proto/server/TransportRequestProto.proto
@@ -0,0 +1,21 @@
+/*
+ * 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.
+ *
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+syntax = "proto3";
+package org.opensearch.server.proto;
+
+import "server/ClusterStateRequestProto.proto";
+
+option java_outer_classname = "TransportRequestProto";
+
+message TransportReq {
+  optional ClusterStateReq clusterStateRequest = 1;
+}
diff --git a/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java b/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
index 2c65042c40d97..32884a572b968 100644
--- a/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
+++ b/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
@@ -349,7 +349,7 @@ public void onRequestSent(
                 requestRef.set(request);
             }
         });
-        handler.sendProtobufRequest(node, channel, requestId, action, request, options, version, compress, isHandshake);
+        // handler.sendProtobufRequest(node, channel, requestId, action, request, options, version, compress, isHandshake);
 
         BytesReference reference = channel.getMessageCaptor().get();
         ActionListener<Void> sendListener = channel.getListenerCaptor().get();

From b5831793d1f50888c119ba3be5a70e7aa914e8b6 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Fri, 28 Jul 2023 21:23:16 +0000
Subject: [PATCH 20/37] Calculating time

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../src/main/java/org/opensearch/rest/RestController.java   | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/server/src/main/java/org/opensearch/rest/RestController.java b/server/src/main/java/org/opensearch/rest/RestController.java
index 50cf7dcde5019..67300188b817a 100644
--- a/server/src/main/java/org/opensearch/rest/RestController.java
+++ b/server/src/main/java/org/opensearch/rest/RestController.java
@@ -576,14 +576,20 @@ private void tryAllHandlers(final RestRequest request, final RestChannel channel
                     }
                 } else {
                     if (rawPath.contains("protobuf")) {
+                        long startTime = System.nanoTime();
                         dispatchProtobufRequest(request, channel, protobufHandler);
+                        long endTime = System.nanoTime();      
+                        System.out.println("Elapsed Time in nano seconds for protobuf: "+ (endTime-startTime));
                     } else {
                     if (FeatureFlags.isEnabled(FeatureFlags.IDENTITY)) {
                         if (!handleAuthenticateUser(request, channel)) {
                             return;
                         }
                     }
+                        long startTime = System.nanoTime();
                         dispatchRequest(request, channel, handler);
+                        long endTime = System.nanoTime();      
+                        System.out.println("Elapsed Time in nano seconds for original: "+ (endTime-startTime));
                     }
                     return;
                 }

From 515110ad770ea951c42324034324ba1c97adb786 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Fri, 28 Jul 2023 21:47:47 +0000
Subject: [PATCH 21/37] Removing sysouts

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../netty4/Netty4MessageChannelHandler.java   |  1 -
 .../node/info/ProtobufNodesInfoResponse.java  |  5 --
 .../ProtobufTransportNodesInfoAction.java     | 12 ---
 .../node/info/TransportNodesInfoAction.java   | 10 ---
 .../stats/ProtobufNodesStatsResponse.java     |  5 --
 .../ProtobufTransportNodesStatsAction.java    |  6 --
 .../cluster/state/ClusterStateRequest.java    | 10 ---
 .../cluster/state/ClusterStateResponse.java   |  6 --
 .../state/ProtobufClusterStateRequest.java    |  1 -
 .../state/ProtobufClusterStateResponse.java   | 37 ---------
 .../ProtobufTransportClusterStateAction.java  |  5 --
 .../state/TransportClusterStateAction.java    |  5 --
 .../ProtobufHandledTransportAction.java       |  1 -
 .../support/ProtobufTransportAction.java      |  7 --
 ...obufTransportClusterManagerNodeAction.java |  8 --
 .../TransportClusterManagerNodeAction.java    |  6 --
 .../nodes/ProtobufTransportNodesAction.java   |  5 --
 .../support/nodes/TransportNodesAction.java   |  2 -
 .../support/ProtobufAbstractClient.java       |  3 -
 .../org/opensearch/cluster/ClusterName.java   |  2 -
 .../org/opensearch/cluster/ClusterState.java  |  2 -
 .../action/cat/ProtobufRestNodesAction.java   |  8 --
 .../rest/action/cat/RestNodesAction.java      |  5 --
 .../transport/ClusterConnectionManager.java   |  4 -
 .../java/org/opensearch/transport/Header.java |  2 -
 .../transport/InboundAggregator.java          |  1 -
 .../opensearch/transport/InboundDecoder.java  | 14 ----
 .../opensearch/transport/InboundHandler.java  | 83 -------------------
 .../opensearch/transport/InboundMessage.java  |  4 -
 .../opensearch/transport/InboundPipeline.java | 17 ----
 .../opensearch/transport/OutboundHandler.java | 37 ---------
 .../opensearch/transport/OutboundMessage.java | 16 ----
 .../ProtobufRequestHandlerRegistry.java       | 12 ---
 .../transport/RemoteConnectionManager.java    |  1 -
 .../opensearch/transport/TcpTransport.java    | 11 ---
 .../transport/TransportService.java           | 22 -----
 36 files changed, 376 deletions(-)

diff --git a/modules/transport-netty4/src/main/java/org/opensearch/transport/netty4/Netty4MessageChannelHandler.java b/modules/transport-netty4/src/main/java/org/opensearch/transport/netty4/Netty4MessageChannelHandler.java
index f7acab52641e3..b1cdc9c698520 100644
--- a/modules/transport-netty4/src/main/java/org/opensearch/transport/netty4/Netty4MessageChannelHandler.java
+++ b/modules/transport-netty4/src/main/java/org/opensearch/transport/netty4/Netty4MessageChannelHandler.java
@@ -84,7 +84,6 @@ final class Netty4MessageChannelHandler extends ChannelDuplexHandler {
 
     @Override
     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
-        System.out.println("Coming in to channel read");
         assert Transports.assertDefaultThreadContext(transport.getThreadPool().getThreadContext());
         assert Transports.assertTransportThread();
         assert msg instanceof ByteBuf : "Expected message type ByteBuf, found: " + msg.getClass();
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
index b8b46d6dd5f22..8ea260493756e 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
@@ -80,9 +80,6 @@ public ProtobufNodesInfoResponse(CodedInputStream in) throws IOException {
 
     public ProtobufNodesInfoResponse(ClusterName clusterName, List<ProtobufNodeInfo> nodes, List<ProtobufFailedNodeException> failures) {
         super(clusterName, nodes, failures);
-        System.out.println("ProtobufNodesInfoResponse constructor");
-        System.out.println("clusterName: " + clusterName);
-        System.out.println("nodes: " + nodes);
         List<NodesInfo> nodesInfo = new ArrayList<>();
         for (ProtobufNodeInfo nodeInfo : nodes) {
             nodesInfo.add(nodeInfo.response());
@@ -92,8 +89,6 @@ public ProtobufNodesInfoResponse(ClusterName clusterName, List<ProtobufNodeInfo>
             .setClusterName(clusterName.value())
             .addAllNodesInfo(nodesInfo)
             .build();
-        System.out.println("Proto nodes info: " + this.nodesInfoRes);
-        System.out.println("Nodes info map: " + this.nodesMap);
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
index f890a1549d252..805aff9b5115f 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
@@ -68,33 +68,23 @@ protected ProtobufNodesInfoResponse newResponse(
         List<ProtobufNodeInfo> responses,
         List<ProtobufFailedNodeException> failures
     ) {
-        System.out.println("Inside newResponse");
-        System.out.println("nodesInfoRequest: " + nodesInfoRequest);
-        System.out.println("responses: " + responses);
-        System.out.println("failures: " + failures);
         return new ProtobufNodesInfoResponse(new ClusterName(clusterService.getClusterName().value()), responses, failures);
     }
 
     @Override
     protected NodeInfoRequest newNodeRequest(ProtobufNodesInfoRequest request) {
-        // System.out.println("Inside newNodeRequest");
         return new NodeInfoRequest(request);
     }
 
     @Override
     protected ProtobufNodeInfo newNodeResponse(CodedInputStream in) throws IOException {
-        System.out.println("Inside newNodeResponse with input stream");
         return new ProtobufNodeInfo(in);
     }
 
     @Override
     protected ProtobufNodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
-        System.out.println("Inside nodeOperation in ProtobufTransportNodesInfoAction");
-        System.out.println("nodeRequest: " + nodeRequest);
         ProtobufNodesInfoRequest request = nodeRequest.request;
-        System.out.println("request: " + request);
         Set<String> metrics = request.requestedMetrics();
-        System.out.println("Metrics: " + metrics);
         ProtobufNodeInfo protobufNodeInfo = nodeService.info(
             metrics.contains(ProtobufNodesInfoRequest.Metric.SETTINGS.metricName()),
             metrics.contains(ProtobufNodesInfoRequest.Metric.OS.metricName()),
@@ -109,7 +99,6 @@ protected ProtobufNodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
             metrics.contains(ProtobufNodesInfoRequest.Metric.INDICES.metricName()),
             metrics.contains(ProtobufNodesInfoRequest.Metric.SEARCH_PIPELINES.metricName())
         );
-        System.out.println("protobufNodeInfo: " + protobufNodeInfo);
         return protobufNodeInfo;
     }
 
@@ -153,7 +142,6 @@ public void writeTo(OutputStream out) throws IOException {
 
     @Override
     protected ProtobufNodeInfo newNodeResponse(byte[] in) throws IOException {
-        System.out.println("Inside newNodeResponse with byte array");
         return new ProtobufNodeInfo(in);
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
index 45ead36c725a0..64cd1a887ac12 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
@@ -89,32 +89,23 @@ protected NodesInfoResponse newResponse(
         List<NodeInfo> responses,
         List<FailedNodeException> failures
     ) {
-        // System.out.println("Inside newResponse");
-        // System.out.println("nodesInfoRequest: " + nodesInfoRequest);
-        // System.out.println("responses: " + responses);
-        // System.out.println("failures: " + failures);
         return new NodesInfoResponse(clusterService.getClusterName(), responses, failures);
     }
 
     @Override
     protected NodeInfoRequest newNodeRequest(NodesInfoRequest request) {
-        // System.out.println("Inside newNodeRequest");
         return new NodeInfoRequest(request);
     }
 
     @Override
     protected NodeInfo newNodeResponse(StreamInput in) throws IOException {
-        // System.out.println("Inside newNodeResponse with input stream");
         return new NodeInfo(in);
     }
 
     @Override
     protected NodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
-        System.out.println("TransportNodesInfoAction.nodeOperation");
         NodesInfoRequest request = nodeRequest.request;
-        System.out.println("request: " + request);
         Set<String> metrics = request.requestedMetrics();
-        System.out.println("metrics: " + metrics);
         NodeInfo nodeInfo = nodeService.info(
             metrics.contains(NodesInfoRequest.Metric.SETTINGS.metricName()),
             metrics.contains(NodesInfoRequest.Metric.OS.metricName()),
@@ -129,7 +120,6 @@ protected NodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
             metrics.contains(NodesInfoRequest.Metric.INDICES.metricName()),
             metrics.contains(NodesInfoRequest.Metric.SEARCH_PIPELINES.metricName())
         );
-        System.out.println("nodeInfo: " + nodeInfo);
         return nodeInfo;
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
index 2249656f78424..e3218379c8e18 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
@@ -44,9 +44,6 @@ public ProtobufNodesStatsResponse(CodedInputStream in) throws IOException {
 
     public ProtobufNodesStatsResponse(ClusterName clusterName, List<ProtobufNodeStats> nodes, List<ProtobufFailedNodeException> failures) {
         super(clusterName, nodes, failures);
-        System.out.println("ProtobufNodesStatsResponse constructor");
-        System.out.println("clusterName: " + clusterName);
-        System.out.println("nodes: " + nodes);
         List<NodesStats> nodesStats = new ArrayList<>();
         for (ProtobufNodeStats nodeStats : nodes) {
             nodesStats.add(nodeStats.response());
@@ -56,8 +53,6 @@ public ProtobufNodesStatsResponse(ClusterName clusterName, List<ProtobufNodeStat
             .setClusterName(clusterName.value())
             .addAllNodesStats(nodesStats)
             .build();
-        System.out.println("Proto nodes stats: " + this.nodesStatsRes);
-        System.out.println("Nodes info map: " + this.nodesMap);
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
index 70843521d1d31..55c827bcb5c37 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
@@ -69,10 +69,6 @@ protected ProtobufNodesStatsResponse newResponse(
         List<ProtobufNodeStats> responses,
         List<ProtobufFailedNodeException> failures
     ) {
-        System.out.println("Inside newResponse");
-        System.out.println("nodesStatsRequest: " + request);
-        System.out.println("responses: " + responses);
-        System.out.println("failures: " + failures);
         return new ProtobufNodesStatsResponse(new ClusterName(clusterService.getClusterName().value()), responses, failures);
     }
 
@@ -112,7 +108,6 @@ protected ProtobufNodeStats nodeOperation(NodeStatsRequest nodeStatsRequest) {
             ProtobufNodesStatsRequest.Metric.WEIGHTED_ROUTING_STATS.containedIn(metrics),
             ProtobufNodesStatsRequest.Metric.FILE_CACHE_STATS.containedIn(metrics)
         );
-        System.out.println("protobufNodeStats: " + protobufNodeStats);
         return protobufNodeStats;
     }
 
@@ -156,7 +151,6 @@ public void writeTo(OutputStream out) throws IOException {
 
     @Override
     protected ProtobufNodeStats newNodeResponse(byte[] in) throws IOException {
-        System.out.println("Inside newNodeResponse with byte array");
         return new ProtobufNodeStats(in);
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateRequest.java
index d75710fe10b54..c8cd4cab26708 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateRequest.java
@@ -75,16 +75,6 @@ public ClusterStateRequest(StreamInput in) throws IOException {
         indicesOptions = IndicesOptions.readIndicesOptions(in);
         waitForTimeout = in.readTimeValue();
         waitForMetadataVersion = in.readOptionalLong();
-        System.out.println("ClusterStateRequest");
-        System.out.println("routingTable: " + routingTable);
-        System.out.println("nodes: " + nodes);
-        System.out.println("metadata: " + metadata);
-        System.out.println("blocks: " + blocks);
-        System.out.println("customs: " + customs);
-        System.out.println("indices: " + indices);
-        System.out.println("indicesOptions: " + indicesOptions);
-        System.out.println("waitForTimeout: " + waitForTimeout);
-        System.out.println("waitForMetadataVersion: " + waitForMetadataVersion);
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateResponse.java
index efc0dfbd1ac6e..ce3b020280b16 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateResponse.java
@@ -55,21 +55,15 @@ public class ClusterStateResponse extends ActionResponse {
 
     public ClusterStateResponse(StreamInput in) throws IOException {
         super(in);
-        System.out.println("ClusterStateResponse");
-        System.out.println("Stream input: " + in);
         clusterName = new ClusterName(in);
-        System.out.println("Cluster name: " + clusterName);
         clusterState = in.readOptionalWriteable(innerIn -> ClusterState.readFrom(innerIn, null));
         waitForTimedOut = in.readBoolean();
     }
 
     public ClusterStateResponse(ClusterName clusterName, ClusterState clusterState, boolean waitForTimedOut) {
-        System.out.println("Inside ClusterStateResponse constructor");
         this.clusterName = clusterName;
         this.clusterState = clusterState;
         this.waitForTimedOut = waitForTimedOut;
-        System.out.println("Cluster name: " + clusterName);
-        System.out.println("Cluster state: " + clusterState);
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
index f3d0c8a02eace..5977162c4a6c2 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
@@ -59,7 +59,6 @@ public ProtobufClusterStateRequest(boolean routingTable, boolean nodes, boolean
     
     public ProtobufClusterStateRequest(CodedInputStream in) throws IOException {
         super(in);
-        System.out.println("ProtobufClusterStateRequest constructor");
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
index 157d5a415d1f5..61df01b94aedc 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
@@ -54,18 +54,14 @@ public class ProtobufClusterStateResponse extends ProtobufActionResponse impleme
 
     public ProtobufClusterStateResponse(CodedInputStream in) throws IOException {
         super(in);
-        System.out.println("Inside ProtobufClusterStateResponse constructor");
-        System.out.println("CodedInputStream in: " + in.readTag());
         ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
         String cluster_name = in.readString();
-        System.out.println("cluster_name: " + cluster_name);
         clusterName = new ClusterName(cluster_name);
         clusterState = protobufStreamInput.readOptionalWriteable(innerIn -> ClusterState.readFrom(innerIn, null));
         waitForTimedOut = in.readBool();
     }
 
     public ProtobufClusterStateResponse(ClusterName clusterName, ClusterState clusterState, boolean waitForTimedOut) {
-        System.out.println("Inside ProtobufClusterStateResponse constructor");
         this.clusterName = clusterName;
         this.clusterState = clusterState;
         this.waitForTimedOut = waitForTimedOut;
@@ -76,7 +72,6 @@ public ProtobufClusterStateResponse(ClusterName clusterName, ClusterState cluste
         ImmutableOpenMap<String, DiscoveryNode> allNodes = nodes.getNodes();
 
         Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> allNodesMap = convertNodes(allNodes);
-        System.out.println("All nodes map:" + allNodes);
         discoveryNodesBuilder.putAllAllNodes(allNodesMap).setClusterManagerNodeId(nodes.getClusterManagerNodeId()).setLocalNodeId(nodes.getLocalNodeId()).setMinNonClientNodeVersion(nodes.getSmallestNonClientNodeVersion().toString()).setMaxNonClientNodeVersion(nodes.getLargestNonClientNodeVersion().toString()).setMinNodeVersion(nodes.getMinNodeVersion().toString()).setMaxNodeVersion(nodes.getMaxNodeVersion().toString());
 
         ClusterStateResponseProto.ClusterStateRes.ClusterState.Builder clusterStateBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.newBuilder();
@@ -89,7 +84,6 @@ public ProtobufClusterStateResponse(ClusterName clusterName, ClusterState cluste
                                             .setClusterState(clusterStateBuilder.build())
                                             .setWaitForTimedOut(waitForTimedOut)
                                             .build();
-        System.out.println("Proto cluster state response: " + this.clusterStateRes);
     }
 
     private Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> convertNodes(ImmutableOpenMap<String, DiscoveryNode> nodes) {
@@ -97,13 +91,9 @@ private Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.Disco
         if (nodes.isEmpty()) {
             return convertedNodes;
         }
-        System.out.println("In convertNodes");
-        System.out.println("Nodes: " + nodes);
         Iterator<String> keysIt = nodes.keysIt();
         while(keysIt.hasNext()) {
-            System.out.println("Inside while loop");
             String key = keysIt.next();
-            System.out.println("Key: " + key);
             DiscoveryNode node = nodes.get(key);
             Set<ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole> nodeRoles = new HashSet<>();
             node.getRoles().forEach(role -> {
@@ -144,7 +134,6 @@ public boolean isWaitForTimedOut() {
 
     @Override
     public void writeTo(CodedOutputStream out) throws IOException {
-        // System.out.println("Inside writeTo of ProtobufClusterStateResponse");
         ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         clusterName.writeTo(out);
         protobufStreamOutput.writeOptionalWriteable(clusterState);
@@ -162,32 +151,6 @@ public ClusterStateRes response() {
 
     public ProtobufClusterStateResponse(byte[] data) throws IOException {
         this.clusterStateRes = ClusterStateResponseProto.ClusterStateRes.parseFrom(data);
-        // this.clusterName = new ClusterName(this.clusterStateRes.getClusterName());
-        // org.opensearch.server.proto.ClusterStateResponseProto.ClusterStateRes.ClusterState clusterState = this.clusterStateRes.getClusterState();
-        // org.opensearch.server.proto.ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes discoveryNodesProto = clusterState.getNodes();
-        // discoveryNodesProto.getAllNodesMap().forEach((key, value) -> {
-        //     System.out.println("Key: " + key);
-        //     System.out.println("Value: " + value);
-        // });
-        // Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> nodeMap = discoveryNodesProto.getAllNodesMap();
-        // ImmutableOpenMap<String, DiscoveryNode> allNodes = new ImmutableOpenMap.Builder<String, DiscoveryNode>().build();
-        // for (Map.Entry<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> entry : nodeMap.entrySet()) {
-        //     String key = entry.getKey();
-        //     ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node value = entry.getValue();
-        //     Set<DiscoveryNodeRole> roles = new HashSet<>();
-        //     value.getRolesList().forEach(role -> {
-        //         String roleName = role.getRoleName();
-        //         String roleNameAbbreviation = role.getRoleNameAbbreviation();
-        //         boolean canContainData = role.getCanContainData();
-        //         DiscoveryNodeRole discoveryNodeRole = DiscoveryNode.roleMap.get(roleName);
-        //         roles.add(discoveryNodeRole);
-        //     });
-        //     DiscoveryNode node = new DiscoveryNode();
-        //     allNodes = allNodes.copyAndPut(key, node);
-        // }
-        // allNodes.putAll(nodeMap);
-        // DiscoveryNodes discoveryNodes = new DiscoveryNodes(discoveryNodesProto.getClusterManagerNodeId(), discoveryNodesProto.getLocalNodeId(), discoveryNodesProto.getMinNonClientNodeVersion(), discoveryNodesProto.getMaxNonClientNodeVersion(), discoveryNodesProto.getMinNodeVersion(), discoveryNodesProto.getMaxNodeVersion());
-        // this.clusterState = new ClusterState(clusterName, clusterState.getVersion(), clusterState.getStateUUID(), null, null, null, null, null, 0, waitForTimedOut);
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
index 1257bfcddbfed..ccac09b71d6fd 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
@@ -99,8 +99,6 @@ protected void clusterManagerOperation(
         final ClusterState state,
         final ActionListener<ProtobufClusterStateResponse> listener
     ) throws IOException {
-
-        System.out.println("Inside ProtobufTransportClusterStateAction.clusterManagerOperation");
         final Predicate<ClusterState> acceptableClusterStatePredicate = request.waitForMetadataVersion() == null
             ? clusterState -> true
             : clusterState -> clusterState.metadata().version() >= request.waitForMetadataVersion();
@@ -148,9 +146,6 @@ public void onTimeout(TimeValue timeout) {
 
     private ProtobufClusterStateResponse buildResponse(final ProtobufClusterStateRequest request, final ClusterState currentState) {
         logger.trace("Serving cluster state request using version {}", currentState.version());
-        System.out.println("Protobuf Building cluster state response");
-        System.out.println("ProtobufClusterStateRequest: " + request.toString());
-        System.out.println("ClusterState: " + currentState.toString());
         ClusterState.Builder builder = ClusterState.builder(currentState.getClusterName());
         builder.version(currentState.version());
         builder.stateUUID(currentState.stateUUID());
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
index e5b487b981669..05e817b4e9339 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
@@ -120,8 +120,6 @@ protected void clusterManagerOperation(
         final ClusterState state,
         final ActionListener<ClusterStateResponse> listener
     ) throws IOException {
-
-        System.out.println("Cluster state action called");
         final Predicate<ClusterState> acceptableClusterStatePredicate = request.waitForMetadataVersion() == null
             ? clusterState -> true
             : clusterState -> clusterState.metadata().version() >= request.waitForMetadataVersion();
@@ -169,9 +167,6 @@ public void onTimeout(TimeValue timeout) {
 
     private ClusterStateResponse buildResponse(final ClusterStateRequest request, final ClusterState currentState) {
         logger.trace("Serving cluster state request using version {}", currentState.version());
-        System.out.println("Building cluster state response");
-        System.out.println("ClusterStateRequest: " + request.toString());
-        System.out.println("ClusterState: " + currentState.toString());
         ClusterState.Builder builder = ClusterState.builder(currentState.getClusterName());
         builder.version(currentState.version());
         builder.stateUUID(currentState.stateUUID());
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java b/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
index 865f1d300c91f..0078815cdaf62 100644
--- a/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
@@ -76,7 +76,6 @@ protected ProtobufHandledTransportAction(
     class TransportHandler implements ProtobufTransportRequestHandler<Request> {
         @Override
         public final void messageReceived(final Request request, final TransportChannel channel, ProtobufTask task) {
-            System.out.println("ProtobufHandledTransportAction: messageReceived");
             // We already got the task created on the network layer - no need to create it again on the transport layer
             execute(task, request, new ProtobufChannelActionListener<>(channel, actionName, request));
         }
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java b/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
index 47a8c44fa5557..d0156218dc381 100644
--- a/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufTransportAction.java
@@ -149,9 +149,6 @@ public void onFailure(Exception e) {
      * Use this method when the transport action should continue to run in the context of the current task
     */
     public final void execute(ProtobufTask task, Request request, ActionListener<Response> listener) {
-        System.out.println("Inside execute");
-        System.out.println("task: " + task);
-        System.out.println("request: " + request);
         ActionRequestValidationException validationException = request.validate();
         if (validationException != null) {
             listener.onFailure(validationException);
@@ -189,10 +186,6 @@ private RequestFilterChain(ProtobufTransportAction<Request, Response> action, Lo
         @Override
         public void proceed(ProtobufTask task, String actionName, Request request, ActionListener<Response> listener) {
             int i = index.getAndIncrement();
-            System.out.println("Inside proceed");
-            System.out.println("task: " + task);
-            System.out.println("actionName: " + actionName);
-            System.out.println("request: " + request);
             try {
                 if (i < this.action.filters.length) {
                     this.action.filters[i].apply(task, actionName, request, listener, this);
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
index 93366069a52ea..95c9e8947bf3d 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
@@ -218,12 +218,8 @@ public Exception getTimeoutException(Exception e) {
 
         protected void doStart(ClusterState clusterState) {
             try {
-                System.out.println("ProtobufTransportClusterManagerNodeAction.doStart");
                 final DiscoveryNodes nodes = clusterService.state().nodes();
-                System.out.println("nodes: " + nodes);
-                // final DiscoveryNodes discoveryNodes = clusterService.state().nodes();
                 if (nodes.isLocalNodeElectedClusterManager() || localExecute(request)) {
-                    System.out.println("ProtobufTransportClusterManagerNodeAction.doStart.isLocalNodeElectedClusterManager");
                     // check for block, if blocked, retry, else, execute locally
                     final ClusterBlockException blockException = checkBlock(request, clusterState);
                     if (blockException != null) {
@@ -243,7 +239,6 @@ protected void doStart(ClusterState clusterState) {
                             });
                         }
                     } else {
-                        System.out.println("No blocks");
                         ActionListener<Response> delegate = ActionListener.delegateResponse(listener, (delegatedListener, t) -> {
                             if (t instanceof FailedToCommitClusterStateException || t instanceof NotClusterManagerException) {
                                 logger.debug(
@@ -263,13 +258,10 @@ protected void doStart(ClusterState clusterState) {
                             .execute(ActionRunnable.wrap(delegate, l -> clusterManagerOperation(task, request, clusterState, l)));
                     }
                 } else {
-                    System.out.println("In else");
                     if (nodes.getClusterManagerNode() == null) {
-                        System.out.println("In else if");
                         logger.debug("no known cluster-manager node, scheduling a retry");
                         retryOnMasterChange(clusterState, null);
                     } else {
-                        System.out.println("In else else");
                         DiscoveryNode clusterManagerNode = nodes.getClusterManagerNode();
                         final String actionName = getClusterManagerActionName(clusterManagerNode);
                         transportService.sendRequest(
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
index 7de1327a10423..13c576bd120c7 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
@@ -231,11 +231,8 @@ public Exception getTimeoutException(Exception e) {
 
         protected void doStart(ClusterState clusterState) {
             try {
-                System.out.println("TransportClusterManagerNodeAction.doStart");
                 final DiscoveryNodes nodes = clusterState.nodes();
-                // System.out.println("nodes: " + nodes);
                 if (nodes.isLocalNodeElectedClusterManager() || localExecute(request)) {
-                    System.out.println("TransportClusterManagerNodeAction.doStart.isLocalNodeElectedClusterManager");
                     // check for block, if blocked, retry, else, execute locally
                     final ClusterBlockException blockException = checkBlock(request, clusterState);
                     if (blockException != null) {
@@ -255,7 +252,6 @@ protected void doStart(ClusterState clusterState) {
                             });
                         }
                     } else {
-                        System.out.println("No blocks");
                         ActionListener<Response> delegate = ActionListener.delegateResponse(listener, (delegatedListener, t) -> {
                             if (t instanceof FailedToCommitClusterStateException || t instanceof NotClusterManagerException) {
                                 logger.debug(
@@ -275,9 +271,7 @@ protected void doStart(ClusterState clusterState) {
                             .execute(ActionRunnable.wrap(delegate, l -> clusterManagerOperation(task, request, clusterState, l)));
                     }
                 } else {
-                    // System.out.println("In else");
                     if (nodes.getClusterManagerNode() == null) {
-                        // System.out.println("In else if");
                         logger.debug("no known cluster-manager node, scheduling a retry");
                         retryOnMasterChange(clusterState, null);
                     } else {
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
index fa6bf3d01cc74..a827f6a6c4526 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
@@ -225,9 +225,7 @@ class AsyncAction {
         }
 
         void start() {
-            // System.out.println("ProtoTransportNodesAction.AsyncAction.start");
             final DiscoveryNode[] nodes = request.concreteNodes();
-            // System.out.println("Nodes: " + nodes[0]);
             if (nodes.length == 0) {
                 // nothing to notify
                 threadPool.generic().execute(() -> listener.onResponse(newResponse(request, responses)));
@@ -260,13 +258,11 @@ public NodeResponse read(CodedInputStream in) throws IOException {
 
                             @Override
                             public void handleResponse(NodeResponse response) {
-                                // System.out.println("ProtoTransportNodesAction.AsyncAction.start.handleResponse");
                                 onOperation(idx, response);
                             }
 
                             @Override
                             public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                                // System.out.println("ProtoTransportNodesAction.AsyncAction.start.handleExceptionProtobuf");
                                 onFailure(idx, node.getId(), exp);
                             }
 
@@ -329,7 +325,6 @@ class NodeTransportHandler implements ProtobufTransportRequestHandler<NodeReques
 
         @Override
         public void messageReceived(NodeRequest request, TransportChannel channel, ProtobufTask task) throws Exception {
-            System.out.println("ProtoTransportNodesAction.NodeTransportHandler.messageReceived");
             channel.sendResponse(nodeOperation(request, task));
         }
     }
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java b/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
index b87d6566850d5..e22d9e00ab7fc 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
@@ -244,9 +244,7 @@ class AsyncAction {
         }
 
         void start() {
-            // System.out.println("TransportNodesAction.AsyncAction.start");
             final DiscoveryNode[] nodes = request.concreteNodes();
-            // System.out.println("Nodes: " + nodes[0]);
             if (nodes.length == 0) {
                 // nothing to notify
                 threadPool.generic().execute(() -> listener.onResponse(newResponse(request, responses)));
diff --git a/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java b/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
index f19cf4d076f61..0ed6bc96ef3d2 100644
--- a/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
+++ b/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
@@ -143,9 +143,6 @@ public <Request extends ProtobufActionRequest, Response extends ProtobufActionRe
             Request request,
             ActionListener<Response> listener
         ) {
-            // System.out.println("Nodes info execute");
-            // System.out.println("action: " + action);
-            // System.out.println("request: " + request);
             client.execute(action, request, listener);
         }
 
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterName.java b/server/src/main/java/org/opensearch/cluster/ClusterName.java
index 3a7535303c0cc..b74a393bdd658 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterName.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterName.java
@@ -76,8 +76,6 @@ public ClusterName(CodedInputStream input) throws IOException {
     }
 
     public ClusterName(String value) {
-        System.out.println("Hello from ClusterName.java");
-        System.out.println("value: " + value);
         this.value = value.intern();
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterState.java b/server/src/main/java/org/opensearch/cluster/ClusterState.java
index 03108760b7eee..11d8e445509e4 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterState.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterState.java
@@ -801,7 +801,6 @@ public static ClusterState readFrom(CodedInputStream in, DiscoveryNode localNode
 
     @Override
     public void writeTo(StreamOutput out) throws IOException {
-        // System.out.println("writeTo");
         clusterName.writeTo(out);
         out.writeLong(version);
         out.writeString(stateUUID);
@@ -827,7 +826,6 @@ public void writeTo(StreamOutput out) throws IOException {
 
      @Override
     public void writeTo(CodedOutputStream out) throws IOException {
-        // System.out.println("writeTo CodedOutputStream");
         ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
         clusterName.writeTo(out);
         out.writeInt64NoTag(version);
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
index b5c4f2b9d27b9..2de445e4fbd2e 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
@@ -348,17 +348,9 @@ Table buildTable(
         ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes nodes = state.response().getClusterState().getNodes();
         String clusterManagerId = nodes.getClusterManagerNodeId();
         Table table = getTableWithHeader(req);
-        // System.out.println("Nodes: " + nodes);
-        // System.out.println("clusterManagerId: " + clusterManagerId);
-        // System.out.println("state: " + state);
-        // System.out.println("nodesInfo: " + nodesInfo);
-        // System.out.println("nodesStats: " + nodesStats);
-
         for (ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node node : nodes.getAllNodesMap().values()) {
             NodesInfo info = nodesInfo.nodesMap().get(node.getNodeId());
-            System.out.println("info: " + info);
             NodesStats stats = nodesStats.nodesMap().get(node.getNodeId());
-            System.out.println("stats: " + stats);
 
             // JvmInfo jvmInfo = info == null ? null : info.getInfo(JvmInfo.class);
             // ProtobufJvmStats jvmStats = stats == null ? null : stats.getJvm();
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
index 2a7473cb414ad..2cabe1e649d70 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
@@ -357,11 +357,6 @@ Table buildTable(
         DiscoveryNodes nodes = state.getState().nodes();
         String clusterManagerId = nodes.getClusterManagerNodeId();
         Table table = getTableWithHeader(req);
-        // System.out.println("Nodes: " + nodes);
-        // System.out.println("clusterManagerId: " + clusterManagerId);
-        // System.out.println("state: " + state);
-        // System.out.println("nodesInfo: " + nodesInfo);
-        // System.out.println("nodesStats: " + nodesStats);
         
         for (DiscoveryNode node : nodes) {
             NodeInfo info = nodesInfo.getNodesMap().get(node.getId());
diff --git a/server/src/main/java/org/opensearch/transport/ClusterConnectionManager.java b/server/src/main/java/org/opensearch/transport/ClusterConnectionManager.java
index aa973a348811a..1a4854cfad8db 100644
--- a/server/src/main/java/org/opensearch/transport/ClusterConnectionManager.java
+++ b/server/src/main/java/org/opensearch/transport/ClusterConnectionManager.java
@@ -122,7 +122,6 @@ public void connectToNode(
         ConnectionValidator connectionValidator,
         ActionListener<Void> listener
     ) throws ConnectTransportException {
-        // System.out.println("Connecting to node");
         ConnectionProfile resolvedProfile = ConnectionProfile.resolveConnectionProfile(connectionProfile, defaultProfile);
         if (node == null) {
             listener.onFailure(new ConnectTransportException(null, "can't connect to a null node"));
@@ -202,9 +201,6 @@ public void connectToNode(
      */
     @Override
     public Transport.Connection getConnection(DiscoveryNode node) {
-        // System.out.println("ClusterConnectionManager.getConnection");
-        // System.out.println("node = " + node);
-        // System.out.println("connectedNodes = " + connectedNodes);
         Transport.Connection connection = connectedNodes.get(node);
         if (connection == null) {
             throw new NodeNotConnectedException(node, "Node not connected");
diff --git a/server/src/main/java/org/opensearch/transport/Header.java b/server/src/main/java/org/opensearch/transport/Header.java
index a8fac66be21d8..988a5ea8e50c1 100644
--- a/server/src/main/java/org/opensearch/transport/Header.java
+++ b/server/src/main/java/org/opensearch/transport/Header.java
@@ -125,7 +125,6 @@ Tuple<Map<String, String>, Map<String, Set<String>>> getHeaders() {
     }
 
     void finishParsingHeader(StreamInput input) throws IOException {
-        System.out.println("finishParsingHeader");
         this.headers = ThreadContext.readHeadersFromStream(input);
 
         if (isRequest()) {
@@ -142,7 +141,6 @@ void finishParsingHeader(StreamInput input) throws IOException {
     }
 
     void finishParsingHeaderProtobuf(CodedInputStream input) throws IOException {
-        System.out.println("finishParsingHeaderProtobuf");
         this.headers = ThreadContext.readHeadersFromStreamProtobuf(input);
         ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(input);
 
diff --git a/server/src/main/java/org/opensearch/transport/InboundAggregator.java b/server/src/main/java/org/opensearch/transport/InboundAggregator.java
index 8ff6e05677de6..060ccec3563e2 100644
--- a/server/src/main/java/org/opensearch/transport/InboundAggregator.java
+++ b/server/src/main/java/org/opensearch/transport/InboundAggregator.java
@@ -114,7 +114,6 @@ public void aggregate(ReleasableBytesReference content) {
     }
 
     public InboundMessage finishAggregation() throws IOException {
-        System.out.println("InboundAggregator.finishAggregation");
         ensureOpen();
         final ReleasableBytesReference releasableContent;
         if (isFirstContent()) {
diff --git a/server/src/main/java/org/opensearch/transport/InboundDecoder.java b/server/src/main/java/org/opensearch/transport/InboundDecoder.java
index 052cbc79aa139..6e21ab67f1cc0 100644
--- a/server/src/main/java/org/opensearch/transport/InboundDecoder.java
+++ b/server/src/main/java/org/opensearch/transport/InboundDecoder.java
@@ -82,7 +82,6 @@ public int decode(ReleasableBytesReference reference, Consumer<Object> fragmentC
     public int internalDecode(ReleasableBytesReference reference, Consumer<Object> fragmentConsumer) throws IOException {
         if (isOnHeader()) {
             int messageLength = TcpTransport.readMessageLength(reference);
-            System.out.println("Message length: " + messageLength);
             if (messageLength == -1) {
                 return 0;
             } else if (messageLength == 0) {
@@ -96,14 +95,6 @@ public int internalDecode(ReleasableBytesReference reference, Consumer<Object> f
                     totalNetworkSize = messageLength + TcpHeader.BYTES_REQUIRED_FOR_MESSAGE_SIZE;
 
                     Header header = readHeader(version, messageLength, reference);
-                    System.out.println("InboundDecoder.internalDecode: header = " + header);
-                    System.out.println("InboundDecoder.internalDecode: header.getNetworkMessageSize() = " + header.getNetworkMessageSize());
-                    System.out.println("InboundDecoder.internalDecode: header.getActionName() = " + header.getActionName());
-                    // if (header.getNetworkMessageSize() == 108 && header.getActionName().equals("cluster:monitor/state")) {
-                    //     System.out.println("Coming in the if condition finally");
-                    //     header = readHeaderProtobuf(version, messageLength, reference);
-                    // }
-                    System.out.println("InboundDecoder.internalDecode after protobuf: header = " + header);
                     bytesConsumed += headerBytesToRead;
                     if (header.isCompressed()) {
                         decompressor = new TransportDecompressor(recycler);
@@ -216,16 +207,11 @@ static Header readHeader(Version version, int networkMessageSize, BytesReference
     }
 
     static Header readHeaderProtobuf(Version version, int networkMessageSize, BytesReference bytesReference) throws IOException {
-        System.out.println("Reading header protobuf");
-        System.out.println("Bytes reference:" + bytesReference.toString());
         CodedInputStream streamInput = bytesReference.protobufInput();
 
         streamInput.skipRawBytes(TcpHeader.BYTES_REQUIRED_FOR_MESSAGE_SIZE);
         long requestId = streamInput.readInt64();
-        System.out.println("Read request id:" + requestId);
         byte status = streamInput.readRawByte();
-        System.out.println("Read status:" + status);
-        System.out.println("Read version:" + streamInput.readInt32());
         Version remoteVersion = Version.fromId(streamInput.readInt32());
         Header header = new Header(networkMessageSize, requestId, status, remoteVersion);
         final IllegalStateException invalidVersion = ensureVersionCompatibility(remoteVersion, version, header.isHandshake());
diff --git a/server/src/main/java/org/opensearch/transport/InboundHandler.java b/server/src/main/java/org/opensearch/transport/InboundHandler.java
index acc47fa0d2afa..d41a6d9126122 100644
--- a/server/src/main/java/org/opensearch/transport/InboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/InboundHandler.java
@@ -142,8 +142,6 @@ void setSlowLogThreshold(TimeValue slowLogThreshold) {
     }
 
     void inboundMessage(TcpChannel channel, InboundMessage message) throws Exception {
-        System.out.println("InboundHandler.inboundMessage");
-        System.out.println("message: " + message);
         final long startTime = threadPool.relativeTimeInMillis();
         channel.getChannelStats().markAccessed(startTime);
         TransportLogger.logInboundMessage(channel, message);
@@ -156,8 +154,6 @@ void inboundMessage(TcpChannel channel, InboundMessage message) throws Exception
     }
 
     void inboundMessageProtobuf(TcpChannel channel, BytesReference message) throws IOException {
-        System.out.println("InboundHandler.inboundMessageProtobuf");
-        System.out.println("message: " + message);
         final long startTime = threadPool.relativeTimeInMillis();
         channel.getChannelStats().markAccessed(startTime);
         ProtobufOutboundMessage protobufOutboundMessage = new ProtobufOutboundMessage(BytesReference.toBytes(message)); 
@@ -170,12 +166,8 @@ void inboundMessageProtobuf(TcpChannel channel, BytesReference message) throws I
     private static final CodedInputStream EMPTY_CODED_INPUT_STREAM = CodedInputStream.newInstance(BytesRef.EMPTY_BYTES);
 
     private void messageReceivedProtobuf(TcpChannel channel, ProtobufOutboundMessage message, long startTime) throws IOException {
-        System.out.println("InboundHandler.messageReceivedProtobuf");
         final InetSocketAddress remoteAddress = channel.getRemoteAddress();
         final org.opensearch.server.proto.OutboundMessageProto.OutboundMsg.Header header = message.getHeader();
-        System.out.println("header: " + header);
-        System.out.println("message: " + message);
-        System.out.println("remoteAddress: " + remoteAddress);
 
         ThreadContext threadContext = threadPool.getThreadContext();
         try (ThreadContext.StoredContext existing = threadContext.stashContext()) {
@@ -184,24 +176,15 @@ private void messageReceivedProtobuf(TcpChannel channel, ProtobufOutboundMessage
             threadContext.setHeaders(headers);
             threadContext.putTransient("_remote_address", remoteAddress);
             if (TransportStatus.isRequest(header.getStatus().byteAt(0))) {
-                System.out.println("InboundHandler.messageReceivedProtobuf isRequest");
-                System.out.println("Header: " + header);
-                System.out.println("message: " + message);
                 handleRequestProtobuf(channel, header, message);
             } else {
-                System.out.println("InboundHandler.messageReceivedProtobuf isResponse");
                 long requestId = header.getRequestId();
                 TransportResponseHandler<? extends TransportResponse> handler = responseHandlers.onResponseReceived(
                     requestId,
                     messageListener
                 );
-                System.out.println("Found the handler: " + handler);
                 if (handler != null) {
-                    System.out.println("Handler for the response is: " + handler);
-                    System.out.println("Handler for the response is: " + handler.toString());
-                    System.out.println("The final message is: " + message);
                     if (handler.toString().contains("Protobuf")) {
-                        System.out.println("Trying protobuf");
                         handleProtobufResponse(requestId, remoteAddress, message, handler);
                     }
                 }
@@ -221,12 +204,8 @@ private void messageReceivedProtobuf(TcpChannel channel, ProtobufOutboundMessage
     }
 
     private void messageReceived(TcpChannel channel, InboundMessage message, long startTime) throws IOException {
-        System.out.println("InboundHandler.messageReceived");
         final InetSocketAddress remoteAddress = channel.getRemoteAddress();
         final Header header = message.getHeader();
-        System.out.println("header: " + header);
-        System.out.println("message: " + message);
-        System.out.println("remoteAddress: " + remoteAddress);
         assert header.needsToReadVariableHeader() == false;
 
         ThreadContext threadContext = threadPool.getThreadContext();
@@ -235,11 +214,8 @@ private void messageReceived(TcpChannel channel, InboundMessage message, long st
             threadContext.setHeaders(header.getHeaders());
             threadContext.putTransient("_remote_address", remoteAddress);
             if (header.isRequest()) {
-                System.out.println("InboundHandler.messageReceived isRequest");
-                System.out.println("Header: " + header);
                 handleRequest(channel, header, message);
             } else {
-                System.out.println("InboundHandler.messageReceived isResponse else");
                 // Responses do not support short circuiting currently
                 assert message.isShortCircuit() == false;
                 final TransportResponseHandler<?> handler;
@@ -256,41 +232,27 @@ private void messageReceived(TcpChannel channel, InboundMessage message, long st
                     } else {
                         handler = theHandler;
                     }
-                    System.out.println("Found the handler: " + handler);
                 }
                 // ignore if its null, the service logs it
                 if (handler != null) {
-                    System.out.println("Handler for the response is: " + handler);
-                    System.out.println("Handler for the response is: " + handler.toString());
-                    System.out.println("Teh final message is: " + message);
                     if (handler.toString().contains("Protobuf")) {
-                        System.out.println("Trying protobuf");
-                        System.out.println("finale message inside protobuf is: " + message);
-                        System.out.println("finale message inside protobuf is: " + message.getContentLength());
                         final CodedInputStream streamInput;
                         if (message.getContentLength() > 0 || header.getVersion().equals(Version.CURRENT) == false) {
-                            System.out.println("Message content length is greater than 0 or header version is not current");
                             StreamInput streamInput1 = namedWriteableStream(message.openOrGetStreamInput());
                             streamInput = CodedInputStream.newInstance(streamInput1);
-                            System.out.println("Protobuf input is: " + streamInput);
-                            // assertRemoteVersion(streamInput, header.getVersion());
                             if (header.isError()) {
                                 handlerResponseErrorProtobuf(requestId, streamInput, handler);
                             } else {
                                 handleResponseProtobuf(requestId, remoteAddress, streamInput, handler);
                             }
                         } else {
-                            System.out.println("Protobuf else condition");
                             assert header.isError() == false;
                             handleResponseProtobuf(requestId, remoteAddress, EMPTY_CODED_INPUT_STREAM, handler);
                         }
                     } else {
                         final StreamInput streamInput;
-                        System.out.println("Trying stream");
                         if (message.getContentLength() > 0 || header.getVersion().equals(Version.CURRENT) == false) {
-                            System.out.println("if condition");
                             streamInput = namedWriteableStream(message.openOrGetStreamInput());
-                            System.out.println("Stream input is: " + streamInput);
                             assertRemoteVersion(streamInput, header.getVersion());
                             if (header.isError()) {
                                 handlerResponseError(requestId, streamInput, handler);
@@ -298,7 +260,6 @@ private void messageReceived(TcpChannel channel, InboundMessage message, long st
                                 handleResponse(requestId, remoteAddress, streamInput, handler);
                             }
                         } else {
-                            System.out.println("else condition");
                             assert header.isError() == false;
                             handleResponse(requestId, remoteAddress, EMPTY_STREAM_INPUT, handler);
                         }
@@ -324,12 +285,6 @@ private <T extends TransportRequest> void handleRequestProtobuf(TcpChannel chann
         final String action = outboundMsg.getAction();
         final long requestId = header.getRequestId();
         final Version version = Version.fromString(outboundMsg.getVersion());
-        System.out.println("InboundHandler.handleRequestProtobuf");
-        System.out.println("Header: " + header);
-        System.out.println("Action: " + action);
-        System.out.println("RequestId: " + requestId);
-        System.out.println("Version: " + version);
-        System.out.println("Message: " + outboundMsg);
         final TransportChannel transportChannel = new TcpTransportChannel(
             outboundHandler,
             channel,
@@ -346,13 +301,10 @@ private <T extends TransportRequest> void handleRequestProtobuf(TcpChannel chann
             final ProtobufRequestHandlerRegistry<T> reg = protobufRequestHandlers.getHandler(action);
             assert reg != null;
             if (outboundMsg.hasClusterStateReq()) {
-                System.out.println("InboundHandler.handleRequestProtobuf hasClusterStateReq");
                 final ClusterStateReq clusterStateReq = outboundMsg.getClusterStateReq();
-                System.out.println("ClusterStateReq: " + clusterStateReq);
                 ProtobufClusterStateRequest protobufClusterStateRequest = new ProtobufClusterStateRequest(clusterStateReq.toByteArray());
                 final T request = (T) protobufClusterStateRequest;
                 request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
-                System.out.println("Transport request: " + request);
                 final String executor = reg.getExecutor();
                 if (ThreadPool.Names.SAME.equals(executor)) {
                     try {
@@ -364,15 +316,11 @@ private <T extends TransportRequest> void handleRequestProtobuf(TcpChannel chann
                     threadPool.executor(executor).execute(new ProtobufRequestHandler<>(reg, request, transportChannel));
                 }
             } else if (outboundMsg.hasNodesInfoReq()) {
-                System.out.println("InboundHandler.handleRequestProtobuf hasNodesInfoReq");
                 final NodesInfoReq nodesInfoReq = outboundMsg.getNodesInfoReq();
-                System.out.println("NodesInfoReq: " + nodesInfoReq);
                 try {
                     ProtobufNodesInfoRequest protobufNodesInfoRequest = new ProtobufNodesInfoRequest(nodesInfoReq.toByteArray());
-                    System.out.println("Converted node info request: " + protobufNodesInfoRequest);
                     final T request = (T) new NodeInfoRequest(protobufNodesInfoRequest);
                     request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
-                    System.out.println("Transport request: " + request);
                     final String executor = reg.getExecutor();
                     if (ThreadPool.Names.SAME.equals(executor)) {
                         try {
@@ -381,22 +329,17 @@ private <T extends TransportRequest> void handleRequestProtobuf(TcpChannel chann
                             sendErrorResponse(reg.getAction(), transportChannel, e);
                         }
                     } else {
-                        System.out.println("In else condition for thread pool");
                         threadPool.executor(executor).execute(new ProtobufRequestHandler<>(reg, request, transportChannel));
                     }
                 } catch (Exception e) {
                     System.out.println("Exception: " + e);
                 }             
             } else if (outboundMsg.hasNodesStatsReq()) {
-                System.out.println("InboundHandler.handleRequestProtobuf hasNodesStatsReq");
                 final NodesStatsReq nodesStatsReq = outboundMsg.getNodesStatsReq();
-                System.out.println("NodesStatsReq: " + nodesStatsReq);
                 try {
                     ProtobufNodesStatsRequest protobufNodesStatsRequest = new ProtobufNodesStatsRequest(nodesStatsReq.toByteArray());
-                    System.out.println("Converted node stats request: " + protobufNodesStatsRequest);
                     final T request = (T) new NodeStatsRequest(protobufNodesStatsRequest);
                     request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
-                    System.out.println("Transport request: " + request);
                     final String executor = reg.getExecutor();
                     if (ThreadPool.Names.SAME.equals(executor)) {
                         try {
@@ -405,7 +348,6 @@ private <T extends TransportRequest> void handleRequestProtobuf(TcpChannel chann
                             sendErrorResponse(reg.getAction(), transportChannel, e);
                         }
                     } else {
-                        System.out.println("In else condition for thread pool");
                         threadPool.executor(executor).execute(new ProtobufRequestHandler<>(reg, request, transportChannel));
                     }
                 } catch (Exception e) {
@@ -421,14 +363,7 @@ private <T extends TransportRequest> void handleRequest(TcpChannel channel, Head
         final String action = header.getActionName();
         final long requestId = header.getRequestId();
         final Version version = header.getVersion();
-        System.out.println("InboundHandler.handleRequest");
-        System.out.println("Header: " + header);
-        System.out.println("Action: " + action);
-        System.out.println("RequestId: " + requestId);
-        System.out.println("Version: " + version);
-        System.out.println("Message: " + message);
         if (header.isHandshake()) {
-            System.out.println("InboundHandler.handleRequest isHandshake");
             messageListener.onRequestReceived(requestId, action);
             // Cannot short circuit handshakes
             assert message.isShortCircuit() == false;
@@ -463,7 +398,6 @@ private <T extends TransportRequest> void handleRequest(TcpChannel channel, Head
                 }
             }
         } else {
-            System.out.println("InboundHandler.handleRequest else isNotHandshake");
             final TransportChannel transportChannel = new TcpTransportChannel(
                 outboundHandler,
                 channel,
@@ -490,7 +424,6 @@ private <T extends TransportRequest> void handleRequest(TcpChannel channel, Head
                         request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
                         checkStreamIsFullyConsumed(requestId, action, stream);
 
-                        System.out.println("Deserialized request: " + request);
                         final String executor = reg.getExecutor();
                         if (ThreadPool.Names.SAME.equals(executor)) {
                             try {
@@ -499,11 +432,9 @@ private <T extends TransportRequest> void handleRequest(TcpChannel channel, Head
                                 sendErrorResponse(reg.getAction(), transportChannel, e);
                             }
                         } else {
-                            System.out.println("In else condition for thread pool normal");
                             threadPool.executor(executor).execute(new RequestHandler<>(reg, request, transportChannel));
                         }
                     } catch (Exception e) {
-                        System.out.println("Coming in here to try protobuf");
                         // final CodedInputStream stream = message.openOrGetProtobufCodedInput();
                         // final StreamInput stream = namedWriteableStream(message.openOrGetStreamInput());
                         // assertRemoteVersion(stream, header.getVersion());
@@ -516,7 +447,6 @@ private <T extends TransportRequest> void handleRequest(TcpChannel channel, Head
                         request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
                         // checkStreamIsFullyConsumed(requestId, action, stream);
 
-                        System.out.println("Deserialized request: " + request);
                         final String executor = reg.getExecutor();
                         if (ThreadPool.Names.SAME.equals(executor)) {
                             try {
@@ -663,7 +593,6 @@ private <T extends TransportResponse> void handleResponse(
         final StreamInput stream,
         final TransportResponseHandler<T> handler
     ) {
-        System.out.println("handleResponse");
         final T response;
         try {
             response = handler.read(stream);
@@ -692,17 +621,13 @@ private <T extends TransportResponse> void handleProtobufResponse(
         final ProtobufOutboundMessage message,
         final TransportResponseHandler<T> handler
     ) throws IOException {
-        System.out.println("handleProtobufResponse");
         try {
             OutboundMsg outboundMsg = message.getMessage();
             if (outboundMsg.hasClusterStateRes()) {
-                System.out.println("InboundHandler.handleProtobufResponse hasClusterStateRes");
                 final ClusterStateRes clusterStateRes = outboundMsg.getClusterStateRes();
-                System.out.println("ClusterStateRes: " + clusterStateRes);
                 ProtobufClusterStateResponse protobufClusterStateResponse = new ProtobufClusterStateResponse(clusterStateRes.toByteArray());
                 final T response = (T) protobufClusterStateResponse;
                 response.remoteAddress(new TransportAddress(remoteAddress));
-                System.out.println("Transport response: " + response);
 
                 final String executor = handler.executor();
                 if (ThreadPool.Names.SAME.equals(executor)) {
@@ -711,13 +636,10 @@ private <T extends TransportResponse> void handleProtobufResponse(
                     threadPool.executor(executor).execute(() -> doHandleResponse(handler, response));
                 }
             } else if (outboundMsg.hasNodesInfoRes()) {
-                System.out.println("InboundHandler.handleProtobufResponse hasNodesInfoRes");
                 final NodesInfo nodesInfoRes = outboundMsg.getNodesInfoRes();
-                System.out.println("NodesInfoRes: " + nodesInfoRes);
                 ProtobufNodeInfo protobufNodeInfo = new ProtobufNodeInfo(nodesInfoRes.toByteArray());
                 final T response = (T) protobufNodeInfo;
                 response.remoteAddress(new TransportAddress(remoteAddress));
-                System.out.println("Transport nodes response: " + response);
 
                 final String executor = handler.executor();
                 if (ThreadPool.Names.SAME.equals(executor)) {
@@ -726,13 +648,10 @@ private <T extends TransportResponse> void handleProtobufResponse(
                     threadPool.executor(executor).execute(() -> doHandleResponse(handler, response));
                 }
             } else if (outboundMsg.hasNodesStatsRes()) {
-                System.out.println("InboundHandler.handleProtobufResponse hasNodesStatsRes");
                 final NodesStats nodesStatsRes = outboundMsg.getNodesStatsRes();
-                System.out.println("NodesStatsRes: " + nodesStatsRes);
                 ProtobufNodeStats protobufNodeStats = new ProtobufNodeStats(nodesStatsRes.toByteArray());
                 final T response = (T) protobufNodeStats;
                 response.remoteAddress(new TransportAddress(remoteAddress));
-                System.out.println("Transport nodes stats response: " + response);
 
                 final String executor = handler.executor();
                 if (ThreadPool.Names.SAME.equals(executor)) {
@@ -758,8 +677,6 @@ private <T extends TransportResponse> void handleResponseProtobuf(
         final CodedInputStream stream,
         final TransportResponseHandler<T> handler
     ) throws IOException {
-        System.out.println("handleResponseProtobuf");
-        System.out.println("seeing if the stream has something");
         System.out.println(stream.readTag());
         final T response;
         try {
diff --git a/server/src/main/java/org/opensearch/transport/InboundMessage.java b/server/src/main/java/org/opensearch/transport/InboundMessage.java
index 1106393a4cb1c..b15af4d236926 100644
--- a/server/src/main/java/org/opensearch/transport/InboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/InboundMessage.java
@@ -88,10 +88,8 @@ public Header getHeader() {
 
     public int getContentLength() {
         if (content == null) {
-            System.out.println("InboundMessage.getContentLength content is null");
             return 0;
         } else {
-            System.out.println("InboundMessage.getContentLength content is not null: " + content.length());
             return content.length();
         }
     }
@@ -121,7 +119,6 @@ public Releasable takeBreakerReleaseControl() {
     public StreamInput openOrGetStreamInput() throws IOException {
         assert isPing == false && content != null;
         if (streamInput == null) {
-            System.out.println("InboundMessage.openOrGetStreamInput");
             streamInput = content.streamInput();
             streamInput.setVersion(header.getVersion());
         }
@@ -131,7 +128,6 @@ public StreamInput openOrGetStreamInput() throws IOException {
     public CodedInputStream openOrGetProtobufCodedInput() throws IOException {
         assert isPing == false && content != null;
         if (codedInputStream == null) {
-            System.out.println("InboundMessage.openOrGetProtobufCodedInput");
             streamInput = content.streamInput();
             codedInputStream = CodedInputStream.newInstance(streamInput);
             ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(codedInputStream);
diff --git a/server/src/main/java/org/opensearch/transport/InboundPipeline.java b/server/src/main/java/org/opensearch/transport/InboundPipeline.java
index dde4ecaa54ed4..44899c27d75de 100644
--- a/server/src/main/java/org/opensearch/transport/InboundPipeline.java
+++ b/server/src/main/java/org/opensearch/transport/InboundPipeline.java
@@ -115,13 +115,6 @@ public void close() {
     }
 
     public void handleBytes(TcpChannel channel, ReleasableBytesReference reference) throws IOException {
-        System.out.println("Handle bytes in InboundPipeline");
-        System.out.println("Incoming bytes length: " + reference.length());
-        // System.out.println("Now the incoming bytes: ");
-        // for (int i = 0; i < reference.length(); i++) {
-        //     System.out.print(reference.get(i) + " ");
-        // }
-        System.out.println();
         if (uncaughtException != null) {
             throw new IllegalStateException("Pipeline state corrupted by uncaught exception", uncaughtException);
         }
@@ -136,19 +129,9 @@ public void handleBytes(TcpChannel channel, ReleasableBytesReference reference)
     public void doHandleBytes(TcpChannel channel, ReleasableBytesReference reference) throws IOException {
         try {
             byte[] incomingBytes = BytesReference.toBytes(reference);
-            System.out.println("Size of incoming bytes: " + incomingBytes.length);
             ProtobufOutboundMessage protobufOutboundMessage = new ProtobufOutboundMessage(incomingBytes);
             if (protobufOutboundMessage.isProtobuf()) {
-                // for (int i = 0; i < incomingBytes.length; i++) {
-                //     System.out.println("Byte " + i + " is: " + incomingBytes[i]);
-                // }
-                System.out.println("Last byte is 1");
                 forwardFragmentsProtobuf(channel, reference);
-                // byte[] newBytes = Arrays.copyOfRange(incomingBytes, 0, incomingBytes.length-1);
-                // reference = new ReleasableBytesReference(newBytes);
-
-                // ProtobufOutboundMessage protobufOutboundMessage = new ProtobufOutboundMessage(incomingBytes);
-                // System.out.println("Received protobuf message is: " + protobufOutboundMessage);
             }
         } catch (Exception e) {
         
diff --git a/server/src/main/java/org/opensearch/transport/OutboundHandler.java b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
index 5465c43601588..f2d019424fe50 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
@@ -135,14 +135,6 @@ void sendRequest(
             compressRequest
         );
 
-        System.out.println("OutboundHandler.sendRequest");
-        System.out.println("node: " + node);
-        System.out.println("channel: " + channel);
-        System.out.println("requestId: " + requestId);
-        System.out.println("action: " + action);
-        System.out.println("request: " + request.toString());
-        System.out.println("canonical: " + request.getClass().getCanonicalName());
-        System.out.println("message: " + message);
         ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onRequestSent(node, requestId, action, request, options));
         if (request.getClass().getCanonicalName().contains("ProtobufClusterState")) {
             // ExampleProtoRequest exampleProtoRequest = new ExampleProtoRequest(1, "message");
@@ -152,14 +144,12 @@ void sendRequest(
             ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufClusterStateRequest.request(), features, action);
             sendProtobufMessage(channel, protobufMessage, listener);
         } else if (request.getClass().getCanonicalName().contains("ProtobufTransportNodesInfo")) {
-            System.out.println("It is a nodes info request for protobuf");
             NodeInfoRequest protobufNodesInfoRequest = (NodeInfoRequest) request;
             byte[] bytes = new byte[1];
             bytes[0] = 0;
             ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufNodesInfoRequest.request().request(), features, action);
             sendProtobufMessage(channel, protobufMessage, listener);
         } else if (request.getClass().getCanonicalName().contains("ProtobufTransportNodesStats")) {
-            System.out.println("It is a nodes stats request for protobuf");
             NodeStatsRequest protobufNodesStatsRequest = (NodeStatsRequest) request;
             byte[] bytes = new byte[1];
             bytes[0] = 0;
@@ -223,28 +213,21 @@ void sendResponse(
             isHandshake,
             compress
         );
-        System.out.println("OutboundHandler.sendResponse");
-        System.out.println("action: " + action);
-        System.out.println("response: " + response);
-        System.out.println("canonical: " + response.getClass().getCanonicalName());
         ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onResponseSent(requestId, action, response));
         if (response.getClass().getCanonicalName().contains("ProtobufClusterState")) {
             // ExampleProtoRequest exampleProtoRequest = new ExampleProtoRequest(1, "message");
-            System.out.println("In sendReponse for protobuf");
             ProtobufClusterStateResponse protobufClusterStateResponse = (ProtobufClusterStateResponse) response;
             byte[] bytes = new byte[1];
             bytes[0] = 1;
             ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufClusterStateResponse.response(), features, action);
             sendProtobufMessage(channel, protobufMessage, listener);
         } else if (response.getClass().getCanonicalName().contains("ProtobufNodeInfo")) {
-            System.out.println("Sending response of type protobuf node info");
             ProtobufNodeInfo protobufNodeInfo = (ProtobufNodeInfo) response;
             byte[] bytes = new byte[1];
             bytes[0] = 1;
             ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufNodeInfo.response(), features, action);
             sendProtobufMessage(channel, protobufMessage, listener);
         } else if (response.getClass().getCanonicalName().contains("ProtobufNodeStats")) {
-            System.out.println("Sending response of type protobuf node stats");
             ProtobufNodeStats protobufNodeStats = (ProtobufNodeStats) response;
             byte[] bytes = new byte[1];
             bytes[0] = 1;
@@ -283,36 +266,26 @@ void sendErrorResponse(
     }
 
     private void sendMessage(TcpChannel channel, OutboundMessage networkMessage, ActionListener<Void> listener) throws IOException {
-        System.out.println("OutboundHandler.sendMessage");
-        System.out.println("OutboundHandler.sendMessage networkMessage = " + networkMessage);
         MessageSerializer serializer = new MessageSerializer(networkMessage, bigArrays);
         SendContext sendContext = new SendContext(channel, serializer, listener, serializer);
         internalSend(channel, sendContext);
     }
 
     private void sendProtobufMessage(TcpChannel channel, ProtobufOutboundMessage message, ActionListener<Void> listener) throws IOException {
-        System.out.println("OutboundHandler.sendProtobufMessage");
-        System.out.println("OutboundHandler.sendProtobufMessage networkMessage = " + message);
         TryMessageSerializer serializer = new TryMessageSerializer(message, bigArrays);
         SendContext sendContext = new SendContext(channel, serializer, listener, serializer);
         internalSend(channel, sendContext);
     }
 
     private void sendMessage1(TcpChannel channel, OutboundMessage networkMessage, ActionListener<Void> listener) throws IOException {
-        System.out.println("OutboundHandler.sendMessage");
-        System.out.println("OutboundHandler.sendMessage networkMessage = " + networkMessage);
         MessageSerializer1 serializer = new MessageSerializer1(networkMessage, bigArrays);
         SendContext sendContext = new SendContext(channel, serializer, listener, serializer);
         internalSend(channel, sendContext);
     }
 
     private void internalSend(TcpChannel channel, SendContext sendContext) throws IOException {
-        System.out.println("In internal send");
-        System.out.println("channel: " + channel);
-        System.out.println("sendContext: " + sendContext);
         channel.getChannelStats().markAccessed(threadPool.relativeTimeInMillis());
         BytesReference reference = sendContext.get();
-        System.out.println("reference: " + reference);
         // stash thread context so that channel event loop is not polluted by thread context
         try (ThreadContext.StoredContext existing = threadPool.getThreadContext().stashContext()) {
             channel.sendMessage(reference, sendContext);
@@ -349,7 +322,6 @@ private MessageSerializer(OutboundMessage message, BigArrays bigArrays) {
 
         @Override
         public BytesReference get() throws IOException {
-            System.out.println("OutboundHandler.MessageSerializer.get");
             bytesStreamOutput = new ReleasableBytesStreamOutput(bigArrays);
             return message.serialize(bytesStreamOutput);
         }
@@ -373,16 +345,8 @@ private TryMessageSerializer(ProtobufOutboundMessage message, BigArrays bigArray
 
         @Override
         public BytesReference get() throws IOException {
-            System.out.println("OutboundHandler.TryMessageSerializer.get");
             bytesStreamOutput = new ReleasableBytesStreamOutput(bigArrays);
             BytesReference reference = serialize(bytesStreamOutput); 
-            System.out.println("Bytes serialized length: " + reference.length());
-            System.out.println("Bytes serialized: " + reference);
-            System.out.println("Now the bytes: ");
-            for (int i = 0; i < reference.length(); i++) {
-                System.out.print(reference.get(i) + " ");
-            }
-            System.out.println();
             return reference;
         }
 
@@ -416,7 +380,6 @@ private MessageSerializer1(OutboundMessage message, BigArrays bigArrays) {
 
         @Override
         public BytesReference get() throws IOException {
-            System.out.println("OutboundHandler.MessageSerializer.get");
             bytesStreamOutput = new ReleasableBytesStreamOutput(bigArrays);
             return message.serialize1(bytesStreamOutput);
         }
diff --git a/server/src/main/java/org/opensearch/transport/OutboundMessage.java b/server/src/main/java/org/opensearch/transport/OutboundMessage.java
index aa09d6c46ed5f..e6b93a426559b 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundMessage.java
@@ -58,7 +58,6 @@ abstract class OutboundMessage extends NetworkMessage {
     }
 
     BytesReference serialize(BytesStreamOutput bytesStream) throws IOException {
-        System.out.println("Inside OutboundMessage.serialize");
         bytesStream.setVersion(version);
         bytesStream.skip(TcpHeader.headerSize(version));
 
@@ -82,18 +81,10 @@ BytesReference serialize(BytesStreamOutput bytesStream) throws IOException {
         bytesStream.seek(0);
         final int contentSize = reference.length() - TcpHeader.headerSize(version);
         TcpHeader.writeHeader(bytesStream, requestId, status, version, contentSize, variableHeaderLength);
-        System.out.println("Bytes serialized length: " + reference.length());
-        System.out.println("Bytes serialized: " + reference);
-        // System.out.println("Now the bytes: ");
-        // for (int i = 0; i < reference.length(); i++) {
-        //     System.out.print(reference.get(i) + " ");
-        // }
-        System.out.println();
         return reference;
     }
 
     BytesReference serialize1(BytesStreamOutput bytesStream) throws IOException {
-        System.out.println("Inside OutboundMessage.serialize");
         bytesStream.setVersion(version);
         // bytesStream.skip(TcpHeader.headerSize(version));
 
@@ -118,13 +109,6 @@ BytesReference serialize1(BytesStreamOutput bytesStream) throws IOException {
         bytesStream.seek(0);
         final int contentSize = reference.length() - TcpHeader.headerSize(version);
         TcpHeader.writeHeader(bytesStream, requestId, status, version, contentSize, variableHeaderLength);
-        System.out.println("Bytes serialized length: " + reference.length());
-        System.out.println("Bytes serialized: " + reference);
-        System.out.println("Now the bytes: ");
-        for (int i = 0; i < reference.length(); i++) {
-            System.out.print(reference.get(i) + " ");
-        }
-        System.out.println();
         return reference;
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
index 1fd59deef7586..488a26b60e5d5 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
@@ -61,23 +61,12 @@ public Request newRequest(CodedInputStream in) throws IOException {
     }
 
     public void processMessageReceived(Request request, TransportChannel channel) throws Exception {
-        System.out.println("ProtobufRequestHandlerRegistry.processMessageReceived");
-        System.out.println("request: " + request);
-        System.out.println("channel: " + channel);
         final ProtobufTask task = taskManager.registerProtobuf(channel.getChannelType(), action, request);
-        System.out.println("task: " + task);
         ThreadContext.StoredContext contextToRestore = taskManager.protobufTaskExecutionStarted(task);
 
         Releasable unregisterTask = () -> taskManager.unregisterProtobufTask(task);
         try {
             if (channel instanceof TcpTransportChannel && task instanceof ProtobufCancellableTask) {
-                // if (request instanceof ShardSearchRequest) {
-                // // on receiving request, update the inbound network time to reflect time spent in transit over the network
-                // ((ShardSearchRequest) request).setInboundNetworkTime(
-                // Math.max(0, System.currentTimeMillis() - ((ShardSearchRequest) request).getInboundNetworkTime())
-                // );
-                // }
-                System.out.println("Inside if for processMessageReceived");
                 final TcpChannel tcpChannel = ((TcpTransportChannel) channel).getChannel();
                 final Releasable stopTracking = taskManager.startProtobufTrackingCancellableChannelTask(
                     tcpChannel,
@@ -85,7 +74,6 @@ public void processMessageReceived(Request request, TransportChannel channel) th
                 );
                 unregisterTask = Releasables.wrap(unregisterTask, stopTracking);
             }
-            System.out.println("Before calling handler.messageReceived");
             final TaskTransportChannel taskTransportChannel = new TaskTransportChannel(channel, unregisterTask);
             handler.messageReceived(request, taskTransportChannel, task);
             unregisterTask = null;
diff --git a/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java b/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java
index 50abf21f542e8..43e820c209d47 100644
--- a/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java
+++ b/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java
@@ -164,7 +164,6 @@ public void closeNoBlock() {
     }
 
     private synchronized void addConnectedNode(DiscoveryNode addedNode) {
-        // System.out.println("RemoteConnectionManager.addConnectedNode");
         ArrayList<DiscoveryNode> newConnections = new ArrayList<>(this.connectedNodes);
         newConnections.add(addedNode);
         this.connectedNodes = Collections.unmodifiableList(newConnections);
diff --git a/server/src/main/java/org/opensearch/transport/TcpTransport.java b/server/src/main/java/org/opensearch/transport/TcpTransport.java
index fffc3e359e11c..97ddede0105ae 100644
--- a/server/src/main/java/org/opensearch/transport/TcpTransport.java
+++ b/server/src/main/java/org/opensearch/transport/TcpTransport.java
@@ -318,21 +318,13 @@ public DiscoveryNode getNode() {
         @Override
         public void sendRequest(long requestId, String action, TransportRequest request, TransportRequestOptions options)
             throws IOException, TransportException {
-            System.out.println("Sending request from NodeChannels");
             if (isClosing.get()) {
                 throw new NodeNotConnectedException(node, "connection already closed");
             }
             TcpChannel channel = channel(options.type());
             outboundHandler.sendRequest(node, channel, requestId, action, request, options, getVersion(), compress, false);
-            System.out.println("Done with send request");
         }
 
-        // @Override
-        // public void sendRequestProtobuf(long requestId, String action, TransportRequest request,
-        //         TransportRequestOptions options) throws IOException, TransportException {
-        //     // TODO Auto-generated method stub
-        //     throw new UnsupportedOperationException("Unimplemented method 'sendRequestProtobuf'");
-        // }
     }
 
     // This allows transport implementations to potentially override specific connection profiles. This
@@ -865,9 +857,6 @@ public static int readMessageLength(BytesReference networkBytes) throws IOExcept
 
     private static int readHeaderBuffer(BytesReference headerBuffer) throws IOException {
         if (headerBuffer.get(0) != 'E' || headerBuffer.get(1) != 'S') {
-            System.out.println("headerBuffer: " + headerBuffer);
-            System.out.println("headerBuffer.get(0): " + headerBuffer.get(0));
-            System.out.println("headerBuffer.get(1): " + headerBuffer.get(1));
             if (appearsToBeHTTPRequest(headerBuffer)) {
                 throw new HttpRequestOnTransportException("This is not an HTTP port");
             }
diff --git a/server/src/main/java/org/opensearch/transport/TransportService.java b/server/src/main/java/org/opensearch/transport/TransportService.java
index 3a6679462932d..140e5924e23f4 100644
--- a/server/src/main/java/org/opensearch/transport/TransportService.java
+++ b/server/src/main/java/org/opensearch/transport/TransportService.java
@@ -517,7 +517,6 @@ public void connectToExtensionNode(DiscoveryNode node, ActionListener<Void> list
      * @param listener the action listener to notify
      */
     public void connectToNode(final DiscoveryNode node, ConnectionProfile connectionProfile, ActionListener<Void> listener) {
-        // System.out.println("TransportService.connectToNode");
         if (isLocalNode(node)) {
             listener.onResponse(null);
             return;
@@ -883,10 +882,6 @@ public final <T extends TransportResponse> void sendRequest(
         final TransportRequestOptions options,
         TransportResponseHandler<T> handler
     ) {
-        // System.out.println("sendRequest");
-        // System.out.println("node: " + node);
-        // System.out.println("action: " + action);
-        // System.out.println("request: " + request);
         final Transport.Connection connection;
         try {
             connection = getConnection(node);
@@ -916,7 +911,6 @@ public final <T extends TransportResponse> void sendRequest(
         final TransportResponseHandler<T> handler
     ) {
         try {
-            // System.out.println("sendRequest2");
             logger.debug("Action: " + action);
             final TransportResponseHandler<T> delegate;
             if (request.getParentTask().isSet()) {
@@ -986,13 +980,9 @@ public T read(byte[] in) throws IOException {
      * @throws NodeNotConnectedException if the given node is not connected
      */
     public Transport.Connection getConnection(DiscoveryNode node) {
-        // System.out.println("transport service");
-        // System.out.println("Getting connection for node " + node);
         if (isLocalNode(node)) {
-            // System.out.println("Is local node");
             return localNodeConnection;
         } else {
-            // System.out.println("Not local node");
             return connectionManager.getConnection(node);
         }
     }
@@ -1045,7 +1035,6 @@ private <T extends TransportResponse> void sendRequestInternal(
         final TransportRequestOptions options,
         TransportResponseHandler<T> handler
     ) {
-        System.out.println("Sending internal request from transport service");
         if (connection == null) {
             throw new IllegalStateException("can't send request to a null connection");
         }
@@ -1074,7 +1063,6 @@ private <T extends TransportResponse> void sendRequestInternal(
                 assert options.timeout() != null;
                 timeoutHandler.scheduleTimeout(options.timeout());
             }
-            System.out.println("Before sending request to TcpTransport NodeChannels");
             connection.sendRequest(requestId, action, request, options); // local node optimization happens upstream
         } catch (final Exception e) {
             // usually happen either because we failed to connect to the node
@@ -1126,22 +1114,12 @@ protected void doRun() throws Exception {
     }
 
     private void sendLocalRequest(long requestId, final String action, final TransportRequest request, TransportRequestOptions options) {
-        // System.out.println("Sending local request");
-        // System.out.println("Request id: " + requestId);
-        // System.out.println("Action: " + action);
-        // System.out.println("Request: " + request);
         final DirectResponseChannel channel = new DirectResponseChannel(localNode, action, requestId, this, threadPool);
         try {
             onRequestSent(localNode, requestId, action, request, options);
             onRequestReceived(requestId, action);
-            // System.out.println("Req canonical: " + request.getClass().getCanonicalName());
             final RequestHandlerRegistry reg = getRequestHandler(action);
             final ProtobufRequestHandlerRegistry protobufRequestHandlerRegistry = getRequestHandlerProtobuf(action);
-            // if (request.getClass().getCanonicalName().contains("Protobuf")) {
-            //     protobufRequestHandlerRegistry = getRequestHandlerProtobuf(action);
-            // }   
-            // System.out.println("Request handler: " + reg);
-            // System.out.println("Protobuf request handler: " + protobufRequestHandlerRegistry);
             if (reg == null) {
                 throw new ActionNotFoundTransportException("Action [" + action + "] not found");
             }

From f94f16546154103832f64f677e3de3e22e5a9936 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Mon, 31 Jul 2023 07:16:31 +0000
Subject: [PATCH 22/37] Cleaning up code

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../java/org/opensearch/core/index/Index.java |  20 +-
 .../opensearch/core/index/shard/ShardId.java  |  18 +-
 .../breaker/CircuitBreakerService.java        |  10 -
 .../breaker/NoneCircuitBreakerService.java    |  10 -
 .../ProtobufOpenSearchException.java          | 935 ------------------
 .../action/ActionListenerResponseHandler.java |  15 -
 ...ProtobufActionListenerResponseHandler.java |  15 +-
 .../action/ProtobufActionRequest.java         |   7 +-
 .../action/ProtobufActionResponse.java        |   2 +-
 .../opensearch/action/ProtobufActionType.java |  13 +-
 .../action/ProtobufFailedNodeException.java   |  46 -
 .../cluster/node/info/ProtobufNodeInfo.java   | 146 +--
 .../node/info/ProtobufNodesInfoRequest.java   |  72 +-
 .../info/ProtobufNodesInfoRequestBuilder.java |  65 --
 .../node/info/ProtobufNodesInfoResponse.java  |  80 +-
 .../node/info/ProtobufPluginsAndModules.java  |  95 --
 .../ProtobufTransportNodesInfoAction.java     |  21 +-
 .../cluster/node/stats/ProtobufNodeStats.java | 277 +-----
 .../node/stats/ProtobufNodesStatsRequest.java |  19 -
 .../ProtobufNodesStatsRequestBuilder.java     |  82 --
 .../stats/ProtobufNodesStatsResponse.java     |  34 +-
 .../ProtobufTransportNodesStatsAction.java    |  21 +-
 .../state/ProtobufClusterStateRequest.java    |   9 -
 .../state/ProtobufClusterStateResponse.java   |  59 +-
 .../ProtobufTransportClusterStateAction.java  |   5 -
 .../datastream/GetDataStreamAction.java       |   7 +-
 .../admin/indices/rollover/RolloverInfo.java  |   7 +-
 .../admin/indices/stats/CommonStatsFlags.java |  50 +-
 .../indices/stats/ProtobufCommonStats.java    | 526 ----------
 .../stats/ProtobufCommonStatsFlags.java       | 276 ------
 .../stats/ProtobufIndexShardStats.java        |  98 --
 .../indices/stats/ProtobufShardStats.java     | 178 ----
 ...TransportFieldCapabilitiesIndexAction.java |  13 -
 .../action/main/ProtobufMainRequest.java      |   3 +-
 .../action/main/ProtobufMainResponse.java     |  16 +-
 .../TransportResyncReplicationAction.java     |  13 -
 .../opensearch/action/search/PitService.java  |  13 -
 .../action/support/IndicesOptions.java        |  16 -
 .../broadcast/TransportBroadcastAction.java   |  13 -
 .../node/TransportBroadcastByNodeAction.java  |  14 -
 ...ProtobufClusterManagerNodeReadRequest.java |  14 +-
 .../ProtobufClusterManagerNodeRequest.java    |  19 -
 ...obufTransportClusterManagerNodeAction.java |  16 +-
 .../support/nodes/BaseNodeResponse.java       |  13 -
 .../nodes/ProtobufBaseNodeResponse.java       |  13 -
 .../nodes/ProtobufBaseNodesRequest.java       |  20 -
 .../nodes/ProtobufBaseNodesResponse.java      |  39 +-
 .../ProtobufNodesOperationRequestBuilder.java |  49 -
 .../nodes/ProtobufTransportNodesAction.java   |  27 +-
 .../support/nodes/TransportNodesAction.java   |  13 -
 .../TransportReplicationAction.java           |  13 -
 ...ransportInstanceSingleOperationAction.java |  13 -
 .../shard/TransportSingleShardAction.java     |  25 -
 .../support/tasks/TransportTasksAction.java   |  14 -
 .../org/opensearch/client/ProtobufClient.java |  16 -
 .../client/ProtobufClusterAdminClient.java    |  12 -
 .../client/ProtobufFilterClient.java          |  74 --
 .../client/node/ProtobufNodeClient.java       |   5 -
 .../support/ProtobufAbstractClient.java       |  32 -
 .../opensearch/cluster/AbstractDiffable.java  |  63 +-
 .../org/opensearch/cluster/ClusterName.java   |   8 +-
 .../org/opensearch/cluster/ClusterState.java  | 157 +--
 .../cluster/ProtobufAbstractDiffable.java     |  90 --
 .../cluster/ProtobufDiffableUtils.java        | 812 ---------------
 .../opensearch/cluster/ProtobufNamedDiff.java |  32 -
 .../cluster/ProtobufNamedDiffable.java        |  24 -
 .../ProtobufNamedDiffableValueSerializer.java |  59 --
 .../cluster/block/ClusterBlocks.java          |   7 +-
 .../cluster/coordination/Coordinator.java     |   6 -
 .../coordination/FollowersChecker.java        |  13 -
 .../cluster/coordination/JoinHelper.java      |  25 -
 .../cluster/coordination/LeaderChecker.java   |  13 -
 .../coordination/PreVoteCollector.java        |  13 -
 .../ProtobufPendingClusterStateStats.java     |  87 --
 .../ProtobufPublishClusterStateStats.java     |  92 --
 .../PublicationTransportHandler.java          |  33 -
 .../decommission/DecommissionController.java  |  13 -
 .../cluster/metadata/AliasMetadata.java       |   7 +-
 .../cluster/metadata/ComponentTemplate.java   |   7 +-
 .../metadata/ComposableIndexTemplate.java     |   7 +-
 .../cluster/metadata/DataStream.java          |   7 +-
 .../metadata/IndexTemplateMetadata.java       |   8 +-
 .../cluster/metadata/MappingMetadata.java     |   9 +-
 .../opensearch/cluster/metadata/Template.java |   7 +-
 .../cluster/node/DiscoveryNode.java           |  73 +-
 .../cluster/node/DiscoveryNodes.java          |  49 +-
 .../cluster/routing/AllocationId.java         |  17 +-
 .../cluster/routing/IndexRoutingTable.java    |  22 +-
 .../routing/IndexShardRoutingTable.java       |  16 -
 .../cluster/routing/RoutingTable.java         |  12 -
 .../cluster/routing/ShardRouting.java         |  57 +-
 .../cluster/routing/UnassignedInfo.java       |  39 +-
 .../common/ProtobufFieldMemoryStats.java      | 124 ---
 ...otobufNotSerializableExceptionWrapper.java |  74 --
 .../common/io/stream/ProtobufStreamInput.java | 436 --------
 .../io/stream/ProtobufStreamOutput.java       | 358 -------
 .../common/io/stream/ProtobufWriteable.java   |  23 +-
 .../transport/BoundTransportAddress.java      |  21 +-
 .../ProtobufBoundTransportAddress.java        |  92 --
 .../common/transport/TransportAddress.java    |  32 +-
 .../common/unit/ProtobufSizeValue.java        | 144 ---
 .../common/util/concurrent/ThreadContext.java |  65 +-
 .../org/opensearch/discovery/Discovery.java   |   5 -
 .../org/opensearch/discovery/PeerFinder.java  |  13 -
 .../discovery/ProtobufDiscoveryStats.java     |  99 --
 .../example/proto/ExampleProtoRequest.java    |   7 -
 .../extensions/ExtensionsManager.java         |  13 -
 .../UpdateSettingsResponseHandler.java        |  13 -
 .../ExtensionTransportActionsHandler.java     |  25 -
 .../rest/RestSendToExtensionAction.java       |  13 -
 .../http/AbstractHttpServerTransport.java     |  26 -
 .../opensearch/http/HttpServerTransport.java  |   8 +-
 .../org/opensearch/http/ProtobufHttpInfo.java | 105 --
 .../opensearch/http/ProtobufHttpStats.java    |  67 --
 .../cache/query/ProtobufQueryCacheStats.java  | 151 ---
 .../request/ProtobufRequestCacheStats.java    | 107 --
 .../cache/request/ShardRequestCache.java      |   4 -
 .../opensearch/index/engine/CommitStats.java  |  38 +-
 .../org/opensearch/index/engine/Engine.java   |  77 --
 .../index/engine/ProtobufSegmentsStats.java   | 285 ------
 .../fielddata/ProtobufFieldDataStats.java     | 120 ---
 .../index/fielddata/ShardFieldData.java       |  18 -
 .../index/flush/ProtobufFlushStats.java       | 123 ---
 .../index/get/ProtobufGetStats.java           | 151 ---
 .../opensearch/index/get/ShardGetService.java |  10 -
 .../index/merge/ProtobufMergeStats.java       | 262 -----
 .../index/recovery/ProtobufRecoveryStats.java | 137 ---
 .../index/refresh/ProtobufRefreshStats.java   | 161 ---
 .../search/stats/ProtobufSearchStats.java     | 444 ---------
 .../index/search/stats/ShardSearchStats.java  |  45 -
 .../index/seqno/RetentionLease.java           |  32 +-
 .../RetentionLeaseBackgroundSyncAction.java   |  13 -
 .../index/seqno/RetentionLeaseStats.java      |  26 +-
 .../index/seqno/RetentionLeaseSyncAction.java |  13 -
 .../index/seqno/RetentionLeases.java          |  35 +-
 .../opensearch/index/seqno/SeqNoStats.java    |  17 +-
 .../opensearch/index/shard/IndexShard.java    |  93 --
 .../index/shard/InternalIndexingStats.java    |  25 -
 .../index/shard/ProtobufDocsStats.java        | 110 ---
 .../index/shard/ProtobufIndexingStats.java    | 286 ------
 .../index/store/ProtobufStoreStats.java       | 118 ---
 .../org/opensearch/index/store/Store.java     |   8 -
 .../index/translog/ProtobufTranslogStats.java | 137 ---
 .../index/warmer/ProtobufWarmerStats.java     | 118 ---
 .../index/warmer/ShardIndexWarmerService.java |   3 -
 .../opensearch/indices/IndicesQueryCache.java |  34 -
 .../opensearch/indices/IndicesService.java    | 141 ---
 .../indices/ProtobufNodeIndicesStats.java     | 182 ----
 .../HierarchyCircuitBreakerService.java       |  33 -
 .../ProtobufAllCircuitBreakerStats.java       |  78 --
 .../breaker/ProtobufCircuitBreakerStats.java  | 124 ---
 .../recovery/PeerRecoveryTargetService.java   |  13 -
 .../checkpoint/PublishCheckpointAction.java   |  13 -
 .../indices/store/IndicesStore.java           |  13 -
 .../org/opensearch/ingest/IngestService.java  |  30 +-
 .../ingest/PipelineConfiguration.java         |   7 +-
 .../opensearch/ingest/ProtobufIngestInfo.java |  73 --
 .../ingest/ProtobufIngestStats.java           | 351 -------
 .../ingest/ProtobufProcessorInfo.java         |  59 --
 .../monitor/ProtobufMonitorService.java       |  77 --
 .../org/opensearch/monitor/fs/FsProbe.java    |  95 --
 .../opensearch/monitor/fs/ProtobufFsInfo.java | 554 -----------
 .../monitor/fs/ProtobufFsService.java         |  94 --
 .../org/opensearch/monitor/jvm/JvmInfo.java   |  82 +-
 .../monitor/jvm/ProtobufJvmInfo.java          | 684 -------------
 .../monitor/jvm/ProtobufJvmService.java       |  61 --
 .../monitor/jvm/ProtobufJvmStats.java         | 755 --------------
 .../org/opensearch/monitor/os/OsProbe.java    | 109 --
 .../opensearch/monitor/os/ProtobufOsInfo.java | 140 ---
 .../monitor/os/ProtobufOsService.java         |  70 --
 .../monitor/os/ProtobufOsStats.java           | 610 ------------
 .../monitor/process/ProcessProbe.java         |  10 -
 .../monitor/process/ProtobufProcessInfo.java  |  86 --
 .../process/ProtobufProcessService.java       |  67 --
 .../monitor/process/ProtobufProcessStats.java | 193 ----
 .../main/java/org/opensearch/node/Node.java   |   9 +-
 .../node/ProtobufAdaptiveSelectionStats.java  | 121 ---
 .../node/ProtobufNodeClosedException.java     |  31 -
 .../opensearch/node/ProtobufNodeService.java  |  44 +-
 .../node/ResponseCollectorService.java        | 117 ---
 .../plugins/ProtobufPluginInfo.java           | 372 -------
 .../action/cat/ProtobufRestNodesAction.java   |  54 +-
 .../script/ProtobufScriptCacheStats.java      | 152 ---
 .../script/ProtobufScriptContextStats.java    |  91 --
 .../script/ProtobufScriptStats.java           | 127 ---
 .../org/opensearch/script/ScriptCache.java    |   8 -
 .../org/opensearch/script/ScriptMetrics.java  |  13 -
 .../org/opensearch/script/ScriptService.java  |  16 -
 .../opensearch/script/StoredScriptSource.java |  12 +-
 .../support/AggregationUsageService.java      |   8 +-
 .../support/ProtobufAggregationInfo.java      |  89 --
 .../pipeline/PipelineConfiguration.java       |   7 +-
 .../pipeline/ProtobufSearchPipelineInfo.java  |  70 --
 .../pipeline/SearchPipelineService.java       |  13 +-
 .../completion/ProtobufCompletionStats.java   |  96 --
 .../snapshots/SnapshotShardsService.java      |  13 -
 .../ProtobufTaskCancellationService.java      |  25 +-
 .../org/opensearch/tasks/ProtobufTaskId.java  |  17 +-
 .../opensearch/tasks/ProtobufTaskInfo.java    |  67 +-
 .../tasks/ProtobufTaskResourceStats.java      |  12 +-
 .../opensearch/tasks/ProtobufTaskResult.java  |  29 +-
 .../threadpool/ProtobufThreadPoolInfo.java    |  66 --
 .../threadpool/ProtobufThreadPoolStats.java   | 191 ----
 .../org/opensearch/threadpool/ThreadPool.java |  82 +-
 .../transport/BytesTransportRequest.java      |  11 -
 .../EmptyTransportResponseHandler.java        |  12 -
 .../java/org/opensearch/transport/Header.java |  20 -
 .../opensearch/transport/InboundDecoder.java  |  22 -
 .../opensearch/transport/InboundHandler.java  | 160 +--
 .../opensearch/transport/InboundMessage.java  |  16 +-
 .../transport/PlainTransportFuture.java       |  15 +-
 .../ProtobufActionTransportException.java     |  88 --
 .../ProtobufBytesTransportRequest.java        |  66 --
 .../ProtobufConnectTransportException.java    |  61 --
 ...ProtobufEmptyTransportResponseHandler.java |  10 -
 .../transport/ProtobufNetworkMessage.java     |  62 --
 .../ProtobufNodeDisconnectedException.java    |  37 -
 .../ProtobufNodeNotConnectedException.java    |  30 -
 .../ProtobufPlainTransportFuture.java         | 121 ---
 .../ProtobufProxyConnectionStrategy.java      | 415 --------
 ...tobufReceiveTimeoutTransportException.java |  31 -
 .../ProtobufRemoteClusterAwareClient.java     |  73 --
 .../ProtobufRemoteClusterConnection.java      | 247 -----
 .../ProtobufRemoteClusterService.java         | 454 ---------
 .../ProtobufRemoteConnectionInfo.java         | 132 ---
 .../ProtobufRemoteConnectionStrategy.java     | 484 ---------
 .../ProtobufRemoteTransportException.java     |  42 -
 .../ProtobufRequestHandlerRegistry.java       |   2 +-
 ...ProtobufSendRequestTransportException.java |  31 -
 .../ProtobufSniffConnectionStrategy.java      | 646 ------------
 .../ProtobufTransportActionProxy.java         | 246 -----
 .../transport/ProtobufTransportException.java |  37 -
 .../transport/ProtobufTransportInfo.java      | 159 ---
 .../transport/ProtobufTransportStats.java     | 126 ---
 .../transport/RemoteClusterConnection.java    |  12 -
 .../transport/RemoteClusterService.java       |  64 +-
 .../transport/SniffConnectionStrategy.java    |  12 -
 .../opensearch/transport/TcpTransport.java    |  29 -
 .../org/opensearch/transport/Transport.java   |  33 -
 .../transport/TransportActionProxy.java       |  12 -
 .../transport/TransportHandshaker.java        |  12 -
 .../transport/TransportMessage.java           |   2 +-
 .../transport/TransportRequest.java           |   9 +-
 .../transport/TransportResponse.java          |   7 +-
 .../transport/TransportResponseHandler.java   |  29 +-
 .../transport/TransportService.java           |  67 +-
 .../org/opensearch/test/NoopDiscovery.java    |   6 -
 .../opensearch/test/MockHttpTransport.java    |  24 +-
 .../test/transport/FakeTransport.java         |  49 -
 .../test/transport/StubbableTransport.java    |  49 -
 .../test/disruption/NetworkDisruptionIT.java  |   7 -
 251 files changed, 303 insertions(+), 21326 deletions(-)
 delete mode 100644 server/src/main/java/org/opensearch/ProtobufOpenSearchException.java
 delete mode 100644 server/src/main/java/org/opensearch/action/ProtobufFailedNodeException.java
 delete mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequestBuilder.java
 delete mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufPluginsAndModules.java
 delete mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequestBuilder.java
 delete mode 100644 server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStats.java
 delete mode 100644 server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStatsFlags.java
 delete mode 100644 server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufIndexShardStats.java
 delete mode 100644 server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufShardStats.java
 delete mode 100644 server/src/main/java/org/opensearch/action/support/nodes/ProtobufNodesOperationRequestBuilder.java
 delete mode 100644 server/src/main/java/org/opensearch/client/ProtobufFilterClient.java
 delete mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufAbstractDiffable.java
 delete mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufDiffableUtils.java
 delete mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufNamedDiff.java
 delete mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffable.java
 delete mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffableValueSerializer.java
 delete mode 100644 server/src/main/java/org/opensearch/cluster/coordination/ProtobufPendingClusterStateStats.java
 delete mode 100644 server/src/main/java/org/opensearch/cluster/coordination/ProtobufPublishClusterStateStats.java
 delete mode 100644 server/src/main/java/org/opensearch/common/ProtobufFieldMemoryStats.java
 delete mode 100644 server/src/main/java/org/opensearch/common/io/stream/ProtobufNotSerializableExceptionWrapper.java
 delete mode 100644 server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java
 delete mode 100644 server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java
 delete mode 100644 server/src/main/java/org/opensearch/common/transport/ProtobufBoundTransportAddress.java
 delete mode 100644 server/src/main/java/org/opensearch/common/unit/ProtobufSizeValue.java
 delete mode 100644 server/src/main/java/org/opensearch/discovery/ProtobufDiscoveryStats.java
 delete mode 100644 server/src/main/java/org/opensearch/http/ProtobufHttpInfo.java
 delete mode 100644 server/src/main/java/org/opensearch/http/ProtobufHttpStats.java
 delete mode 100644 server/src/main/java/org/opensearch/index/cache/query/ProtobufQueryCacheStats.java
 delete mode 100644 server/src/main/java/org/opensearch/index/cache/request/ProtobufRequestCacheStats.java
 delete mode 100644 server/src/main/java/org/opensearch/index/engine/ProtobufSegmentsStats.java
 delete mode 100644 server/src/main/java/org/opensearch/index/fielddata/ProtobufFieldDataStats.java
 delete mode 100644 server/src/main/java/org/opensearch/index/flush/ProtobufFlushStats.java
 delete mode 100644 server/src/main/java/org/opensearch/index/get/ProtobufGetStats.java
 delete mode 100644 server/src/main/java/org/opensearch/index/merge/ProtobufMergeStats.java
 delete mode 100644 server/src/main/java/org/opensearch/index/recovery/ProtobufRecoveryStats.java
 delete mode 100644 server/src/main/java/org/opensearch/index/refresh/ProtobufRefreshStats.java
 delete mode 100644 server/src/main/java/org/opensearch/index/search/stats/ProtobufSearchStats.java
 delete mode 100644 server/src/main/java/org/opensearch/index/shard/ProtobufDocsStats.java
 delete mode 100644 server/src/main/java/org/opensearch/index/shard/ProtobufIndexingStats.java
 delete mode 100644 server/src/main/java/org/opensearch/index/store/ProtobufStoreStats.java
 delete mode 100644 server/src/main/java/org/opensearch/index/translog/ProtobufTranslogStats.java
 delete mode 100644 server/src/main/java/org/opensearch/index/warmer/ProtobufWarmerStats.java
 delete mode 100644 server/src/main/java/org/opensearch/indices/ProtobufNodeIndicesStats.java
 delete mode 100644 server/src/main/java/org/opensearch/indices/breaker/ProtobufAllCircuitBreakerStats.java
 delete mode 100644 server/src/main/java/org/opensearch/indices/breaker/ProtobufCircuitBreakerStats.java
 delete mode 100644 server/src/main/java/org/opensearch/ingest/ProtobufIngestInfo.java
 delete mode 100644 server/src/main/java/org/opensearch/ingest/ProtobufIngestStats.java
 delete mode 100644 server/src/main/java/org/opensearch/ingest/ProtobufProcessorInfo.java
 delete mode 100644 server/src/main/java/org/opensearch/monitor/ProtobufMonitorService.java
 delete mode 100644 server/src/main/java/org/opensearch/monitor/fs/ProtobufFsInfo.java
 delete mode 100644 server/src/main/java/org/opensearch/monitor/fs/ProtobufFsService.java
 delete mode 100644 server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java
 delete mode 100644 server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmService.java
 delete mode 100644 server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmStats.java
 delete mode 100644 server/src/main/java/org/opensearch/monitor/os/ProtobufOsInfo.java
 delete mode 100644 server/src/main/java/org/opensearch/monitor/os/ProtobufOsService.java
 delete mode 100644 server/src/main/java/org/opensearch/monitor/os/ProtobufOsStats.java
 delete mode 100644 server/src/main/java/org/opensearch/monitor/process/ProtobufProcessInfo.java
 delete mode 100644 server/src/main/java/org/opensearch/monitor/process/ProtobufProcessService.java
 delete mode 100644 server/src/main/java/org/opensearch/monitor/process/ProtobufProcessStats.java
 delete mode 100644 server/src/main/java/org/opensearch/node/ProtobufAdaptiveSelectionStats.java
 delete mode 100644 server/src/main/java/org/opensearch/node/ProtobufNodeClosedException.java
 delete mode 100644 server/src/main/java/org/opensearch/plugins/ProtobufPluginInfo.java
 delete mode 100644 server/src/main/java/org/opensearch/script/ProtobufScriptCacheStats.java
 delete mode 100644 server/src/main/java/org/opensearch/script/ProtobufScriptContextStats.java
 delete mode 100644 server/src/main/java/org/opensearch/script/ProtobufScriptStats.java
 delete mode 100644 server/src/main/java/org/opensearch/search/aggregations/support/ProtobufAggregationInfo.java
 delete mode 100644 server/src/main/java/org/opensearch/search/pipeline/ProtobufSearchPipelineInfo.java
 delete mode 100644 server/src/main/java/org/opensearch/search/suggest/completion/ProtobufCompletionStats.java
 delete mode 100644 server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java
 delete mode 100644 server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolStats.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufActionTransportException.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufBytesTransportRequest.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufConnectTransportException.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufNetworkMessage.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufNodeDisconnectedException.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufNodeNotConnectedException.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufPlainTransportFuture.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufProxyConnectionStrategy.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufReceiveTimeoutTransportException.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionInfo.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufRemoteTransportException.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufSendRequestTransportException.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportException.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportInfo.java
 delete mode 100644 server/src/main/java/org/opensearch/transport/ProtobufTransportStats.java

diff --git a/libs/core/src/main/java/org/opensearch/core/index/Index.java b/libs/core/src/main/java/org/opensearch/core/index/Index.java
index 7bff2f7d0dc3b..fc5c5152a5500 100644
--- a/libs/core/src/main/java/org/opensearch/core/index/Index.java
+++ b/libs/core/src/main/java/org/opensearch/core/index/Index.java
@@ -33,7 +33,6 @@
 package org.opensearch.core.index;
 
 import org.opensearch.core.ParseField;
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
@@ -43,9 +42,6 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.util.Objects;
 
@@ -54,7 +50,7 @@
  *
  * @opensearch.internal
  */
-public class Index implements Writeable, ToXContentObject, ProtobufWriteable {
+public class Index implements Writeable, ToXContentObject {
 
     public static final Index[] EMPTY_ARRAY = new Index[0];
     private static final String INDEX_UUID_KEY = "index_uuid";
@@ -81,14 +77,6 @@ public Index(StreamInput in) throws IOException {
         this.uuid = in.readString();
     }
 
-    /**
-     * Read from a stream.
-     */
-    public Index(CodedInputStream in) throws IOException {
-        this.name = in.readString();
-        this.uuid = in.readString();
-    }
-
     public String getName() {
         return this.name;
     }
@@ -134,12 +122,6 @@ public void writeTo(final StreamOutput out) throws IOException {
         out.writeString(uuid);
     }
 
-    @Override
-    public void writeTo(final CodedOutputStream out) throws IOException {
-        out.writeStringNoTag(name);
-        out.writeStringNoTag(uuid);
-    }
-
     @Override
     public XContentBuilder toXContent(final XContentBuilder builder, final Params params) throws IOException {
         builder.startObject();
diff --git a/libs/core/src/main/java/org/opensearch/core/index/shard/ShardId.java b/libs/core/src/main/java/org/opensearch/core/index/shard/ShardId.java
index e978978f2920c..b01121c3f30d4 100644
--- a/libs/core/src/main/java/org/opensearch/core/index/shard/ShardId.java
+++ b/libs/core/src/main/java/org/opensearch/core/index/shard/ShardId.java
@@ -33,7 +33,6 @@
 package org.opensearch.core.index.shard;
 
 import org.opensearch.core.common.Strings;
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
@@ -41,9 +40,6 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.index.Index;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 
 /**
@@ -51,7 +47,7 @@
  *
  * @opensearch.internal
  */
-public class ShardId implements Comparable<ShardId>, ToXContentFragment, Writeable, ProtobufWriteable {
+public class ShardId implements Comparable<ShardId>, ToXContentFragment, Writeable {
 
     private final Index index;
     private final int shardId;
@@ -73,24 +69,12 @@ public ShardId(StreamInput in) throws IOException {
         hashCode = computeHashCode();
     }
 
-    public ShardId(CodedInputStream in) throws IOException {
-        index = new Index(in);
-        shardId = in.readInt32();
-        hashCode = computeHashCode();
-    }
-
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         index.writeTo(out);
         out.writeVInt(shardId);
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        index.writeTo(out);
-        out.writeInt32NoTag(shardId);
-    }
-
     public Index getIndex() {
         return index;
     }
diff --git a/libs/core/src/main/java/org/opensearch/core/indices/breaker/CircuitBreakerService.java b/libs/core/src/main/java/org/opensearch/core/indices/breaker/CircuitBreakerService.java
index 6069a1a20a23a..ee9c94f432a36 100644
--- a/libs/core/src/main/java/org/opensearch/core/indices/breaker/CircuitBreakerService.java
+++ b/libs/core/src/main/java/org/opensearch/core/indices/breaker/CircuitBreakerService.java
@@ -63,16 +63,6 @@ protected CircuitBreakerService() {}
      */
     public abstract CircuitBreakerStats stats(String name);
 
-    /**
-     * @return stats about all breakers
-     */
-    public abstract ProtobufAllCircuitBreakerStats protobufStats();
-
-    /**
-     * @return stats about a specific breaker
-     */
-    public abstract ProtobufCircuitBreakerStats protobufStats(String name);
-
     @Override
     protected void doStart() {}
 
diff --git a/libs/core/src/main/java/org/opensearch/core/indices/breaker/NoneCircuitBreakerService.java b/libs/core/src/main/java/org/opensearch/core/indices/breaker/NoneCircuitBreakerService.java
index 626c4ad5d0100..4095fd32b6d3c 100644
--- a/libs/core/src/main/java/org/opensearch/core/indices/breaker/NoneCircuitBreakerService.java
+++ b/libs/core/src/main/java/org/opensearch/core/indices/breaker/NoneCircuitBreakerService.java
@@ -63,14 +63,4 @@ public CircuitBreakerStats stats(String name) {
         return new CircuitBreakerStats(CircuitBreaker.FIELDDATA, -1, -1, 0, 0);
     }
 
-    @Override
-    public ProtobufAllCircuitBreakerStats protobufStats() {
-        return new ProtobufAllCircuitBreakerStats(new ProtobufCircuitBreakerStats[] { protobufStats(CircuitBreaker.FIELDDATA) });
-    }
-
-    @Override
-    public ProtobufCircuitBreakerStats protobufStats(String name) {
-        return new ProtobufCircuitBreakerStats(CircuitBreaker.FIELDDATA, -1, -1, 0, 0);
-    }
-
 }
diff --git a/server/src/main/java/org/opensearch/ProtobufOpenSearchException.java b/server/src/main/java/org/opensearch/ProtobufOpenSearchException.java
deleted file mode 100644
index 572ae2efc6d47..0000000000000
--- a/server/src/main/java/org/opensearch/ProtobufOpenSearchException.java
+++ /dev/null
@@ -1,935 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.CheckedFunction;
-import org.opensearch.common.Nullable;
-import org.opensearch.core.ParseField;
-import org.opensearch.common.collect.Tuple;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.logging.LoggerMessageFormat;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.core.xcontent.XContentParseException;
-import org.opensearch.core.xcontent.XContentParser;
-import org.opensearch.index.Index;
-import org.opensearch.index.shard.ShardId;
-import org.opensearch.rest.RestStatus;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
-
-import static java.util.Collections.emptyMap;
-import static java.util.Collections.singletonMap;
-import static java.util.Collections.unmodifiableMap;
-import static org.opensearch.cluster.metadata.IndexMetadata.INDEX_UUID_NA_VALUE;
-import static org.opensearch.common.xcontent.XContentParserUtils.ensureExpectedToken;
-import static org.opensearch.common.xcontent.XContentParserUtils.ensureFieldName;
-
-/**
- * A base class for all opensearch exceptions.
-*
-* @opensearch.internal
-*/
-public class ProtobufOpenSearchException extends RuntimeException implements ToXContentFragment, ProtobufWriteable {
-
-    private static final Version UNKNOWN_VERSION_ADDED = Version.fromId(0);
-
-    /**
-     * Setting a higher base exception id to avoid conflicts.
-    */
-    private static final int CUSTOM_ELASTICSEARCH_EXCEPTIONS_BASE_ID = 10000;
-
-    /**
-     * Passed in the {@link Params} of {@link #generateThrowableXContent(XContentBuilder, Params, Throwable)}
-    * to control if the {@code caused_by} element should render. Unlike most parameters to {@code toXContent} methods this parameter is
-    * internal only and not available as a URL parameter.
-    */
-    private static final String REST_EXCEPTION_SKIP_CAUSE = "rest.exception.cause.skip";
-    /**
-     * Passed in the {@link Params} of {@link #generateThrowableXContent(XContentBuilder, Params, Throwable)}
-    * to control if the {@code stack_trace} element should render. Unlike most parameters to {@code toXContent} methods this parameter is
-    * internal only and not available as a URL parameter. Use the {@code error_trace} parameter instead.
-    */
-    public static final String REST_EXCEPTION_SKIP_STACK_TRACE = "rest.exception.stacktrace.skip";
-    public static final boolean REST_EXCEPTION_SKIP_STACK_TRACE_DEFAULT = true;
-    private static final boolean REST_EXCEPTION_SKIP_CAUSE_DEFAULT = false;
-    private static final String INDEX_METADATA_KEY = "opensearch.index";
-    private static final String INDEX_METADATA_KEY_UUID = "opensearch.index_uuid";
-    private static final String SHARD_METADATA_KEY = "opensearch.shard";
-    private static final String RESOURCE_METADATA_TYPE_KEY = "opensearch.resource.type";
-    private static final String RESOURCE_METADATA_ID_KEY = "opensearch.resource.id";
-
-    private static final String TYPE = "type";
-    private static final String REASON = "reason";
-    private static final String CAUSED_BY = "caused_by";
-    private static final ParseField SUPPRESSED = new ParseField("suppressed");
-    public static final String STACK_TRACE = "stack_trace";
-    private static final String HEADER = "header";
-    private static final String ERROR = "error";
-    private static final String ROOT_CAUSE = "root_cause";
-
-    private static final Map<Integer, CheckedFunction<CodedInputStream, ? extends ProtobufOpenSearchException, IOException>> ID_TO_SUPPLIER;
-    private static final Map<Class<? extends ProtobufOpenSearchException>, OpenSearchExceptionHandle> CLASS_TO_OPENSEARCH_EXCEPTION_HANDLE;
-
-    private static final Pattern OS_METADATA = Pattern.compile("^opensearch\\.");
-
-    private final Map<String, List<String>> metadata = new HashMap<>();
-    private final Map<String, List<String>> headers = new HashMap<>();
-
-    /**
-     * Construct a <code>ProtobufOpenSearchException</code> with the specified cause exception.
-    */
-    public ProtobufOpenSearchException(Throwable cause) {
-        super(cause);
-    }
-
-    /**
-     * Construct a <code>ProtobufOpenSearchException</code> with the specified detail message.
-    *
-    * The message can be parameterized using <code>{}</code> as placeholders for the given
-    * arguments
-    *
-    * @param msg  the detail message
-    * @param args the arguments for the message
-    */
-    public ProtobufOpenSearchException(String msg, Object... args) {
-        super(LoggerMessageFormat.format(msg, args));
-    }
-
-    /**
-     * Construct a <code>ProtobufOpenSearchException</code> with the specified detail message
-    * and nested exception.
-    *
-    * The message can be parameterized using <code>{}</code> as placeholders for the given
-    * arguments
-    *
-    * @param msg   the detail message
-    * @param cause the nested exception
-    * @param args  the arguments for the message
-    */
-    public ProtobufOpenSearchException(String msg, Throwable cause, Object... args) {
-        super(LoggerMessageFormat.format(msg, args), cause);
-    }
-
-    public ProtobufOpenSearchException(CodedInputStream in) throws IOException {
-        super(new ProtobufStreamInput(in).readOptionalString(), new ProtobufStreamInput(in).readException());
-        readStackTrace(this, in);
-        // headers.putAll(in.readMapOfLists(StreamInput::readString, StreamInput::readString));
-        // metadata.putAll(in.readMapOfLists(StreamInput::readString, StreamInput::readString));
-    }
-
-    /**
-     * Adds a new piece of metadata with the given key.
-    * If the provided key is already present, the corresponding metadata will be replaced
-    */
-    public void addMetadata(String key, String... values) {
-        addMetadata(key, Arrays.asList(values));
-    }
-
-    /**
-     * Adds a new piece of metadata with the given key.
-    * If the provided key is already present, the corresponding metadata will be replaced
-    */
-    public void addMetadata(String key, List<String> values) {
-        // we need to enforce this otherwise bw comp doesn't work properly, as "opensearch."
-        // was the previous criteria to split headers in two sets
-        if (key.startsWith("opensearch.") == false) {
-            throw new IllegalArgumentException("exception metadata must start with [opensearch.], found [" + key + "] instead");
-        }
-        this.metadata.put(key, values);
-    }
-
-    /**
-     * Returns a set of all metadata keys on this exception
-    */
-    public Set<String> getMetadataKeys() {
-        return metadata.keySet();
-    }
-
-    /**
-     * Returns the list of metadata values for the given key or {@code null} if no metadata for the
-    * given key exists.
-    */
-    public List<String> getMetadata(String key) {
-        return metadata.get(key);
-    }
-
-    protected Map<String, List<String>> getMetadata() {
-        return metadata;
-    }
-
-    /**
-     * Adds a new header with the given key.
-    * This method will replace existing header if a header with the same key already exists
-    */
-    public void addHeader(String key, List<String> value) {
-        // we need to enforce this otherwise bw comp doesn't work properly, as "opensearch."
-        // was the previous criteria to split headers in two sets
-        if (key.startsWith("opensearch.")) {
-            throw new IllegalArgumentException("exception headers must not start with [opensearch.], found [" + key + "] instead");
-        }
-        this.headers.put(key, value);
-    }
-
-    /**
-     * Adds a new header with the given key.
-    * This method will replace existing header if a header with the same key already exists
-    */
-    public void addHeader(String key, String... value) {
-        addHeader(key, Arrays.asList(value));
-    }
-
-    /**
-     * Returns a set of all header keys on this exception
-    */
-    public Set<String> getHeaderKeys() {
-        return headers.keySet();
-    }
-
-    /**
-     * Returns the list of header values for the given key or {@code null} if no header for the
-    * given key exists.
-    */
-    public List<String> getHeader(String key) {
-        return headers.get(key);
-    }
-
-    protected Map<String, List<String>> getHeaders() {
-        return headers;
-    }
-
-    /**
-     * Returns the rest status code associated with this exception.
-    */
-    public RestStatus status() {
-        Throwable cause = unwrapCause();
-        if (cause == this) {
-            return RestStatus.INTERNAL_SERVER_ERROR;
-        } else {
-            return ExceptionsHelper.status(cause);
-        }
-    }
-
-    /**
-     * Unwraps the actual cause from the exception for cases when the exception is a
-    * {@link OpenSearchWrapperException}.
-    *
-    * @see ExceptionsHelper#unwrapCause(Throwable)
-    */
-    public Throwable unwrapCause() {
-        return ExceptionsHelper.unwrapCause(this);
-    }
-
-    /**
-     * Return the detail message, including the message from the nested exception
-    * if there is one.
-    */
-    public String getDetailedMessage() {
-        if (getCause() != null) {
-            StringBuilder sb = new StringBuilder();
-            sb.append(toString()).append("; ");
-            if (getCause() instanceof ProtobufOpenSearchException) {
-                sb.append(((ProtobufOpenSearchException) getCause()).getDetailedMessage());
-            } else {
-                sb.append(getCause());
-            }
-            return sb.toString();
-        } else {
-            return super.toString();
-        }
-    }
-
-    /**
-     * Retrieve the innermost cause of this exception, if none, returns the current exception.
-    */
-    public Throwable getRootCause() {
-        Throwable rootCause = this;
-        Throwable cause = getCause();
-        while (cause != null && cause != rootCause) {
-            rootCause = cause;
-            cause = cause.getCause();
-        }
-        return rootCause;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeOptionalString(this.getMessage());
-        protobufStreamOutput.writeException(this.getCause());
-        writeStackTraces(this, out, protobufStreamOutput);
-        // out.writeMapOfLists(headers, StreamOutput::writeString, StreamOutput::writeString);
-        // out.writeMapOfLists(metadata, StreamOutput::writeString, StreamOutput::writeString);
-    }
-
-    public static ProtobufOpenSearchException readException(CodedInputStream input, int id) throws IOException {
-        CheckedFunction<CodedInputStream, ? extends ProtobufOpenSearchException, IOException> opensearchException = ID_TO_SUPPLIER.get(id);
-        if (opensearchException == null) {
-            throw new IllegalStateException("unknown exception for id: " + id);
-        }
-        return opensearchException.apply(input);
-    }
-
-    /**
-     * Returns <code>true</code> iff the given class is a registered for an exception to be read.
-    */
-    public static boolean isRegistered(Class<? extends Throwable> exception, Version version) {
-        OpenSearchExceptionHandle openSearchExceptionHandle = CLASS_TO_OPENSEARCH_EXCEPTION_HANDLE.get(exception);
-        if (openSearchExceptionHandle != null) {
-            return version.onOrAfter(openSearchExceptionHandle.versionAdded);
-        }
-        return false;
-    }
-
-    static Set<Class<? extends ProtobufOpenSearchException>> getRegisteredKeys() { // for testing
-        return CLASS_TO_OPENSEARCH_EXCEPTION_HANDLE.keySet();
-    }
-
-    /**
-     * Returns the serialization id the given exception.
-    */
-    public static int getId(Class<? extends ProtobufOpenSearchException> exception) {
-        return CLASS_TO_OPENSEARCH_EXCEPTION_HANDLE.get(exception).id;
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        Throwable ex = ExceptionsHelper.unwrapCause(this);
-        if (ex != this) {
-            generateThrowableXContent(builder, params, this);
-        } else {
-            innerToXContent(builder, params, this, getExceptionName(), getMessage(), headers, metadata, getCause());
-        }
-        return builder;
-    }
-
-    protected static void innerToXContent(
-        XContentBuilder builder,
-        Params params,
-        Throwable throwable,
-        String type,
-        String message,
-        Map<String, List<String>> headers,
-        Map<String, List<String>> metadata,
-        Throwable cause
-    ) throws IOException {
-        builder.field(TYPE, type);
-        builder.field(REASON, message);
-
-        for (Map.Entry<String, List<String>> entry : metadata.entrySet()) {
-            headerToXContent(builder, entry.getKey().substring("opensearch.".length()), entry.getValue());
-        }
-
-        if (throwable instanceof ProtobufOpenSearchException) {
-            ProtobufOpenSearchException exception = (ProtobufOpenSearchException) throwable;
-            exception.metadataToXContent(builder, params);
-        }
-
-        if (params.paramAsBoolean(REST_EXCEPTION_SKIP_CAUSE, REST_EXCEPTION_SKIP_CAUSE_DEFAULT) == false) {
-            if (cause != null) {
-                builder.field(CAUSED_BY);
-                builder.startObject();
-                generateThrowableXContent(builder, params, cause);
-                builder.endObject();
-            }
-        }
-
-        if (headers.isEmpty() == false) {
-            builder.startObject(HEADER);
-            for (Map.Entry<String, List<String>> entry : headers.entrySet()) {
-                headerToXContent(builder, entry.getKey(), entry.getValue());
-            }
-            builder.endObject();
-        }
-
-        if (params.paramAsBoolean(REST_EXCEPTION_SKIP_STACK_TRACE, REST_EXCEPTION_SKIP_STACK_TRACE_DEFAULT) == false) {
-            builder.field(STACK_TRACE, ExceptionsHelper.stackTrace(throwable));
-        }
-
-        Throwable[] allSuppressed = throwable.getSuppressed();
-        if (allSuppressed.length > 0) {
-            builder.startArray(SUPPRESSED.getPreferredName());
-            for (Throwable suppressed : allSuppressed) {
-                builder.startObject();
-                generateThrowableXContent(builder, params, suppressed);
-                builder.endObject();
-            }
-            builder.endArray();
-        }
-    }
-
-    private static void headerToXContent(XContentBuilder builder, String key, List<String> values) throws IOException {
-        if (values != null && values.isEmpty() == false) {
-            if (values.size() == 1) {
-                builder.field(key, values.get(0));
-            } else {
-                builder.startArray(key);
-                for (String value : values) {
-                    builder.value(value);
-                }
-                builder.endArray();
-            }
-        }
-    }
-
-    /**
-     * Renders additional per exception information into the XContent
-    */
-    protected void metadataToXContent(XContentBuilder builder, Params params) throws IOException {}
-
-    /**
-     * Generate a {@link ProtobufOpenSearchException} from a {@link XContentParser}. This does not
-    * return the original exception type (ie NodeClosedException for example) but just wraps
-    * the type, the reason and the cause of the exception. It also recursively parses the
-    * tree structure of the cause, returning it as a tree structure of {@link ProtobufOpenSearchException}
-    * instances.
-    */
-    public static ProtobufOpenSearchException fromXContent(XContentParser parser) throws IOException {
-        XContentParser.Token token = parser.nextToken();
-        ensureExpectedToken(XContentParser.Token.FIELD_NAME, token, parser);
-        return innerFromXContent(parser, false);
-    }
-
-    public static ProtobufOpenSearchException innerFromXContent(XContentParser parser, boolean parseRootCauses) throws IOException {
-        XContentParser.Token token = parser.currentToken();
-        ensureExpectedToken(XContentParser.Token.FIELD_NAME, token, parser);
-
-        String type = null, reason = null, stack = null;
-        ProtobufOpenSearchException cause = null;
-        Map<String, List<String>> metadata = new HashMap<>();
-        Map<String, List<String>> headers = new HashMap<>();
-        List<ProtobufOpenSearchException> rootCauses = new ArrayList<>();
-        List<ProtobufOpenSearchException> suppressed = new ArrayList<>();
-
-        for (; token == XContentParser.Token.FIELD_NAME; token = parser.nextToken()) {
-            String currentFieldName = parser.currentName();
-            token = parser.nextToken();
-
-            if (token.isValue()) {
-                if (TYPE.equals(currentFieldName)) {
-                    type = parser.text();
-                } else if (REASON.equals(currentFieldName)) {
-                    reason = parser.text();
-                } else if (STACK_TRACE.equals(currentFieldName)) {
-                    stack = parser.text();
-                } else if (token == XContentParser.Token.VALUE_STRING) {
-                    metadata.put(currentFieldName, Collections.singletonList(parser.text()));
-                }
-            } else if (token == XContentParser.Token.START_OBJECT) {
-                if (CAUSED_BY.equals(currentFieldName)) {
-                    cause = fromXContent(parser);
-                } else if (HEADER.equals(currentFieldName)) {
-                    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
-                        if (token == XContentParser.Token.FIELD_NAME) {
-                            currentFieldName = parser.currentName();
-                        } else {
-                            List<String> values = headers.getOrDefault(currentFieldName, new ArrayList<>());
-                            if (token == XContentParser.Token.VALUE_STRING) {
-                                values.add(parser.text());
-                            } else if (token == XContentParser.Token.START_ARRAY) {
-                                while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
-                                    if (token == XContentParser.Token.VALUE_STRING) {
-                                        values.add(parser.text());
-                                    } else {
-                                        parser.skipChildren();
-                                    }
-                                }
-                            } else if (token == XContentParser.Token.START_OBJECT) {
-                                parser.skipChildren();
-                            }
-                            headers.put(currentFieldName, values);
-                        }
-                    }
-                } else {
-                    // Any additional metadata object added by the metadataToXContent method is ignored
-                    // and skipped, so that the parser does not fail on unknown fields. The parser only
-                    // support metadata key-pairs and metadata arrays of values.
-                    parser.skipChildren();
-                }
-            } else if (token == XContentParser.Token.START_ARRAY) {
-                if (parseRootCauses && ROOT_CAUSE.equals(currentFieldName)) {
-                    while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
-                        rootCauses.add(fromXContent(parser));
-                    }
-                } else if (SUPPRESSED.match(currentFieldName, parser.getDeprecationHandler())) {
-                    while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
-                        suppressed.add(fromXContent(parser));
-                    }
-                } else {
-                    // Parse the array and add each item to the corresponding list of metadata.
-                    // Arrays of objects are not supported yet and just ignored and skipped.
-                    List<String> values = new ArrayList<>();
-                    while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
-                        if (token == XContentParser.Token.VALUE_STRING) {
-                            values.add(parser.text());
-                        } else {
-                            parser.skipChildren();
-                        }
-                    }
-                    if (values.size() > 0) {
-                        if (metadata.containsKey(currentFieldName)) {
-                            values.addAll(metadata.get(currentFieldName));
-                        }
-                        metadata.put(currentFieldName, values);
-                    }
-                }
-            }
-        }
-
-        ProtobufOpenSearchException e = new ProtobufOpenSearchException(buildMessage(type, reason, stack), cause);
-        for (Map.Entry<String, List<String>> entry : metadata.entrySet()) {
-            // subclasses can print out additional metadata through the metadataToXContent method. Simple key-value pairs will be
-            // parsed back and become part of this metadata set, while objects and arrays are not supported when parsing back.
-            // Those key-value pairs become part of the metadata set and inherit the "opensearch." prefix as that is currently required
-            // by addMetadata. The prefix will get stripped out when printing metadata out so it will be effectively invisible.
-            // TODO move subclasses that print out simple metadata to using addMetadata directly and support also numbers and booleans.
-            // TODO rename metadataToXContent and have only SearchPhaseExecutionException use it, which prints out complex objects
-            e.addMetadata("opensearch." + entry.getKey(), entry.getValue());
-        }
-        for (Map.Entry<String, List<String>> header : headers.entrySet()) {
-            e.addHeader(header.getKey(), header.getValue());
-        }
-
-        // Adds root causes as suppressed exception. This way they are not lost
-        // after parsing and can be retrieved using getSuppressed() method.
-        for (ProtobufOpenSearchException rootCause : rootCauses) {
-            e.addSuppressed(rootCause);
-        }
-        for (ProtobufOpenSearchException s : suppressed) {
-            e.addSuppressed(s);
-        }
-        return e;
-    }
-
-    /**
-     * Static toXContent helper method that renders {@link ProtobufOpenSearchException} or {@link Throwable} instances
-    * as XContent, delegating the rendering to {@link #toXContent(XContentBuilder, Params)}
-    * or {@link #innerToXContent(XContentBuilder, Params, Throwable, String, String, Map, Map, Throwable)}.
-    *
-    * This method is usually used when the {@link Throwable} is rendered as a part of another XContent object, and its result can
-    * be parsed back using the {@link #fromXContent(XContentParser)} method.
-    */
-    public static void generateThrowableXContent(XContentBuilder builder, Params params, Throwable t) throws IOException {
-        t = ExceptionsHelper.unwrapCause(t);
-
-        if (t instanceof ProtobufOpenSearchException) {
-            ((ProtobufOpenSearchException) t).toXContent(builder, params);
-        } else {
-            innerToXContent(builder, params, t, getExceptionName(t), t.getMessage(), emptyMap(), emptyMap(), t.getCause());
-        }
-    }
-
-    /**
-     * Render any exception as a xcontent, encapsulated within a field or object named "error". The level of details that are rendered
-    * depends on the value of the "detailed" parameter: when it's false only a simple message based on the type and message of the
-    * exception is rendered. When it's true all detail are provided including guesses root causes, cause and potentially stack
-    * trace.
-    *
-    * This method is usually used when the {@link Exception} is rendered as a full XContent object, and its output can be parsed
-    * by the {@link #failureFromXContent(XContentParser)} method.
-    */
-    public static void generateFailureXContent(XContentBuilder builder, Params params, @Nullable Exception e, boolean detailed)
-        throws IOException {
-        // No exception to render as an error
-        if (e == null) {
-            builder.field(ERROR, "unknown");
-            return;
-        }
-
-        // Render the exception with a simple message
-        if (detailed == false) {
-            Throwable t = e;
-            for (int counter = 0; counter < 10 && t != null; counter++) {
-                if (t instanceof ProtobufOpenSearchException) {
-                    break;
-                }
-                t = t.getCause();
-            }
-            builder.field(ERROR, ExceptionsHelper.summaryMessage(t != null ? t : e));
-            return;
-        }
-
-        // Render the exception with all details
-        final ProtobufOpenSearchException[] rootCauses = ProtobufOpenSearchException.guessRootCauses(e);
-        builder.startObject(ERROR);
-        {
-            builder.startArray(ROOT_CAUSE);
-            for (ProtobufOpenSearchException rootCause : rootCauses) {
-                builder.startObject();
-                rootCause.toXContent(builder, new DelegatingMapParams(singletonMap(REST_EXCEPTION_SKIP_CAUSE, "true"), params));
-                builder.endObject();
-            }
-            builder.endArray();
-        }
-        generateThrowableXContent(builder, params, e);
-        builder.endObject();
-    }
-
-    /**
-     * Parses the output of {@link #generateFailureXContent(XContentBuilder, Params, Exception, boolean)}
-    */
-    public static ProtobufOpenSearchException failureFromXContent(XContentParser parser) throws IOException {
-        XContentParser.Token token = parser.currentToken();
-        ensureFieldName(parser, token, ERROR);
-
-        token = parser.nextToken();
-        if (token.isValue()) {
-            return new ProtobufOpenSearchException(buildMessage("exception", parser.text(), null));
-        }
-
-        ensureExpectedToken(XContentParser.Token.START_OBJECT, token, parser);
-        token = parser.nextToken();
-
-        // Root causes are parsed in the innerFromXContent() and are added as suppressed exceptions.
-        return innerFromXContent(parser, true);
-    }
-
-    /**
-     * Returns the root cause of this exception or multiple if different shards caused different exceptions
-    */
-    public ProtobufOpenSearchException[] guessRootCauses() {
-        final Throwable cause = getCause();
-        if (cause != null && cause instanceof ProtobufOpenSearchException) {
-            return ((ProtobufOpenSearchException) cause).guessRootCauses();
-        }
-        return new ProtobufOpenSearchException[] { this };
-    }
-
-    /**
-     * Returns the root cause of this exception or multiple if different shards caused different exceptions.
-    * If the given exception is not an instance of {@link ProtobufOpenSearchException} an empty array
-    * is returned.
-    */
-    public static ProtobufOpenSearchException[] guessRootCauses(Throwable t) {
-        Throwable ex = ExceptionsHelper.unwrapCause(t);
-        if (ex instanceof ProtobufOpenSearchException) {
-            // ProtobufOpenSearchException knows how to guess its own root cause
-            return ((ProtobufOpenSearchException) ex).guessRootCauses();
-        }
-        if (ex instanceof XContentParseException) {
-            /*
-            * We'd like to unwrap parsing exceptions to the inner-most
-            * parsing exception because that is generally the most interesting
-            * exception to return to the user. If that exception is caused by
-            * an ProtobufOpenSearchException we'd like to keep unwrapping because
-            * ProtobufOpenSearchException instances tend to contain useful information
-            * for the user.
-            */
-            Throwable cause = ex.getCause();
-            if (cause != null) {
-                if (cause instanceof XContentParseException || cause instanceof ProtobufOpenSearchException) {
-                    return guessRootCauses(ex.getCause());
-                }
-            }
-        }
-        return new ProtobufOpenSearchException[] { new ProtobufOpenSearchException(ex.getMessage(), ex) {
-            @Override
-            protected String getExceptionName() {
-                return getExceptionName(getCause());
-            }
-        } };
-    }
-
-    protected String getExceptionName() {
-        return getExceptionName(this);
-    }
-
-    /**
-     * Returns an underscore case name for the given exception. This method strips {@code OpenSearch} prefixes from exception names.
-    */
-    public static String getExceptionName(Throwable ex) {
-        String simpleName = ex.getClass().getSimpleName();
-        if (simpleName.startsWith("OpenSearch")) {
-            simpleName = simpleName.substring("OpenSearch".length());
-        }
-        // TODO: do we really need to make the exception name in underscore casing?
-        return toUnderscoreCase(simpleName);
-    }
-
-    static String buildMessage(String type, String reason, String stack) {
-        StringBuilder message = new StringBuilder("OpenSearch exception [");
-        message.append(TYPE).append('=').append(type).append(", ");
-        message.append(REASON).append('=').append(reason);
-        if (stack != null) {
-            message.append(", ").append(STACK_TRACE).append('=').append(stack);
-        }
-        message.append(']');
-        return message.toString();
-    }
-
-    @Override
-    public String toString() {
-        StringBuilder builder = new StringBuilder();
-        if (metadata.containsKey(INDEX_METADATA_KEY)) {
-            builder.append(getIndex());
-            if (metadata.containsKey(SHARD_METADATA_KEY)) {
-                builder.append('[').append(getShardId()).append(']');
-            }
-            builder.append(' ');
-        }
-        return builder.append(ExceptionsHelper.detailedMessage(this).trim()).toString();
-    }
-
-    /**
-     * Deserializes stacktrace elements as well as suppressed exceptions from the given output stream and
-    * adds it to the given exception.
-    */
-    public static <T extends Throwable> T readStackTrace(T throwable, CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        throwable.setStackTrace(protobufStreamInput.readArray(i -> {
-            final String declaringClasss = i.readString();
-            final String fileName = protobufStreamInput.readOptionalString();
-            final String methodName = i.readString();
-            final int lineNumber = i.readInt32();
-            return new StackTraceElement(declaringClasss, methodName, fileName, lineNumber);
-        }, StackTraceElement[]::new));
-
-        int numSuppressed = protobufStreamInput.readVInt();
-        for (int i = 0; i < numSuppressed; i++) {
-            throwable.addSuppressed(protobufStreamInput.readException());
-        }
-        return throwable;
-    }
-
-    /**
-     * Serializes the given exceptions stacktrace elements as well as it's suppressed exceptions to the given output stream.
-    */
-    public static <T extends Throwable> T writeStackTraces(T throwable, CodedOutputStream out, ProtobufStreamOutput protobufStreamOutput)
-        throws IOException {
-        protobufStreamOutput.writeArray((o, v) -> {
-            o.writeStringNoTag(v.getClassName());
-            protobufStreamOutput.writeOptionalString(v.getFileName());
-            o.writeStringNoTag(v.getMethodName());
-            o.writeInt32NoTag(v.getLineNumber());
-        }, throwable.getStackTrace());
-        protobufStreamOutput.writeArray((o, v) -> { o.writeStringNoTag(v.toString()); }, throwable.getSuppressed());
-        return throwable;
-    }
-
-    /**
-     * This is the list of Exceptions OpenSearch can throw over the wire or save into a corruption marker. Each value in the enum is a
-    * single exception tying the Class to an id for use of the encode side and the id back to a constructor for use on the decode side. As
-    * such its ok if the exceptions to change names so long as their constructor can still read the exception. Each exception is listed
-    * in id order below. If you want to remove an exception leave a tombstone comment and mark the id as null in
-    * ExceptionSerializationTests.testIds.ids.
-    */
-    private enum OpenSearchExceptionHandle {
-        NODE_CLOSED_EXCEPTION(
-            org.opensearch.node.ProtobufNodeClosedException.class,
-            org.opensearch.node.ProtobufNodeClosedException::new,
-            9,
-            UNKNOWN_VERSION_ADDED
-        ),
-        CONNECT_TRANSPORT_EXCEPTION(
-            org.opensearch.transport.ProtobufConnectTransportException.class,
-            org.opensearch.transport.ProtobufConnectTransportException::new,
-            12,
-            UNKNOWN_VERSION_ADDED
-        ),
-        ACTION_TRANSPORT_EXCEPTION(
-            org.opensearch.transport.ProtobufActionTransportException.class,
-            org.opensearch.transport.ProtobufActionTransportException::new,
-            20,
-            UNKNOWN_VERSION_ADDED
-        ),
-        TRANSPORT_EXCEPTION(
-            org.opensearch.transport.ProtobufTransportException.class,
-            org.opensearch.transport.ProtobufTransportException::new,
-            34,
-            UNKNOWN_VERSION_ADDED
-        ),
-        FAILED_NODE_EXCEPTION(
-            org.opensearch.action.ProtobufFailedNodeException.class,
-            org.opensearch.action.ProtobufFailedNodeException::new,
-            71,
-            UNKNOWN_VERSION_ADDED
-        ),
-        RECEIVE_TIMEOUT_TRANSPORT_EXCEPTION(
-            org.opensearch.transport.ProtobufReceiveTimeoutTransportException.class,
-            org.opensearch.transport.ProtobufReceiveTimeoutTransportException::new,
-            83,
-            UNKNOWN_VERSION_ADDED
-        ),
-        NODE_DISCONNECTED_EXCEPTION(
-            org.opensearch.transport.ProtobufNodeDisconnectedException.class,
-            org.opensearch.transport.ProtobufNodeDisconnectedException::new,
-            84,
-            UNKNOWN_VERSION_ADDED
-        ),
-        REMOTE_TRANSPORT_EXCEPTION(
-            org.opensearch.transport.ProtobufRemoteTransportException.class,
-            org.opensearch.transport.ProtobufRemoteTransportException::new,
-            103,
-            UNKNOWN_VERSION_ADDED
-        ),
-        NODE_NOT_CONNECTED_EXCEPTION(
-            org.opensearch.transport.ProtobufNodeNotConnectedException.class,
-            org.opensearch.transport.ProtobufNodeNotConnectedException::new,
-            134,
-            UNKNOWN_VERSION_ADDED
-        );
-
-        final Class<? extends ProtobufOpenSearchException> exceptionClass;
-        final CheckedFunction<CodedInputStream, ? extends ProtobufOpenSearchException, IOException> constructor;
-        final int id;
-        final Version versionAdded;
-
-        <E extends ProtobufOpenSearchException> OpenSearchExceptionHandle(
-            Class<E> exceptionClass,
-            CheckedFunction<CodedInputStream, E, IOException> constructor,
-            int id,
-            Version versionAdded
-        ) {
-            // We need the exceptionClass because you can't dig it out of the constructor reliably.
-            this.exceptionClass = exceptionClass;
-            this.constructor = constructor;
-            this.versionAdded = versionAdded;
-            this.id = id;
-        }
-    }
-
-    /**
-     * Returns an array of all registered handle IDs. These are the IDs for every registered
-    * exception.
-    *
-    * @return an array of all registered handle IDs
-    */
-    static int[] ids() {
-        return Arrays.stream(OpenSearchExceptionHandle.values()).mapToInt(h -> h.id).toArray();
-    }
-
-    /**
-     * Returns an array of all registered pairs of handle IDs and exception classes. These pairs are
-    * provided for every registered exception.
-    *
-    * @return an array of all registered pairs of handle IDs and exception classes
-    */
-    static Tuple<Integer, Class<? extends ProtobufOpenSearchException>>[] classes() {
-        @SuppressWarnings("unchecked")
-        final Tuple<Integer, Class<? extends ProtobufOpenSearchException>>[] ts = Arrays.stream(OpenSearchExceptionHandle.values())
-            .map(h -> Tuple.tuple(h.id, h.exceptionClass))
-            .toArray(Tuple[]::new);
-        return ts;
-    }
-
-    static {
-        ID_TO_SUPPLIER = unmodifiableMap(
-            Arrays.stream(OpenSearchExceptionHandle.values()).collect(Collectors.toMap(e -> e.id, e -> e.constructor))
-        );
-        CLASS_TO_OPENSEARCH_EXCEPTION_HANDLE = unmodifiableMap(
-            Arrays.stream(OpenSearchExceptionHandle.values()).collect(Collectors.toMap(e -> e.exceptionClass, e -> e))
-        );
-    }
-
-    public Index getIndex() {
-        List<String> index = getMetadata(INDEX_METADATA_KEY);
-        if (index != null && index.isEmpty() == false) {
-            List<String> index_uuid = getMetadata(INDEX_METADATA_KEY_UUID);
-            return new Index(index.get(0), index_uuid.get(0));
-        }
-
-        return null;
-    }
-
-    public ShardId getShardId() {
-        List<String> shard = getMetadata(SHARD_METADATA_KEY);
-        if (shard != null && shard.isEmpty() == false) {
-            return new ShardId(getIndex(), Integer.parseInt(shard.get(0)));
-        }
-        return null;
-    }
-
-    public void setIndex(Index index) {
-        if (index != null) {
-            addMetadata(INDEX_METADATA_KEY, index.getName());
-            addMetadata(INDEX_METADATA_KEY_UUID, index.getUUID());
-        }
-    }
-
-    public void setIndex(String index) {
-        if (index != null) {
-            setIndex(new Index(index, INDEX_UUID_NA_VALUE));
-        }
-    }
-
-    public void setShard(ShardId shardId) {
-        if (shardId != null) {
-            setIndex(shardId.getIndex());
-            addMetadata(SHARD_METADATA_KEY, Integer.toString(shardId.id()));
-        }
-    }
-
-    public void setResources(String type, String... id) {
-        assert type != null;
-        addMetadata(RESOURCE_METADATA_ID_KEY, id);
-        addMetadata(RESOURCE_METADATA_TYPE_KEY, type);
-    }
-
-    public List<String> getResourceId() {
-        return getMetadata(RESOURCE_METADATA_ID_KEY);
-    }
-
-    public String getResourceType() {
-        List<String> header = getMetadata(RESOURCE_METADATA_TYPE_KEY);
-        if (header != null && header.isEmpty() == false) {
-            assert header.size() == 1;
-            return header.get(0);
-        }
-        return null;
-    }
-
-    // lower cases and adds underscores to transitions in a name
-    private static String toUnderscoreCase(String value) {
-        StringBuilder sb = new StringBuilder();
-        boolean changed = false;
-        for (int i = 0; i < value.length(); i++) {
-            char c = value.charAt(i);
-            if (Character.isUpperCase(c)) {
-                if (!changed) {
-                    // copy it over here
-                    for (int j = 0; j < i; j++) {
-                        sb.append(value.charAt(j));
-                    }
-                    changed = true;
-                    if (i == 0) {
-                        sb.append(Character.toLowerCase(c));
-                    } else {
-                        sb.append('_');
-                        sb.append(Character.toLowerCase(c));
-                    }
-                } else {
-                    sb.append('_');
-                    sb.append(Character.toLowerCase(c));
-                }
-            } else {
-                if (changed) {
-                    sb.append(c);
-                }
-            }
-        }
-        if (!changed) {
-            return value;
-        }
-        return sb.toString();
-    }
-
-}
diff --git a/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java b/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java
index 7fcf9fb886e38..fe98f7d373639 100644
--- a/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java
+++ b/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java
@@ -37,9 +37,6 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportResponseHandler;
 
-import com.google.protobuf.CodedInputStream;
-
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponse;
 
@@ -93,18 +90,6 @@ public String toString() {
         return super.toString() + "/" + listener;
     }
 
-    @Override
-    public Response read(CodedInputStream in) throws IOException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'read'");
-    }
-
-    @Override
-    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-    }
-
     @Override
     public Response read(byte[] in) throws IOException {
         // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java b/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
index 4955b1a717cd1..b9282dee63996 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
@@ -9,12 +9,10 @@
 package org.opensearch.action;
 
 import com.google.protobuf.CodedInputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportResponseHandler;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponse;
 
@@ -55,7 +53,7 @@ public void handleResponse(Response response) {
     }
 
     @Override
-    public void handleExceptionProtobuf(ProtobufTransportException e) {
+    public void handleException(TransportException e) {
         listener.onFailure(e);
     }
 
@@ -64,12 +62,6 @@ public String executor() {
         return executor;
     }
 
-    @Override
-    public Response read(CodedInputStream in) throws IOException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'read'");
-    }
-
     @Override
     public String toString() {
         return super.toString() + "/" + listener;
@@ -81,11 +73,6 @@ public Response read(StreamInput in) throws IOException {
         throw new UnsupportedOperationException("Unimplemented method 'read'");
     }
 
-    @Override
-    public void handleException(TransportException exp) {
-        listener.onFailure(exp);
-    }
-
     @Override
     public Response read(byte[] in) throws IOException {
         return reader.read(in);
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionRequest.java b/server/src/main/java/org/opensearch/action/ProtobufActionRequest.java
index eb81bf81f9049..0bf8fd85268a9 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionRequest.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionRequest.java
@@ -13,11 +13,10 @@
 
 package org.opensearch.action;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import org.opensearch.transport.TransportRequest;
 
 import java.io.IOException;
+import java.io.OutputStream;
 
 /**
  * Base action request implemented by plugins.
@@ -33,7 +32,7 @@ public ProtobufActionRequest() {
         // this.listenerThreaded = request.listenerThreaded();
     }
 
-    public ProtobufActionRequest(CodedInputStream in) throws IOException {
+    public ProtobufActionRequest(byte[] in) throws IOException {
         super(in);
     }
 
@@ -47,7 +46,7 @@ public boolean getShouldStoreResult() {
     }
 
     @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
+    public void writeTo(OutputStream out) throws IOException {
         super.writeTo(out);
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java b/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java
index 8c070f849ee0e..8a3a0d4ff1cc6 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java
@@ -27,7 +27,7 @@ public abstract class ProtobufActionResponse extends TransportResponse {
 
     public ProtobufActionResponse() {}
 
-    public ProtobufActionResponse(CodedInputStream in) throws IOException {
+    public ProtobufActionResponse(byte[] in) throws IOException {
         super(in);
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionType.java b/server/src/main/java/org/opensearch/action/ProtobufActionType.java
index 2ddd444d4ce8b..ed8297fa3b176 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionType.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionType.java
@@ -8,7 +8,6 @@
 
 package org.opensearch.action;
 
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.transport.TransportRequestOptions;
@@ -21,17 +20,15 @@
 public class ProtobufActionType<Response extends ProtobufActionResponse> {
 
     private final String name;
-    private final ProtobufWriteable.Reader<Response> responseReader;
-    private final TryWriteable.Reader<Response> responseReaderTry;
+    private final TryWriteable.Reader<Response> responseReader;
 
     /**
      * @param name The name of the action, must be unique across actions.
     * @param responseReader A reader for the response type
     */
-    public ProtobufActionType(String name, ProtobufWriteable.Reader<Response> responseReader) {
+    public ProtobufActionType(String name, TryWriteable.Reader<Response> responseReader) {
         this.name = name;
         this.responseReader = responseReader;
-        this.responseReaderTry = null;
     }
 
     /**
@@ -44,12 +41,8 @@ public String name() {
     /**
      * Get a reader that can create a new instance of the class from a {@link org.opensearch.common.io.stream.StreamInput}
     */
-    public ProtobufWriteable.Reader<Response> getResponseReader() {
-        return responseReader;
-    }
-
     public TryWriteable.Reader<Response> getResponseReaderTry() {
-        return responseReaderTry;
+        return responseReader;
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/action/ProtobufFailedNodeException.java b/server/src/main/java/org/opensearch/action/ProtobufFailedNodeException.java
deleted file mode 100644
index 511d933391c00..0000000000000
--- a/server/src/main/java/org/opensearch/action/ProtobufFailedNodeException.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.action;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.ProtobufOpenSearchException;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-
-import java.io.IOException;
-
-/**
- * Base exception for a failed node
-*
-* @opensearch.internal
-*/
-public class ProtobufFailedNodeException extends ProtobufOpenSearchException implements ProtobufWriteable {
-
-    private final String nodeId;
-
-    public ProtobufFailedNodeException(String nodeId, String msg, Throwable cause) {
-        super(msg);
-        this.nodeId = nodeId;
-    }
-
-    public String nodeId() {
-        return this.nodeId;
-    }
-
-    public ProtobufFailedNodeException(CodedInputStream in) throws IOException {
-        super(in);
-        nodeId = in.readString();
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        super.writeTo(out);
-        out.writeStringNoTag(nodeId);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
index 63390fe874351..248b218af57da 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
@@ -13,8 +13,6 @@
 
 package org.opensearch.action.admin.cluster.node.info;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import com.google.protobuf.InvalidProtocolBufferException;
 
 import org.opensearch.Build;
@@ -22,23 +20,20 @@
 import org.opensearch.action.support.nodes.ProtobufBaseNodeResponse;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.Nullable;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.http.ProtobufHttpInfo;
-import org.opensearch.ingest.ProtobufIngestInfo;
+import org.opensearch.http.HttpInfo;
+import org.opensearch.ingest.IngestInfo;
 import org.opensearch.monitor.jvm.JvmInfo;
 import org.opensearch.monitor.os.OsInfo;
-import org.opensearch.monitor.os.ProtobufOsInfo;
-import org.opensearch.monitor.process.ProtobufProcessInfo;
+import org.opensearch.monitor.process.ProcessInfo;
 import org.opensearch.node.ProtobufReportingService;
-import org.opensearch.search.aggregations.support.ProtobufAggregationInfo;
-import org.opensearch.search.pipeline.ProtobufSearchPipelineInfo;
+import org.opensearch.search.aggregations.support.AggregationInfo;
+import org.opensearch.search.pipeline.SearchPipelineInfo;
 import org.opensearch.server.proto.NodesInfoProto;
-import org.opensearch.threadpool.ProtobufThreadPoolInfo;
-import org.opensearch.transport.ProtobufTransportInfo;
+import org.opensearch.threadpool.ThreadPoolInfo;
+import org.opensearch.transport.TransportInfo;
 
 import java.io.IOException;
 import java.io.OutputStream;
@@ -70,33 +65,6 @@ public class ProtobufNodeInfo extends ProtobufBaseNodeResponse implements TryWri
     @Nullable
     private ByteSizeValue totalIndexingBuffer;
 
-    public ProtobufNodeInfo(CodedInputStream in) throws IOException {
-        super(in);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        version = Version.readVersionProtobuf(in);
-        build = Build.readBuildProtobuf(in);
-        if (in.readBool()) {
-            totalIndexingBuffer = new ByteSizeValue(in.readInt64());
-        } else {
-            totalIndexingBuffer = null;
-        }
-        if (in.readBool()) {
-            settings = Settings.readSettingsFromStreamProtobuf(in);
-        }
-        addInfoIfNonNull(ProtobufOsInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufOsInfo::new));
-        addInfoIfNonNull(ProtobufProcessInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufProcessInfo::new));
-        addInfoIfNonNull(JvmInfo.class, protobufStreamInput.readOptionalWriteable(JvmInfo::new));
-        addInfoIfNonNull(ProtobufThreadPoolInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufThreadPoolInfo::new));
-        addInfoIfNonNull(ProtobufTransportInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufTransportInfo::new));
-        addInfoIfNonNull(ProtobufHttpInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufHttpInfo::new));
-        addInfoIfNonNull(ProtobufPluginsAndModules.class, protobufStreamInput.readOptionalWriteable(ProtobufPluginsAndModules::new));
-        addInfoIfNonNull(ProtobufIngestInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufIngestInfo::new));
-        addInfoIfNonNull(ProtobufAggregationInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufAggregationInfo::new));
-        if (protobufStreamInput.getVersion().onOrAfter(Version.V_2_7_0)) {
-            addInfoIfNonNull(ProtobufSearchPipelineInfo.class, protobufStreamInput.readOptionalWriteable(ProtobufSearchPipelineInfo::new));
-        }
-    }
-
     public ProtobufNodeInfo(byte[] data) throws InvalidProtocolBufferException {
         super(data);
         this.nodesInfoResponse = NodesInfoProto.NodesInfo.parseFrom(data);
@@ -107,32 +75,22 @@ public ProtobufNodeInfo(
         Build build,
         DiscoveryNode node,
         @Nullable Settings settings,
-        @Nullable ProtobufOsInfo os,
-        @Nullable ProtobufProcessInfo process,
+        @Nullable OsInfo os,
+        @Nullable ProcessInfo process,
         @Nullable JvmInfo jvm,
-        @Nullable ProtobufThreadPoolInfo threadPool,
-        @Nullable ProtobufTransportInfo transport,
-        @Nullable ProtobufHttpInfo http,
-        @Nullable ProtobufPluginsAndModules plugins,
-        @Nullable ProtobufIngestInfo ingest,
-        @Nullable ProtobufAggregationInfo aggsInfo,
+        @Nullable ThreadPoolInfo threadPool,
+        @Nullable TransportInfo transport,
+        @Nullable HttpInfo http,
+        @Nullable PluginsAndModules plugins,
+        @Nullable IngestInfo ingest,
+        @Nullable AggregationInfo aggsInfo,
         @Nullable ByteSizeValue totalIndexingBuffer,
-        @Nullable ProtobufSearchPipelineInfo ProtobufSearchPipelineInfo
+        @Nullable SearchPipelineInfo searchPipelineInfo
     ) {
         super(node);
         this.version = version;
         this.build = build;
         this.settings = settings;
-        addInfoIfNonNull(ProtobufOsInfo.class, os);
-        addInfoIfNonNull(ProtobufProcessInfo.class, process);
-        addInfoIfNonNull(JvmInfo.class, jvm);
-        addInfoIfNonNull(ProtobufThreadPoolInfo.class, threadPool);
-        addInfoIfNonNull(ProtobufTransportInfo.class, transport);
-        addInfoIfNonNull(ProtobufHttpInfo.class, http);
-        addInfoIfNonNull(ProtobufPluginsAndModules.class, plugins);
-        addInfoIfNonNull(ProtobufIngestInfo.class, ingest);
-        addInfoIfNonNull(ProtobufAggregationInfo.class, aggsInfo);
-        addInfoIfNonNull(ProtobufSearchPipelineInfo.class, ProtobufSearchPipelineInfo);
         this.totalIndexingBuffer = totalIndexingBuffer;
         this.nodesInfoResponse = NodesInfoProto.NodesInfo.newBuilder()
             .setNodeId(node.getId())
@@ -204,38 +162,6 @@ private <T extends ProtobufReportingService.ProtobufInfo> void addInfoIfNonNull(
         }
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        super.writeTo(out);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeInt32NoTag(version.id);
-        Build.writeBuildProtobuf(build, out);
-        if (totalIndexingBuffer == null) {
-            out.writeBoolNoTag(false);
-        } else {
-            out.writeBoolNoTag(true);
-            out.writeInt64NoTag(totalIndexingBuffer.getBytes());
-        }
-        if (settings == null) {
-            out.writeBoolNoTag(false);
-        } else {
-            out.writeBoolNoTag(true);
-            Settings.writeSettingsToStreamProtobuf(settings, out);
-        }
-        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufOsInfo.class));
-        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufProcessInfo.class));
-        protobufStreamOutput.writeOptionalWriteable(getInfo(JvmInfo.class));
-        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufThreadPoolInfo.class));
-        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufTransportInfo.class));
-        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufHttpInfo.class));
-        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufPluginsAndModules.class));
-        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufIngestInfo.class));
-        protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufAggregationInfo.class));
-        if (protobufStreamOutput.getVersion().onOrAfter(Version.V_2_7_0)) {
-            protobufStreamOutput.writeOptionalWriteable(getInfo(ProtobufSearchPipelineInfo.class));
-        }
-    }
-
     public static ProtobufNodeInfo.Builder builder(Version version, Build build, DiscoveryNode node) {
         return new Builder(version, build, node);
     }
@@ -255,29 +181,29 @@ private Builder(Version version, Build build, DiscoveryNode node) {
         }
 
         private Settings settings;
-        private ProtobufOsInfo os;
-        private ProtobufProcessInfo process;
+        private OsInfo os;
+        private ProcessInfo process;
         private JvmInfo jvm;
-        private ProtobufThreadPoolInfo threadPool;
-        private ProtobufTransportInfo transport;
-        private ProtobufHttpInfo http;
-        private ProtobufPluginsAndModules plugins;
-        private ProtobufIngestInfo ingest;
-        private ProtobufAggregationInfo aggsInfo;
+        private ThreadPoolInfo threadPool;
+        private TransportInfo transport;
+        private HttpInfo http;
+        private PluginsAndModules plugins;
+        private IngestInfo ingest;
+        private AggregationInfo aggsInfo;
         private ByteSizeValue totalIndexingBuffer;
-        private ProtobufSearchPipelineInfo ProtobufSearchPipelineInfo;
+        private SearchPipelineInfo searchPipelineInfo;
 
         public Builder setSettings(Settings settings) {
             this.settings = settings;
             return this;
         }
 
-        public Builder setOs(ProtobufOsInfo os) {
+        public Builder setOs(OsInfo os) {
             this.os = os;
             return this;
         }
 
-        public Builder setProcess(ProtobufProcessInfo process) {
+        public Builder setProcess(ProcessInfo process) {
             this.process = process;
             return this;
         }
@@ -287,32 +213,32 @@ public Builder setJvm(JvmInfo jvm) {
             return this;
         }
 
-        public Builder setThreadPool(ProtobufThreadPoolInfo threadPool) {
+        public Builder setThreadPool(ThreadPoolInfo threadPool) {
             this.threadPool = threadPool;
             return this;
         }
 
-        public Builder setTransport(ProtobufTransportInfo transport) {
+        public Builder setTransport(TransportInfo transport) {
             this.transport = transport;
             return this;
         }
 
-        public Builder setHttp(ProtobufHttpInfo http) {
+        public Builder setHttp(HttpInfo http) {
             this.http = http;
             return this;
         }
 
-        public Builder setPlugins(ProtobufPluginsAndModules plugins) {
+        public Builder setPlugins(PluginsAndModules plugins) {
             this.plugins = plugins;
             return this;
         }
 
-        public Builder setIngest(ProtobufIngestInfo ingest) {
+        public Builder setIngest(IngestInfo ingest) {
             this.ingest = ingest;
             return this;
         }
 
-        public Builder setAggsInfo(ProtobufAggregationInfo aggsInfo) {
+        public Builder setAggsInfo(AggregationInfo aggsInfo) {
             this.aggsInfo = aggsInfo;
             return this;
         }
@@ -322,8 +248,8 @@ public Builder setTotalIndexingBuffer(ByteSizeValue totalIndexingBuffer) {
             return this;
         }
 
-        public Builder setProtobufSearchPipelineInfo(ProtobufSearchPipelineInfo ProtobufSearchPipelineInfo) {
-            this.ProtobufSearchPipelineInfo = ProtobufSearchPipelineInfo;
+        public Builder setProtobufSearchPipelineInfo(SearchPipelineInfo searchPipelineInfo) {
+            this.searchPipelineInfo = searchPipelineInfo;
             return this;
         }
 
@@ -343,7 +269,7 @@ public ProtobufNodeInfo build() {
                 ingest,
                 aggsInfo,
                 totalIndexingBuffer,
-                ProtobufSearchPipelineInfo
+                searchPipelineInfo
             );
         }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
index b57674283a880..1529711d947e5 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
@@ -13,13 +13,9 @@
 
 package org.opensearch.action.admin.cluster.node.info;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import org.opensearch.action.support.nodes.ProtobufBaseNodesRequest;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.common.io.stream.TryWriteable;
+import org.opensearch.common.unit.TimeValue;
 import org.opensearch.server.proto.NodesInfoRequestProto.NodesInfoReq;
 import org.opensearch.server.proto.NodesInfoRequestProto;
 
@@ -39,21 +35,8 @@
  */
 public class ProtobufNodesInfoRequest extends ProtobufBaseNodesRequest<ProtobufNodesInfoRequest> implements TryWriteable {
 
-    private Set<String> requestedMetrics = Metric.allMetrics();
     private NodesInfoRequestProto.NodesInfoReq nodesInfoRequest;
-
-    /**
-     * Create a new NodeInfoRequest from a {@link StreamInput} object.
-     *
-     * @param in A stream input object.
-     * @throws IOException if the stream cannot be deserialized.
-     */
-    public ProtobufNodesInfoRequest(CodedInputStream in) throws IOException {
-        super(in);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        requestedMetrics.clear();
-        requestedMetrics.addAll(Arrays.asList(protobufStreamInput.readStringArray()));
-    }
+    private final TimeValue DEFAULT_TIMEOUT_SECS = TimeValue.timeValueSeconds(30);
 
     /**
      * Get information from nodes based on the nodes ids specified. If none are passed, information
@@ -61,23 +44,6 @@ public ProtobufNodesInfoRequest(CodedInputStream in) throws IOException {
      */
     public ProtobufNodesInfoRequest(String... nodesIds) {
         super(nodesIds);
-        all();
-    }
-
-    /**
-     * Clears all info flags.
-     */
-    public ProtobufNodesInfoRequest clear() {
-        requestedMetrics.clear();
-        return this;
-    }
-
-    /**
-     * Sets to return all the data.
-     */
-    public ProtobufNodesInfoRequest all() {
-        requestedMetrics.addAll(Metric.allMetrics());
-        return this;
     }
 
     /**
@@ -87,50 +53,20 @@ public Set<String> requestedMetrics() {
         return new HashSet<>(this.nodesInfoRequest.getRequestedMetricsList());
     }
 
-    /**
-     * Add metric
-     */
-    public ProtobufNodesInfoRequest addMetric(String metric) {
-        if (Metric.allMetrics().contains(metric) == false) {
-            throw new IllegalStateException("Used an illegal metric: " + metric);
-        }
-        requestedMetrics.add(metric);
-        return this;
-    }
-
     /**
      * Add multiple metrics
      */
-    public ProtobufNodesInfoRequest addMetrics(String... metrics) {
+    public ProtobufNodesInfoRequest addMetrics(String timeout, String... metrics) {
         SortedSet<String> metricsSet = new TreeSet<>(Arrays.asList(metrics));
         if (Metric.allMetrics().containsAll(metricsSet) == false) {
             metricsSet.removeAll(Metric.allMetrics());
             String plural = metricsSet.size() == 1 ? "" : "s";
             throw new IllegalStateException("Used illegal metric" + plural + ": " + metricsSet);
         }
-        this.nodesInfoRequest = NodesInfoRequestProto.NodesInfoReq.newBuilder().addAllRequestedMetrics(metricsSet).build();
-        requestedMetrics.addAll(metricsSet);
-        return this;
-    }
-
-    /**
-     * Remove metric
-     */
-    public ProtobufNodesInfoRequest removeMetric(String metric) {
-        if (Metric.allMetrics().contains(metric) == false) {
-            throw new IllegalStateException("Used an illegal metric: " + metric);
-        }
-        requestedMetrics.remove(metric);
+        this.nodesInfoRequest = NodesInfoRequestProto.NodesInfoReq.newBuilder().addAllRequestedMetrics(metricsSet).setTimeout(DEFAULT_TIMEOUT_SECS.toString()).build();
         return this;
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        super.writeTo(out);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeStringArray(requestedMetrics.toArray(new String[0]));
-    }
-
     public ProtobufNodesInfoRequest(byte[] data) throws IOException {
         super(data);
         this.nodesInfoRequest = NodesInfoRequestProto.NodesInfoReq.parseFrom(data);
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequestBuilder.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequestBuilder.java
deleted file mode 100644
index e751bfe25c47f..0000000000000
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequestBuilder.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.action.admin.cluster.node.info;
-
-import org.opensearch.action.support.nodes.ProtobufNodesOperationRequestBuilder;
-import org.opensearch.client.ProtobufOpenSearchClient;
-
-/**
- * Transport action for OpenSearch Node Information
-*
-* @opensearch.internal
-*/
-public class ProtobufNodesInfoRequestBuilder extends ProtobufNodesOperationRequestBuilder<
-    ProtobufNodesInfoRequest,
-    ProtobufNodesInfoResponse,
-    ProtobufNodesInfoRequestBuilder> {
-
-    public ProtobufNodesInfoRequestBuilder(ProtobufOpenSearchClient client, ProtobufNodesInfoAction action) {
-        super(client, action, new ProtobufNodesInfoRequest());
-    }
-
-    /**
-     * Clears all info flags.
-    */
-    public ProtobufNodesInfoRequestBuilder clear() {
-        request.clear();
-        return this;
-    }
-
-    /**
-     * Sets to return all the data.
-    */
-    public ProtobufNodesInfoRequestBuilder all() {
-        request.all();
-        return this;
-    }
-
-    /**
-     * Add a single metric to the request.
-    *
-    * @param metric Name of metric as a string.
-    * @return This, for request chaining.
-    */
-    public ProtobufNodesInfoRequestBuilder addMetric(String metric) {
-        request.addMetric(metric);
-        return this;
-    }
-
-    /**
-     * Add an array of metrics to the request.
-    *
-    * @param metrics Metric names as strings.
-    * @return This, for request chaining.
-    */
-    public ProtobufNodesInfoRequestBuilder addMetrics(String... metrics) {
-        request.addMetrics(metrics);
-        return this;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
index 8ea260493756e..923d33a656f27 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
@@ -34,31 +34,22 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
-import org.opensearch.action.ProtobufFailedNodeException;
+
+import org.opensearch.action.FailedNodeException;
 import org.opensearch.action.support.nodes.ProtobufBaseNodesResponse;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.common.Strings;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.xcontent.XContentFactory;
-import org.opensearch.core.xcontent.ToXContent.Params;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.http.ProtobufHttpInfo;
-import org.opensearch.ingest.ProtobufIngestInfo;
-import org.opensearch.monitor.jvm.JvmInfo;
-import org.opensearch.monitor.os.ProtobufOsInfo;
-import org.opensearch.monitor.process.ProtobufProcessInfo;
-import org.opensearch.search.aggregations.support.ProtobufAggregationInfo;
-import org.opensearch.search.pipeline.ProtobufSearchPipelineInfo;
 import org.opensearch.server.proto.NodesInfoResponseProto;
+import org.opensearch.server.proto.ClusterStateResponseProto;
 import org.opensearch.server.proto.NodesInfoProto.NodesInfo;
-import org.opensearch.threadpool.ProtobufThreadPoolInfo;
-import org.opensearch.transport.ProtobufTransportInfo;
-
 import java.io.IOException;
+import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -69,16 +60,12 @@
 *
 * @opensearch.internal
 */
-public class ProtobufNodesInfoResponse extends ProtobufBaseNodesResponse<ProtobufNodeInfo> implements ToXContentFragment {
+public class ProtobufNodesInfoResponse extends ProtobufBaseNodesResponse<ProtobufNodeInfo> implements ToXContentFragment, TryWriteable {
 
     private NodesInfoResponseProto.NodesInfoRes nodesInfoRes;
     private Map<String, NodesInfo> nodesMap = new HashMap<>();
 
-    public ProtobufNodesInfoResponse(CodedInputStream in) throws IOException {
-        super(in);
-    }
-
-    public ProtobufNodesInfoResponse(ClusterName clusterName, List<ProtobufNodeInfo> nodes, List<ProtobufFailedNodeException> failures) {
+    public ProtobufNodesInfoResponse(ClusterName clusterName, List<ProtobufNodeInfo> nodes, List<FailedNodeException> failures) {
         super(clusterName, nodes, failures);
         List<NodesInfo> nodesInfo = new ArrayList<>();
         for (ProtobufNodeInfo nodeInfo : nodes) {
@@ -91,18 +78,6 @@ public ProtobufNodesInfoResponse(ClusterName clusterName, List<ProtobufNodeInfo>
             .build();
     }
 
-    @Override
-    protected List<ProtobufNodeInfo> readNodesFrom(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        return protobufStreamInput.readList(ProtobufNodeInfo::new);
-    }
-
-    @Override
-    protected void writeNodesTo(CodedOutputStream out, List<ProtobufNodeInfo> nodes) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeCollection(nodes, (o, v) -> v.writeTo(o));
-    }
-
     @Override
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
         builder.startObject("nodes");
@@ -142,37 +117,6 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
                 builder.endObject();
             }
 
-            if (nodeInfo.getInfo(ProtobufOsInfo.class) != null) {
-                nodeInfo.getInfo(ProtobufOsInfo.class).toXContent(builder, params);
-            }
-            if (nodeInfo.getInfo(ProtobufProcessInfo.class) != null) {
-                nodeInfo.getInfo(ProtobufProcessInfo.class).toXContent(builder, params);
-            }
-            if (nodeInfo.getInfo(JvmInfo.class) != null) {
-                nodeInfo.getInfo(JvmInfo.class).toXContent(builder, params);
-            }
-            if (nodeInfo.getInfo(ProtobufThreadPoolInfo.class) != null) {
-                nodeInfo.getInfo(ProtobufThreadPoolInfo.class).toXContent(builder, params);
-            }
-            if (nodeInfo.getInfo(ProtobufTransportInfo.class) != null) {
-                nodeInfo.getInfo(ProtobufTransportInfo.class).toXContent(builder, params);
-            }
-            if (nodeInfo.getInfo(ProtobufHttpInfo.class) != null) {
-                nodeInfo.getInfo(ProtobufHttpInfo.class).toXContent(builder, params);
-            }
-            if (nodeInfo.getInfo(ProtobufPluginsAndModules.class) != null) {
-                nodeInfo.getInfo(ProtobufPluginsAndModules.class).toXContent(builder, params);
-            }
-            if (nodeInfo.getInfo(ProtobufIngestInfo.class) != null) {
-                nodeInfo.getInfo(ProtobufIngestInfo.class).toXContent(builder, params);
-            }
-            if (nodeInfo.getInfo(ProtobufAggregationInfo.class) != null) {
-                nodeInfo.getInfo(ProtobufAggregationInfo.class).toXContent(builder, params);
-            }
-            if (nodeInfo.getInfo(ProtobufSearchPipelineInfo.class) != null) {
-                nodeInfo.getInfo(ProtobufSearchPipelineInfo.class).toXContent(builder, params);
-            }
-
             builder.endObject();
         }
         builder.endObject();
@@ -199,4 +143,14 @@ public NodesInfoResponseProto.NodesInfoRes response() {
     public Map<String, NodesInfo> nodesMap() {
         return nodesMap;
     }
+
+    public ProtobufNodesInfoResponse(byte[] data) throws IOException {
+        super(data);
+        this.nodesInfoRes = NodesInfoResponseProto.NodesInfoRes.parseFrom(data);
+    }
+
+    @Override
+    public void writeTo(OutputStream out) throws IOException {
+        out.write(this.nodesInfoRes.toByteArray());
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufPluginsAndModules.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufPluginsAndModules.java
deleted file mode 100644
index 8c9e574170aaa..0000000000000
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufPluginsAndModules.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.action.admin.cluster.node.info;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.node.ProtobufReportingService;
-import org.opensearch.plugins.ProtobufPluginInfo;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-
-/**
- * Information about plugins and modules
-*
-* @opensearch.internal
-*/
-public class ProtobufPluginsAndModules implements ProtobufReportingService.ProtobufInfo {
-    private final List<ProtobufPluginInfo> plugins;
-    private final List<ProtobufPluginInfo> modules;
-
-    public ProtobufPluginsAndModules(List<ProtobufPluginInfo> plugins, List<ProtobufPluginInfo> modules) {
-        this.plugins = Collections.unmodifiableList(plugins);
-        this.modules = Collections.unmodifiableList(modules);
-    }
-
-    public ProtobufPluginsAndModules(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        this.plugins = Collections.unmodifiableList(protobufStreamInput.readList(ProtobufPluginInfo::new));
-        this.modules = Collections.unmodifiableList(protobufStreamInput.readList(ProtobufPluginInfo::new));
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeCollection(plugins, (o, v) -> v.writeTo(o));
-        protobufStreamOutput.writeCollection(modules, (o, v) -> v.writeTo(o));
-    }
-
-    /**
-     * Returns an ordered list based on plugins name
-    */
-    public List<ProtobufPluginInfo> getPluginInfos() {
-        List<ProtobufPluginInfo> plugins = new ArrayList<>(this.plugins);
-        Collections.sort(plugins, Comparator.comparing(ProtobufPluginInfo::getName));
-        return plugins;
-    }
-
-    /**
-     * Returns an ordered list based on modules name
-    */
-    public List<ProtobufPluginInfo> getModuleInfos() {
-        List<ProtobufPluginInfo> modules = new ArrayList<>(this.modules);
-        Collections.sort(modules, Comparator.comparing(ProtobufPluginInfo::getName));
-        return modules;
-    }
-
-    public void addPlugin(ProtobufPluginInfo info) {
-        plugins.add(info);
-    }
-
-    public void addModule(ProtobufPluginInfo info) {
-        modules.add(info);
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startArray("plugins");
-        for (ProtobufPluginInfo pluginInfo : getPluginInfos()) {
-            pluginInfo.toXContent(builder, params);
-        }
-        builder.endArray();
-        // TODO: not ideal, make a better api for this (e.g. with jar metadata, and so on)
-        builder.startArray("modules");
-        for (ProtobufPluginInfo moduleInfo : getModuleInfos()) {
-            moduleInfo.toXContent(builder, params);
-        }
-        builder.endArray();
-
-        return builder;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
index 805aff9b5115f..62525c3326b07 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
@@ -10,7 +10,8 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
-import org.opensearch.action.ProtobufFailedNodeException;
+
+import org.opensearch.action.FailedNodeException;
 import org.opensearch.action.support.ProtobufActionFilters;
 import org.opensearch.action.support.nodes.ProtobufTransportNodesAction;
 import org.opensearch.cluster.ClusterName;
@@ -66,7 +67,7 @@ public ProtobufTransportNodesInfoAction(
     protected ProtobufNodesInfoResponse newResponse(
         ProtobufNodesInfoRequest nodesInfoRequest,
         List<ProtobufNodeInfo> responses,
-        List<ProtobufFailedNodeException> failures
+        List<FailedNodeException> failures
     ) {
         return new ProtobufNodesInfoResponse(new ClusterName(clusterService.getClusterName().value()), responses, failures);
     }
@@ -76,11 +77,6 @@ protected NodeInfoRequest newNodeRequest(ProtobufNodesInfoRequest request) {
         return new NodeInfoRequest(request);
     }
 
-    @Override
-    protected ProtobufNodeInfo newNodeResponse(CodedInputStream in) throws IOException {
-        return new ProtobufNodeInfo(in);
-    }
-
     @Override
     protected ProtobufNodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
         ProtobufNodesInfoRequest request = nodeRequest.request;
@@ -111,11 +107,6 @@ public static class NodeInfoRequest extends TransportRequest implements TryWrite
 
         ProtobufNodesInfoRequest request;
 
-        public NodeInfoRequest(CodedInputStream in) throws IOException {
-            super(in);
-            request = new ProtobufNodesInfoRequest(in);
-        }
-
         public NodeInfoRequest(byte[] data) throws IOException {
             request = new ProtobufNodesInfoRequest(data);
         }
@@ -124,12 +115,6 @@ public NodeInfoRequest(ProtobufNodesInfoRequest request) {
             this.request = request;
         }
 
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            super.writeTo(out);
-            request.writeTo(out);
-        }
-
         public ProtobufNodesInfoRequest request() {
             return request;
         }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
index b1a79ed9ef3e0..4a0fd77285979 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
@@ -16,30 +16,26 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.common.Nullable;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.discovery.ProtobufDiscoveryStats;
-import org.opensearch.http.ProtobufHttpStats;
-import org.opensearch.indices.ProtobufNodeIndicesStats;
-import org.opensearch.indices.breaker.ProtobufAllCircuitBreakerStats;
-import org.opensearch.ingest.ProtobufIngestStats;
-import org.opensearch.monitor.fs.ProtobufFsInfo;
-import org.opensearch.monitor.jvm.ProtobufJvmStats;
-import org.opensearch.monitor.os.ProtobufOsStats;
-import org.opensearch.monitor.process.ProtobufProcessStats;
-import org.opensearch.node.ProtobufAdaptiveSelectionStats;
-import org.opensearch.script.ProtobufScriptStats;
+import org.opensearch.discovery.DiscoveryStats;
+import org.opensearch.http.HttpStats;
+import org.opensearch.indices.NodeIndicesStats;
+import org.opensearch.indices.breaker.AllCircuitBreakerStats;
+import org.opensearch.ingest.IngestStats;
+import org.opensearch.monitor.fs.FsInfo;
+import org.opensearch.monitor.jvm.JvmStats;
+import org.opensearch.monitor.os.OsStats;
+import org.opensearch.monitor.process.ProcessStats;
+import org.opensearch.node.AdaptiveSelectionStats;
+import org.opensearch.script.ScriptStats;
 import org.opensearch.server.proto.NodesStatsProto;
-import org.opensearch.server.proto.NodesStatsProto.NodesStats;
-import org.opensearch.threadpool.ProtobufThreadPoolStats;
-import org.opensearch.transport.ProtobufTransportStats;
+import org.opensearch.threadpool.ThreadPoolStats;
+import org.opensearch.transport.TransportStats;
 
 import java.io.IOException;
 import java.io.OutputStream;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
@@ -54,68 +50,8 @@ public class ProtobufNodeStats extends ProtobufBaseNodeResponse implements ToXCo
 
     private long timestamp;
 
-    @Nullable
-    private ProtobufNodeIndicesStats indices;
-
-    @Nullable
-    private ProtobufOsStats os;
-
-    @Nullable
-    private ProtobufProcessStats process;
-
-    @Nullable
-    private ProtobufJvmStats jvm;
-
-    @Nullable
-    private ProtobufThreadPoolStats threadPool;
-
-    @Nullable
-    private ProtobufFsInfo fs;
-
-    @Nullable
-    private ProtobufTransportStats transport;
-
-    @Nullable
-    private ProtobufHttpStats http;
-
-    @Nullable
-    private ProtobufAllCircuitBreakerStats breaker;
-
-    @Nullable
-    private ProtobufScriptStats scriptStats;
-
-    @Nullable
-    private ProtobufDiscoveryStats discoveryStats;
-
-    @Nullable
-    private ProtobufIngestStats ingestStats;
-
-    @Nullable
-    private ProtobufAdaptiveSelectionStats adaptiveSelectionStats;
-
     private NodesStatsProto.NodesStats nodesStatsResponse;
 
-    public ProtobufNodeStats(CodedInputStream in) throws IOException {
-        super(in);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        timestamp = in.readInt64();
-        if (in.readBool()) {
-            indices = new ProtobufNodeIndicesStats(in);
-        }
-        os = protobufStreamInput.readOptionalWriteable(ProtobufOsStats::new);
-        process = protobufStreamInput.readOptionalWriteable(ProtobufProcessStats::new);
-        jvm = protobufStreamInput.readOptionalWriteable(ProtobufJvmStats::new);
-        threadPool = protobufStreamInput.readOptionalWriteable(ProtobufThreadPoolStats::new);
-        fs = protobufStreamInput.readOptionalWriteable(ProtobufFsInfo::new);
-        transport = protobufStreamInput.readOptionalWriteable(ProtobufTransportStats::new);
-        http = protobufStreamInput.readOptionalWriteable(ProtobufHttpStats::new);
-        breaker = protobufStreamInput.readOptionalWriteable(ProtobufAllCircuitBreakerStats::new);
-        scriptStats = protobufStreamInput.readOptionalWriteable(ProtobufScriptStats::new);
-        discoveryStats = protobufStreamInput.readOptionalWriteable(ProtobufDiscoveryStats::new);
-        ingestStats = protobufStreamInput.readOptionalWriteable(ProtobufIngestStats::new);
-        adaptiveSelectionStats = protobufStreamInput.readOptionalWriteable(ProtobufAdaptiveSelectionStats::new);
-    }
-
     public ProtobufNodeStats(byte[] data) throws InvalidProtocolBufferException {
         super(data);
         this.nodesStatsResponse = NodesStatsProto.NodesStats.parseFrom(data);
@@ -124,35 +60,22 @@ public ProtobufNodeStats(byte[] data) throws InvalidProtocolBufferException {
     public ProtobufNodeStats(
         DiscoveryNode node,
         long timestamp,
-        @Nullable ProtobufNodeIndicesStats indices,
-        @Nullable ProtobufOsStats os,
-        @Nullable ProtobufProcessStats process,
-        @Nullable ProtobufJvmStats jvm,
-        @Nullable ProtobufThreadPoolStats threadPool,
-        @Nullable ProtobufFsInfo fs,
-        @Nullable ProtobufTransportStats transport,
-        @Nullable ProtobufHttpStats http,
-        @Nullable ProtobufAllCircuitBreakerStats breaker,
-        @Nullable ProtobufScriptStats scriptStats,
-        @Nullable ProtobufDiscoveryStats discoveryStats,
-        @Nullable ProtobufIngestStats ingestStats,
-        @Nullable ProtobufAdaptiveSelectionStats adaptiveSelectionStats
+        @Nullable NodeIndicesStats indices,
+        @Nullable OsStats os,
+        @Nullable ProcessStats process,
+        @Nullable JvmStats jvm,
+        @Nullable ThreadPoolStats threadPool,
+        @Nullable FsInfo fs,
+        @Nullable TransportStats transport,
+        @Nullable HttpStats http,
+        @Nullable AllCircuitBreakerStats breaker,
+        @Nullable ScriptStats scriptStats,
+        @Nullable DiscoveryStats discoveryStats,
+        @Nullable IngestStats ingestStats,
+        @Nullable AdaptiveSelectionStats adaptiveSelectionStats
     ) {
         super(node);
         this.timestamp = timestamp;
-        this.indices = indices;
-        this.os = os;
-        this.process = process;
-        this.jvm = jvm;
-        this.threadPool = threadPool;
-        this.fs = fs;
-        this.transport = transport;
-        this.http = http;
-        this.breaker = breaker;
-        this.scriptStats = scriptStats;
-        this.discoveryStats = discoveryStats;
-        this.ingestStats = ingestStats;
-        this.adaptiveSelectionStats = adaptiveSelectionStats;
         NodesStatsProto.NodesStats.CompletionStats completionStats = NodesStatsProto.NodesStats.CompletionStats.newBuilder()
             .setSize(indices.getCompletion().getSizeInBytes())
             .build();
@@ -284,114 +207,6 @@ public String getHostname() {
         return getNode().getHostName();
     }
 
-    /**
-     * Indices level stats.
-    */
-    @Nullable
-    public ProtobufNodeIndicesStats getIndices() {
-        return this.indices;
-    }
-
-    /**
-     * Operating System level statistics.
-    */
-    @Nullable
-    public ProtobufOsStats getOs() {
-        return this.os;
-    }
-
-    /**
-     * Process level statistics.
-    */
-    @Nullable
-    public ProtobufProcessStats getProcess() {
-        return process;
-    }
-
-    /**
-     * JVM level statistics.
-    */
-    @Nullable
-    public ProtobufJvmStats getJvm() {
-        return jvm;
-    }
-
-    /**
-     * Thread Pool level statistics.
-    */
-    @Nullable
-    public ProtobufThreadPoolStats getThreadPool() {
-        return this.threadPool;
-    }
-
-    /**
-     * File system level stats.
-    */
-    @Nullable
-    public ProtobufFsInfo getFs() {
-        return fs;
-    }
-
-    @Nullable
-    public ProtobufTransportStats getTransport() {
-        return this.transport;
-    }
-
-    @Nullable
-    public ProtobufHttpStats getHttp() {
-        return this.http;
-    }
-
-    @Nullable
-    public ProtobufAllCircuitBreakerStats getBreaker() {
-        return this.breaker;
-    }
-
-    @Nullable
-    public ProtobufScriptStats getScriptStats() {
-        return this.scriptStats;
-    }
-
-    @Nullable
-    public ProtobufDiscoveryStats getDiscoveryStats() {
-        return this.discoveryStats;
-    }
-
-    @Nullable
-    public ProtobufIngestStats getIngestStats() {
-        return ingestStats;
-    }
-
-    @Nullable
-    public ProtobufAdaptiveSelectionStats getAdaptiveSelectionStats() {
-        return adaptiveSelectionStats;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        super.writeTo(out);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeInt64NoTag(timestamp);
-        if (indices == null) {
-            out.writeBoolNoTag(false);
-        } else {
-            out.writeBoolNoTag(true);
-            indices.writeTo(out);
-        }
-        protobufStreamOutput.writeOptionalWriteable(os);
-        protobufStreamOutput.writeOptionalWriteable(process);
-        protobufStreamOutput.writeOptionalWriteable(jvm);
-        protobufStreamOutput.writeOptionalWriteable(threadPool);
-        protobufStreamOutput.writeOptionalWriteable(fs);
-        protobufStreamOutput.writeOptionalWriteable(transport);
-        protobufStreamOutput.writeOptionalWriteable(http);
-        protobufStreamOutput.writeOptionalWriteable(breaker);
-        protobufStreamOutput.writeOptionalWriteable(scriptStats);
-        protobufStreamOutput.writeOptionalWriteable(discoveryStats);
-        protobufStreamOutput.writeOptionalWriteable(ingestStats);
-        protobufStreamOutput.writeOptionalWriteable(adaptiveSelectionStats);
-    }
-
     @Override
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
 
@@ -414,46 +229,6 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
             builder.endObject();
         }
 
-        if (getIndices() != null) {
-            getIndices().toXContent(builder, params);
-        }
-        if (getOs() != null) {
-            getOs().toXContent(builder, params);
-        }
-        if (getProcess() != null) {
-            getProcess().toXContent(builder, params);
-        }
-        if (getJvm() != null) {
-            getJvm().toXContent(builder, params);
-        }
-        if (getThreadPool() != null) {
-            getThreadPool().toXContent(builder, params);
-        }
-        if (getFs() != null) {
-            getFs().toXContent(builder, params);
-        }
-        if (getTransport() != null) {
-            getTransport().toXContent(builder, params);
-        }
-        if (getHttp() != null) {
-            getHttp().toXContent(builder, params);
-        }
-        if (getBreaker() != null) {
-            getBreaker().toXContent(builder, params);
-        }
-        if (getScriptStats() != null) {
-            getScriptStats().toXContent(builder, params);
-        }
-        if (getDiscoveryStats() != null) {
-            getDiscoveryStats().toXContent(builder, params);
-        }
-        if (getIngestStats() != null) {
-            getIngestStats().toXContent(builder, params);
-        }
-        if (getAdaptiveSelectionStats() != null) {
-            getAdaptiveSelectionStats().toXContent(builder, params);
-        }
-
         return builder;
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
index 37cc281463568..ff83416d94c3b 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
@@ -12,8 +12,6 @@
 import com.google.protobuf.CodedOutputStream;
 import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
 import org.opensearch.action.support.nodes.ProtobufBaseNodesRequest;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.server.proto.NodesStatsRequestProto.NodesStatsReq;
 import org.opensearch.server.proto.NodesStatsRequestProto;
@@ -42,15 +40,6 @@ public ProtobufNodesStatsRequest() {
         super((String[]) null);
     }
 
-    public ProtobufNodesStatsRequest(CodedInputStream in) throws IOException {
-        super(in);
-
-        indices = new CommonStatsFlags(in);
-        requestedMetrics.clear();
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        requestedMetrics.addAll(protobufStreamInput.readList(CodedInputStream::readString));
-    }
-
     /**
      * Get stats from nodes based on the nodes ids specified. If none are passed, stats
     * for all nodes will be returned.
@@ -155,14 +144,6 @@ public ProtobufNodesStatsRequest removeMetric(String metric) {
         return this;
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        super.writeTo(out);
-        indices.writeTo(out);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeStringArray(requestedMetrics.toArray(new String[0]));
-    }
-
     public ProtobufNodesStatsRequest(byte[] data) throws IOException {
         super(data);
         this.nodesStatsRequest = NodesStatsRequestProto.NodesStatsReq.parseFrom(data);
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequestBuilder.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequestBuilder.java
deleted file mode 100644
index 659a4aa7da185..0000000000000
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequestBuilder.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.action.admin.cluster.node.stats;
-
-import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
-import org.opensearch.action.support.nodes.ProtobufNodesOperationRequestBuilder;
-import org.opensearch.client.ProtobufOpenSearchClient;
-
-/**
- * Transport builder for obtaining OpenSearch Node Stats
-*
-* @opensearch.internal
-*/
-public class ProtobufNodesStatsRequestBuilder extends ProtobufNodesOperationRequestBuilder<
-    ProtobufNodesStatsRequest,
-    ProtobufNodesStatsResponse,
-    ProtobufNodesStatsRequestBuilder> {
-
-    public ProtobufNodesStatsRequestBuilder(ProtobufOpenSearchClient client, ProtobufNodesStatsAction action) {
-        super(client, action, new ProtobufNodesStatsRequest());
-    }
-
-    /**
-     * Sets all the request flags.
-    */
-    public ProtobufNodesStatsRequestBuilder all() {
-        request.all();
-        return this;
-    }
-
-    /**
-     * Clears all stats flags.
-    */
-    public ProtobufNodesStatsRequestBuilder clear() {
-        request.clear();
-        return this;
-    }
-
-    /**
-     * Add a single metric to the request.
-    *
-    * @param metric Name of metric as a string.
-    * @return This, for request chaining.
-    */
-    public ProtobufNodesStatsRequestBuilder addMetric(String metric) {
-        request.addMetric(metric);
-        return this;
-    }
-
-    /**
-     * Add an array of metrics to the request.
-    *
-    * @param metrics Metric names as strings.
-    * @return This, for request chaining.
-    */
-    public ProtobufNodesStatsRequestBuilder addMetrics(String... metrics) {
-        request.addMetrics(metrics);
-        return this;
-    }
-
-    /**
-     * Should the node indices stats be returned.
-    */
-    public ProtobufNodesStatsRequestBuilder setIndices(boolean indices) {
-        request.indices(indices);
-        return this;
-    }
-
-    /**
-     * Should the node indices stats be returned.
-    */
-    public ProtobufNodesStatsRequestBuilder setIndices(CommonStatsFlags indices) {
-        request.indices(indices);
-        return this;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
index e3218379c8e18..ca4d8270d6115 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
@@ -10,19 +10,21 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
-import org.opensearch.action.ProtobufFailedNodeException;
+
+import org.opensearch.action.FailedNodeException;
 import org.opensearch.action.support.nodes.ProtobufBaseNodesResponse;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.common.Strings;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
+import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.server.proto.NodesStatsResponseProto;
+import org.opensearch.server.proto.NodesInfoResponseProto;
 import org.opensearch.server.proto.NodesStatsProto.NodesStats;
 import org.opensearch.common.xcontent.XContentFactory;
 
 import java.io.IOException;
+import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -33,16 +35,17 @@
 *
 * @opensearch.internal
 */
-public class ProtobufNodesStatsResponse extends ProtobufBaseNodesResponse<ProtobufNodeStats> implements ToXContentFragment {
+public class ProtobufNodesStatsResponse extends ProtobufBaseNodesResponse<ProtobufNodeStats> implements ToXContentFragment, TryWriteable {
 
     private NodesStatsResponseProto.NodesStatsRes nodesStatsRes;
     private Map<String, NodesStats> nodesMap = new HashMap<>();
 
-    public ProtobufNodesStatsResponse(CodedInputStream in) throws IOException {
-        super(in);
+    public ProtobufNodesStatsResponse(byte[] data) throws IOException {
+        super(data);
+        this.nodesStatsRes = NodesStatsResponseProto.NodesStatsRes.parseFrom(data);
     }
 
-    public ProtobufNodesStatsResponse(ClusterName clusterName, List<ProtobufNodeStats> nodes, List<ProtobufFailedNodeException> failures) {
+    public ProtobufNodesStatsResponse(ClusterName clusterName, List<ProtobufNodeStats> nodes, List<FailedNodeException> failures) {
         super(clusterName, nodes, failures);
         List<NodesStats> nodesStats = new ArrayList<>();
         for (ProtobufNodeStats nodeStats : nodes) {
@@ -55,18 +58,6 @@ public ProtobufNodesStatsResponse(ClusterName clusterName, List<ProtobufNodeStat
             .build();
     }
 
-    @Override
-    protected List<ProtobufNodeStats> readNodesFrom(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        return protobufStreamInput.readList(ProtobufNodeStats::new);
-    }
-
-    @Override
-    protected void writeNodesTo(CodedOutputStream out, List<ProtobufNodeStats> nodes) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeCollection(nodes, (o, v) -> v.writeTo(o));
-    }
-
     @Override
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
         builder.startObject("nodes");
@@ -102,4 +93,9 @@ public NodesStatsResponseProto.NodesStatsRes response() {
     public Map<String, NodesStats> nodesMap() {
         return nodesMap;
     }
+
+    @Override
+    public void writeTo(OutputStream out) throws IOException {
+        out.write(this.nodesStatsRes.toByteArray());
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
index 55c827bcb5c37..0b84839346635 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
@@ -10,7 +10,8 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
-import org.opensearch.action.ProtobufFailedNodeException;
+
+import org.opensearch.action.FailedNodeException;
 import org.opensearch.action.admin.cluster.node.info.ProtobufNodeInfo;
 import org.opensearch.action.support.ProtobufActionFilters;
 import org.opensearch.action.support.nodes.ProtobufTransportNodesAction;
@@ -67,7 +68,7 @@ public ProtobufTransportNodesStatsAction(
     protected ProtobufNodesStatsResponse newResponse(
         ProtobufNodesStatsRequest request,
         List<ProtobufNodeStats> responses,
-        List<ProtobufFailedNodeException> failures
+        List<FailedNodeException> failures
     ) {
         return new ProtobufNodesStatsResponse(new ClusterName(clusterService.getClusterName().value()), responses, failures);
     }
@@ -77,11 +78,6 @@ protected NodeStatsRequest newNodeRequest(ProtobufNodesStatsRequest request) {
         return new NodeStatsRequest(request);
     }
 
-    @Override
-    protected ProtobufNodeStats newNodeResponse(CodedInputStream in) throws IOException {
-        return new ProtobufNodeStats(in);
-    }
-
     @Override
     protected ProtobufNodeStats nodeOperation(NodeStatsRequest nodeStatsRequest) {
         ProtobufNodesStatsRequest request = nodeStatsRequest.request;
@@ -120,11 +116,6 @@ public static class NodeStatsRequest extends TransportRequest implements TryWrit
 
         ProtobufNodesStatsRequest request;
 
-        public NodeStatsRequest(CodedInputStream in) throws IOException {
-            super(in);
-            request = new ProtobufNodesStatsRequest(in);
-        }
-
         public NodeStatsRequest(byte[] data) throws IOException {
             request = new ProtobufNodesStatsRequest(data);
         }
@@ -133,12 +124,6 @@ public NodeStatsRequest(ProtobufNodesStatsRequest request) {
             this.request = request;
         }
 
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            super.writeTo(out);
-            request.writeTo(out);
-        }
-
         public ProtobufNodesStatsRequest request() {
             return request;
         }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
index 5977162c4a6c2..c915c77c54ccb 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
@@ -57,15 +57,6 @@ public ProtobufClusterStateRequest(boolean routingTable, boolean nodes, boolean
                                         .build();               
     }
     
-    public ProtobufClusterStateRequest(CodedInputStream in) throws IOException {
-        super(in);
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        super.writeTo(out);
-    }
-
     @Override
     public ActionRequestValidationException validate() {
         return null;
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
index 61df01b94aedc..714e7e5fc4427 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
@@ -13,22 +13,13 @@
 
 package org.opensearch.action.admin.cluster.state;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
-import org.opensearch.Version;
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.ClusterName;
-import org.opensearch.cluster.ClusterState;
 import org.opensearch.common.collect.ImmutableOpenMap;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.TryWriteable;
-import org.opensearch.server.proto.ClusterStateRequestProto;
 import org.opensearch.server.proto.ClusterStateResponseProto;
 import org.opensearch.server.proto.ClusterStateResponseProto.ClusterStateRes;
 
@@ -47,26 +38,9 @@
 */
 public class ProtobufClusterStateResponse extends ProtobufActionResponse implements TryWriteable {
 
-    private ClusterName clusterName;
-    private ClusterState clusterState;
-    private boolean waitForTimedOut = false;
     private ClusterStateResponseProto.ClusterStateRes clusterStateRes;
 
-    public ProtobufClusterStateResponse(CodedInputStream in) throws IOException {
-        super(in);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        String cluster_name = in.readString();
-        clusterName = new ClusterName(cluster_name);
-        clusterState = protobufStreamInput.readOptionalWriteable(innerIn -> ClusterState.readFrom(innerIn, null));
-        waitForTimedOut = in.readBool();
-    }
-
     public ProtobufClusterStateResponse(ClusterName clusterName, ClusterState clusterState, boolean waitForTimedOut) {
-        this.clusterName = clusterName;
-        this.clusterState = clusterState;
-        this.waitForTimedOut = waitForTimedOut;
-        //convert clusterState to ClusterStateResponseProto.ClusterStateRes.ClusterState
-        
         ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Builder discoveryNodesBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.newBuilder();
         DiscoveryNodes nodes = clusterState.getNodes();
         ImmutableOpenMap<String, DiscoveryNode> allNodes = nodes.getNodes();
@@ -109,40 +83,9 @@ private Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.Disco
         return convertedNodes;
     }
 
-    /**
-     * The requested cluster state.  Only the parts of the cluster state that were
-    * requested are included in the returned {@link ClusterState} instance.
-    */
-    public ClusterState getState() {
-        return this.clusterState;
-    }
-
-    /**
-     * The name of the cluster.
-    */
-    public ClusterName getClusterName() {
-        return this.clusterName;
-    }
-
-    /**
-     * Returns whether the request timed out waiting for a cluster state with a metadata version equal or
-    * higher than the specified metadata.
-    */
-    public boolean isWaitForTimedOut() {
-        return waitForTimedOut;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        clusterName.writeTo(out);
-        protobufStreamOutput.writeOptionalWriteable(clusterState);
-        out.writeBoolNoTag(waitForTimedOut);
-    }
-
     @Override
     public String toString() {
-        return "ProtobufClusterStateResponse{" + "clusterState=" + clusterState + '}';
+        return "ProtobufClusterStateResponse{" + "clusterState=" + this.clusterStateRes.getClusterState() + '}';
     }
 
     public ClusterStateRes response() {
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
index ccac09b71d6fd..ec9698d755956 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
@@ -79,11 +79,6 @@ protected String executor() {
         return ThreadPool.Names.SAME;
     }
 
-    @Override
-    protected ProtobufClusterStateResponse read(CodedInputStream in) throws IOException {
-        return new ProtobufClusterStateResponse(in);
-    }
-
     @Override
     protected ClusterBlockException checkBlock(ProtobufClusterStateRequest request, ClusterState state) {
         // cluster state calls are done also on a fully blocked cluster to figure out what is going
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/datastream/GetDataStreamAction.java b/server/src/main/java/org/opensearch/action/admin/indices/datastream/GetDataStreamAction.java
index bab12921aa42e..6516a099446f9 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/datastream/GetDataStreamAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/datastream/GetDataStreamAction.java
@@ -168,7 +168,7 @@ public static class Response extends ActionResponse implements ToXContentObject
          *
          * @opensearch.internal
          */
-        public static class DataStreamInfo extends AbstractDiffable<DataStreamInfo, DataStreamInfo> implements ToXContentObject {
+        public static class DataStreamInfo extends AbstractDiffable<DataStreamInfo> implements ToXContentObject {
 
             public static final ParseField STATUS_FIELD = new ParseField("status");
             public static final ParseField INDEX_TEMPLATE_FIELD = new ParseField("template");
@@ -238,11 +238,6 @@ public int hashCode() {
                 return Objects.hash(dataStream, dataStreamStatus, indexTemplate);
             }
 
-            @Override
-            public void writeTo(CodedOutputStream out) throws IOException {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
-            }
         }
 
         private final List<DataStreamInfo> dataStreams;
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverInfo.java b/server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverInfo.java
index b21fbdbc29d99..927421bf6ff31 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverInfo.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverInfo.java
@@ -56,7 +56,7 @@
  *
  * @opensearch.internal
  */
-public class RolloverInfo extends AbstractDiffable<RolloverInfo, RolloverInfo> implements Writeable, ToXContentFragment {
+public class RolloverInfo extends AbstractDiffable<RolloverInfo> implements Writeable, ToXContentFragment {
 
     public static final ParseField CONDITION_FIELD = new ParseField("met_conditions");
     public static final ParseField TIME_FIELD = new ParseField("time");
@@ -154,9 +154,4 @@ public String toString() {
         return Strings.toString(XContentType.JSON, this);
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
-    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/stats/CommonStatsFlags.java b/server/src/main/java/org/opensearch/action/admin/indices/stats/CommonStatsFlags.java
index 75e660b4b9e3c..aeb3b4b5e1692 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/stats/CommonStatsFlags.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/stats/CommonStatsFlags.java
@@ -38,12 +38,6 @@
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.core.common.Strings;
 import org.opensearch.common.Strings;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 
 import java.io.IOException;
 import java.util.Collections;
@@ -54,7 +48,7 @@
  *
  * @opensearch.internal
  */
-public class CommonStatsFlags implements Writeable, ProtobufWriteable, Cloneable {
+public class CommonStatsFlags implements Writeable, Cloneable {
 
     public static final CommonStatsFlags ALL = new CommonStatsFlags().all();
     public static final CommonStatsFlags NONE = new CommonStatsFlags().clear();
@@ -118,48 +112,6 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeBoolean(includeOnlyTopIndexingPressureMetrics);
     }
 
-    public CommonStatsFlags(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        final long longFlags = in.readInt64();
-        flags.clear();
-        for (Flag flag : Flag.values()) {
-            if ((longFlags & (1 << flag.getIndex())) != 0) {
-                flags.add(flag);
-            }
-        }
-        if (protobufStreamInput.getVersion().before(Version.V_2_0_0)) {
-            protobufStreamInput.readStringArray();
-        }
-        groups = protobufStreamInput.readStringArray();
-        fieldDataFields = protobufStreamInput.readStringArray();
-        completionDataFields = protobufStreamInput.readStringArray();
-        includeSegmentFileSizes = in.readBool();
-        includeUnloadedSegments = in.readBool();
-        includeAllShardIndexingPressureTrackers = in.readBool();
-        includeOnlyTopIndexingPressureMetrics = in.readBool();
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        long longFlags = 0;
-        for (Flag flag : flags) {
-            longFlags |= (1 << flag.getIndex());
-        }
-        out.writeInt64NoTag(longFlags);
-
-        if (protobufStreamOutput.getVersion().before(Version.V_2_0_0)) {
-            protobufStreamOutput.writeStringArrayNullable(Strings.EMPTY_ARRAY);
-        }
-        protobufStreamOutput.writeStringArrayNullable(groups);
-        protobufStreamOutput.writeStringArrayNullable(fieldDataFields);
-        protobufStreamOutput.writeStringArrayNullable(completionDataFields);
-        out.writeBoolNoTag(includeSegmentFileSizes);
-        out.writeBoolNoTag(includeUnloadedSegments);
-        out.writeBoolNoTag(includeAllShardIndexingPressureTrackers);
-        out.writeBoolNoTag(includeOnlyTopIndexingPressureMetrics);
-    }
-
     /**
      * Sets all flags to return all stats.
      */
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStats.java b/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStats.java
deleted file mode 100644
index de1331c7f21cb..0000000000000
--- a/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStats.java
+++ /dev/null
@@ -1,526 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.action.admin.indices.stats;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
-import org.apache.lucene.store.AlreadyClosedException;
-import org.opensearch.common.Nullable;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.core.xcontent.ToXContent;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.index.cache.query.ProtobufQueryCacheStats;
-import org.opensearch.index.cache.request.ProtobufRequestCacheStats;
-import org.opensearch.index.engine.ProtobufSegmentsStats;
-import org.opensearch.index.fielddata.ProtobufFieldDataStats;
-import org.opensearch.index.flush.ProtobufFlushStats;
-import org.opensearch.index.get.ProtobufGetStats;
-import org.opensearch.index.merge.ProtobufMergeStats;
-import org.opensearch.index.recovery.ProtobufRecoveryStats;
-import org.opensearch.index.refresh.ProtobufRefreshStats;
-import org.opensearch.index.search.stats.ProtobufSearchStats;
-import org.opensearch.index.shard.IndexShard;
-import org.opensearch.index.shard.ProtobufDocsStats;
-import org.opensearch.index.shard.ProtobufIndexingStats;
-import org.opensearch.index.store.ProtobufStoreStats;
-import org.opensearch.index.translog.ProtobufTranslogStats;
-import org.opensearch.index.warmer.ProtobufWarmerStats;
-import org.opensearch.indices.IndicesQueryCache;
-import org.opensearch.search.suggest.completion.ProtobufCompletionStats;
-
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.Objects;
-import java.util.stream.Stream;
-
-/**
- * Common Stats for OpenSearch
-*
-* @opensearch.internal
-*/
-public class ProtobufCommonStats implements ProtobufWriteable, ToXContentFragment {
-
-    @Nullable
-    public ProtobufDocsStats docs;
-
-    @Nullable
-    public ProtobufStoreStats store;
-
-    @Nullable
-    public ProtobufIndexingStats indexing;
-
-    @Nullable
-    public ProtobufGetStats get;
-
-    @Nullable
-    public ProtobufSearchStats search;
-
-    @Nullable
-    public ProtobufMergeStats merge;
-
-    @Nullable
-    public ProtobufRefreshStats refresh;
-
-    @Nullable
-    public ProtobufFlushStats flush;
-
-    @Nullable
-    public ProtobufWarmerStats warmer;
-
-    @Nullable
-    public ProtobufQueryCacheStats queryCache;
-
-    @Nullable
-    public ProtobufFieldDataStats fieldData;
-
-    @Nullable
-    public ProtobufCompletionStats completion;
-
-    @Nullable
-    public ProtobufSegmentsStats segments;
-
-    @Nullable
-    public ProtobufTranslogStats translog;
-
-    @Nullable
-    public ProtobufRequestCacheStats requestCache;
-
-    @Nullable
-    public ProtobufRecoveryStats recoveryStats;
-
-    public ProtobufCommonStats() {
-        this(CommonStatsFlags.NONE);
-    }
-
-    public ProtobufCommonStats(CommonStatsFlags flags) {
-        CommonStatsFlags.Flag[] setFlags = flags.getFlags();
-
-        for (CommonStatsFlags.Flag flag : setFlags) {
-            switch (flag) {
-                case Docs:
-                    docs = new ProtobufDocsStats();
-                    break;
-                case Store:
-                    store = new ProtobufStoreStats();
-                    break;
-                case Indexing:
-                    indexing = new ProtobufIndexingStats();
-                    break;
-                case Get:
-                    get = new ProtobufGetStats();
-                    break;
-                case Search:
-                    search = new ProtobufSearchStats();
-                    break;
-                case Merge:
-                    merge = new ProtobufMergeStats();
-                    break;
-                case Refresh:
-                    refresh = new ProtobufRefreshStats();
-                    break;
-                case Flush:
-                    flush = new ProtobufFlushStats();
-                    break;
-                case Warmer:
-                    warmer = new ProtobufWarmerStats();
-                    break;
-                case QueryCache:
-                    queryCache = new ProtobufQueryCacheStats();
-                    break;
-                case FieldData:
-                    fieldData = new ProtobufFieldDataStats();
-                    break;
-                case Completion:
-                    completion = new ProtobufCompletionStats();
-                    break;
-                case Segments:
-                    segments = new ProtobufSegmentsStats();
-                    break;
-                case Translog:
-                    translog = new ProtobufTranslogStats();
-                    break;
-                case RequestCache:
-                    requestCache = new ProtobufRequestCacheStats();
-                    break;
-                case Recovery:
-                    recoveryStats = new ProtobufRecoveryStats();
-                    break;
-                default:
-                    throw new IllegalStateException("Unknown Flag: " + flag);
-            }
-        }
-    }
-
-    public ProtobufCommonStats(IndicesQueryCache indicesQueryCache, IndexShard indexShard, CommonStatsFlags flags) {
-        CommonStatsFlags.Flag[] setFlags = flags.getFlags();
-        for (CommonStatsFlags.Flag flag : setFlags) {
-            try {
-                switch (flag) {
-                    case Docs:
-                        docs = indexShard.protobufDocsStats();
-                        break;
-                    case Store:
-                        store = indexShard.protobufStoreStats();
-                        break;
-                    case Indexing:
-                        indexing = indexShard.protobufIndexingStats();
-                        break;
-                    case Get:
-                        get = indexShard.getProtobufStats();
-                        break;
-                    case Search:
-                        search = indexShard.protobufSearchStats(flags.groups());
-                        break;
-                    case Merge:
-                        merge = indexShard.protobufMergeStats();
-                        break;
-                    case Refresh:
-                        refresh = indexShard.protobufRefreshStats();
-                        break;
-                    case Flush:
-                        flush = indexShard.protobufFlushStats();
-                        break;
-                    case Warmer:
-                        warmer = indexShard.protobufWarmerStats();
-                        break;
-                    case QueryCache:
-                        queryCache = indicesQueryCache.getProtobufStats(indexShard.shardId());
-                        break;
-                    case FieldData:
-                        fieldData = indexShard.protobufFieldDataStats(flags.fieldDataFields());
-                        break;
-                    // case Completion:
-                    // completion = indexShard.completionStats(flags.completionDataFields());
-                    // break;
-                    case Segments:
-                        segments = indexShard.protobufSegmentStats(flags.includeSegmentFileSizes(), flags.includeUnloadedSegments());
-                        break;
-                    // case Translog:
-                    // translog = indexShard.translogStats();
-                    // break;
-                    case RequestCache:
-                        requestCache = indexShard.requestCache().protobufStats();
-                        break;
-                    case Recovery:
-                        recoveryStats = indexShard.protobufRecoveryStats();
-                        break;
-                    default:
-                        throw new IllegalStateException("Unknown Flag: " + flag);
-                }
-            } catch (AlreadyClosedException e) {
-                // shard is closed - no stats is fine
-            }
-        }
-    }
-
-    public ProtobufCommonStats(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        docs = protobufStreamInput.readOptionalWriteable(ProtobufDocsStats::new);
-        store = protobufStreamInput.readOptionalWriteable(ProtobufStoreStats::new);
-        indexing = protobufStreamInput.readOptionalWriteable(ProtobufIndexingStats::new);
-        get = protobufStreamInput.readOptionalWriteable(ProtobufGetStats::new);
-        search = protobufStreamInput.readOptionalWriteable(ProtobufSearchStats::new);
-        merge = protobufStreamInput.readOptionalWriteable(ProtobufMergeStats::new);
-        refresh = protobufStreamInput.readOptionalWriteable(ProtobufRefreshStats::new);
-        flush = protobufStreamInput.readOptionalWriteable(ProtobufFlushStats::new);
-        warmer = protobufStreamInput.readOptionalWriteable(ProtobufWarmerStats::new);
-        queryCache = protobufStreamInput.readOptionalWriteable(ProtobufQueryCacheStats::new);
-        fieldData = protobufStreamInput.readOptionalWriteable(ProtobufFieldDataStats::new);
-        completion = protobufStreamInput.readOptionalWriteable(ProtobufCompletionStats::new);
-        segments = protobufStreamInput.readOptionalWriteable(ProtobufSegmentsStats::new);
-        translog = protobufStreamInput.readOptionalWriteable(ProtobufTranslogStats::new);
-        requestCache = protobufStreamInput.readOptionalWriteable(ProtobufRequestCacheStats::new);
-        recoveryStats = protobufStreamInput.readOptionalWriteable(ProtobufRecoveryStats::new);
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeOptionalWriteable(docs);
-        protobufStreamOutput.writeOptionalWriteable(store);
-        protobufStreamOutput.writeOptionalWriteable(indexing);
-        protobufStreamOutput.writeOptionalWriteable(get);
-        protobufStreamOutput.writeOptionalWriteable(search);
-        protobufStreamOutput.writeOptionalWriteable(merge);
-        protobufStreamOutput.writeOptionalWriteable(refresh);
-        protobufStreamOutput.writeOptionalWriteable(flush);
-        protobufStreamOutput.writeOptionalWriteable(warmer);
-        protobufStreamOutput.writeOptionalWriteable(queryCache);
-        protobufStreamOutput.writeOptionalWriteable(fieldData);
-        protobufStreamOutput.writeOptionalWriteable(completion);
-        protobufStreamOutput.writeOptionalWriteable(segments);
-        protobufStreamOutput.writeOptionalWriteable(translog);
-        protobufStreamOutput.writeOptionalWriteable(requestCache);
-        protobufStreamOutput.writeOptionalWriteable(recoveryStats);
-    }
-
-    public void add(ProtobufCommonStats stats) {
-        if (docs == null) {
-            if (stats.getDocs() != null) {
-                docs = new ProtobufDocsStats();
-                docs.add(stats.getDocs());
-            }
-        } else {
-            docs.add(stats.getDocs());
-        }
-        if (store == null) {
-            if (stats.getStore() != null) {
-                store = new ProtobufStoreStats();
-                store.add(stats.getStore());
-            }
-        } else {
-            store.add(stats.getStore());
-        }
-        if (indexing == null) {
-            if (stats.getIndexing() != null) {
-                indexing = new ProtobufIndexingStats();
-                indexing.add(stats.getIndexing());
-            }
-        } else {
-            indexing.add(stats.getIndexing());
-        }
-        if (get == null) {
-            if (stats.getGet() != null) {
-                get = new ProtobufGetStats();
-                get.add(stats.getGet());
-            }
-        } else {
-            get.add(stats.getGet());
-        }
-        if (search == null) {
-            if (stats.getSearch() != null) {
-                search = new ProtobufSearchStats();
-                search.add(stats.getSearch());
-            }
-        } else {
-            search.add(stats.getSearch());
-        }
-        if (merge == null) {
-            if (stats.getMerge() != null) {
-                merge = new ProtobufMergeStats();
-                merge.add(stats.getMerge());
-            }
-        } else {
-            merge.add(stats.getMerge());
-        }
-        if (refresh == null) {
-            if (stats.getRefresh() != null) {
-                refresh = new ProtobufRefreshStats();
-                refresh.add(stats.getRefresh());
-            }
-        } else {
-            refresh.add(stats.getRefresh());
-        }
-        if (flush == null) {
-            if (stats.getFlush() != null) {
-                flush = new ProtobufFlushStats();
-                flush.add(stats.getFlush());
-            }
-        } else {
-            flush.add(stats.getFlush());
-        }
-        if (warmer == null) {
-            if (stats.getWarmer() != null) {
-                warmer = new ProtobufWarmerStats();
-                warmer.add(stats.getWarmer());
-            }
-        } else {
-            warmer.add(stats.getWarmer());
-        }
-        if (queryCache == null) {
-            if (stats.getQueryCache() != null) {
-                queryCache = new ProtobufQueryCacheStats();
-                queryCache.add(stats.getQueryCache());
-            }
-        } else {
-            queryCache.add(stats.getQueryCache());
-        }
-
-        if (fieldData == null) {
-            if (stats.getFieldData() != null) {
-                fieldData = new ProtobufFieldDataStats();
-                fieldData.add(stats.getFieldData());
-            }
-        } else {
-            fieldData.add(stats.getFieldData());
-        }
-        if (completion == null) {
-            if (stats.getCompletion() != null) {
-                completion = new ProtobufCompletionStats();
-                completion.add(stats.getCompletion());
-            }
-        } else {
-            completion.add(stats.getCompletion());
-        }
-        if (segments == null) {
-            if (stats.getSegments() != null) {
-                segments = new ProtobufSegmentsStats();
-                segments.add(stats.getSegments());
-            }
-        } else {
-            segments.add(stats.getSegments());
-        }
-        if (translog == null) {
-            if (stats.getTranslog() != null) {
-                translog = new ProtobufTranslogStats();
-                translog.add(stats.getTranslog());
-            }
-        } else {
-            translog.add(stats.getTranslog());
-        }
-        if (requestCache == null) {
-            if (stats.getRequestCache() != null) {
-                requestCache = new ProtobufRequestCacheStats();
-                requestCache.add(stats.getRequestCache());
-            }
-        } else {
-            requestCache.add(stats.getRequestCache());
-        }
-        if (recoveryStats == null) {
-            if (stats.getRecoveryStats() != null) {
-                recoveryStats = new ProtobufRecoveryStats();
-                recoveryStats.add(stats.getRecoveryStats());
-            }
-        } else {
-            recoveryStats.add(stats.getRecoveryStats());
-        }
-    }
-
-    @Nullable
-    public ProtobufDocsStats getDocs() {
-        return this.docs;
-    }
-
-    @Nullable
-    public ProtobufStoreStats getStore() {
-        return store;
-    }
-
-    @Nullable
-    public ProtobufIndexingStats getIndexing() {
-        return indexing;
-    }
-
-    @Nullable
-    public ProtobufGetStats getGet() {
-        return get;
-    }
-
-    @Nullable
-    public ProtobufSearchStats getSearch() {
-        return search;
-    }
-
-    @Nullable
-    public ProtobufMergeStats getMerge() {
-        return merge;
-    }
-
-    @Nullable
-    public ProtobufRefreshStats getRefresh() {
-        return refresh;
-    }
-
-    @Nullable
-    public ProtobufFlushStats getFlush() {
-        return flush;
-    }
-
-    @Nullable
-    public ProtobufWarmerStats getWarmer() {
-        return this.warmer;
-    }
-
-    @Nullable
-    public ProtobufQueryCacheStats getQueryCache() {
-        return this.queryCache;
-    }
-
-    @Nullable
-    public ProtobufFieldDataStats getFieldData() {
-        return this.fieldData;
-    }
-
-    @Nullable
-    public ProtobufCompletionStats getCompletion() {
-        return completion;
-    }
-
-    @Nullable
-    public ProtobufSegmentsStats getSegments() {
-        return segments;
-    }
-
-    @Nullable
-    public ProtobufTranslogStats getTranslog() {
-        return translog;
-    }
-
-    @Nullable
-    public ProtobufRequestCacheStats getRequestCache() {
-        return requestCache;
-    }
-
-    @Nullable
-    public ProtobufRecoveryStats getRecoveryStats() {
-        return recoveryStats;
-    }
-
-    /**
-     * Utility method which computes total memory by adding
-    * FieldData, PercolatorCache, Segments (index writer, version map)
-    */
-    public ByteSizeValue getTotalMemory() {
-        long size = 0;
-        if (this.getFieldData() != null) {
-            size += this.getFieldData().getMemorySizeInBytes();
-        }
-        if (this.getQueryCache() != null) {
-            size += this.getQueryCache().getMemorySizeInBytes();
-        }
-        if (this.getSegments() != null) {
-            size += this.getSegments().getIndexWriterMemoryInBytes() + this.getSegments().getVersionMapMemoryInBytes();
-        }
-
-        return new ByteSizeValue(size);
-    }
-
-    // note, requires a wrapping object
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        final Stream<ToXContent> stream = Arrays.stream(
-            new ToXContent[] {
-                docs,
-                store,
-                indexing,
-                get,
-                search,
-                merge,
-                refresh,
-                flush,
-                warmer,
-                queryCache,
-                fieldData,
-                completion,
-                segments,
-                translog,
-                requestCache,
-                recoveryStats }
-        ).filter(Objects::nonNull);
-        for (ToXContent toXContent : ((Iterable<ToXContent>) stream::iterator)) {
-            toXContent.toXContent(builder, params);
-        }
-        return builder;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStatsFlags.java b/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStatsFlags.java
deleted file mode 100644
index d4a306d7a79ea..0000000000000
--- a/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufCommonStatsFlags.java
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.action.admin.indices.stats;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.Version;
-import org.opensearch.common.Strings;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-
-import java.io.IOException;
-import java.util.Collections;
-import java.util.EnumSet;
-
-/**
- * Common Stats Flags for OpenSearch
-*
-* @opensearch.internal
-*/
-public class ProtobufCommonStatsFlags implements ProtobufWriteable, Cloneable {
-
-    public static final ProtobufCommonStatsFlags ALL = new ProtobufCommonStatsFlags().all();
-    public static final ProtobufCommonStatsFlags NONE = new ProtobufCommonStatsFlags().clear();
-
-    private EnumSet<Flag> flags = EnumSet.allOf(Flag.class);
-    private String[] groups = null;
-    private String[] fieldDataFields = null;
-    private String[] completionDataFields = null;
-    private boolean includeSegmentFileSizes = false;
-    private boolean includeUnloadedSegments = false;
-    private boolean includeAllShardIndexingPressureTrackers = false;
-    private boolean includeOnlyTopIndexingPressureMetrics = false;
-
-    /**
-     * @param flags flags to set. If no flags are supplied, default flags will be set.
-    */
-    public ProtobufCommonStatsFlags(Flag... flags) {
-        if (flags.length > 0) {
-            clear();
-            Collections.addAll(this.flags, flags);
-        }
-    }
-
-    public ProtobufCommonStatsFlags(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        final long longFlags = in.readInt64();
-        flags.clear();
-        for (Flag flag : Flag.values()) {
-            if ((longFlags & (1 << flag.getIndex())) != 0) {
-                flags.add(flag);
-            }
-        }
-        if (protobufStreamInput.getVersion().before(Version.V_2_0_0)) {
-            protobufStreamInput.readStringArray();
-        }
-        groups = protobufStreamInput.readStringArray();
-        fieldDataFields = protobufStreamInput.readStringArray();
-        completionDataFields = protobufStreamInput.readStringArray();
-        includeSegmentFileSizes = in.readBool();
-        includeUnloadedSegments = in.readBool();
-        includeAllShardIndexingPressureTrackers = in.readBool();
-        includeOnlyTopIndexingPressureMetrics = in.readBool();
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        long longFlags = 0;
-        for (Flag flag : flags) {
-            longFlags |= (1 << flag.getIndex());
-        }
-        out.writeInt64NoTag(longFlags);
-
-        if (protobufStreamOutput.getVersion().before(Version.V_2_0_0)) {
-            protobufStreamOutput.writeStringArrayNullable(Strings.EMPTY_ARRAY);
-        }
-        protobufStreamOutput.writeStringArrayNullable(groups);
-        protobufStreamOutput.writeStringArrayNullable(fieldDataFields);
-        protobufStreamOutput.writeStringArrayNullable(completionDataFields);
-        out.writeBoolNoTag(includeSegmentFileSizes);
-        out.writeBoolNoTag(includeUnloadedSegments);
-        out.writeBoolNoTag(includeAllShardIndexingPressureTrackers);
-        out.writeBoolNoTag(includeOnlyTopIndexingPressureMetrics);
-    }
-
-    /**
-     * Sets all flags to return all stats.
-    */
-    public ProtobufCommonStatsFlags all() {
-        flags = EnumSet.allOf(Flag.class);
-        groups = null;
-        fieldDataFields = null;
-        completionDataFields = null;
-        includeSegmentFileSizes = false;
-        includeUnloadedSegments = false;
-        includeAllShardIndexingPressureTrackers = false;
-        includeOnlyTopIndexingPressureMetrics = false;
-        return this;
-    }
-
-    /**
-     * Clears all stats.
-    */
-    public ProtobufCommonStatsFlags clear() {
-        flags = EnumSet.noneOf(Flag.class);
-        groups = null;
-        fieldDataFields = null;
-        completionDataFields = null;
-        includeSegmentFileSizes = false;
-        includeUnloadedSegments = false;
-        includeAllShardIndexingPressureTrackers = false;
-        includeOnlyTopIndexingPressureMetrics = false;
-        return this;
-    }
-
-    public boolean anySet() {
-        return !flags.isEmpty();
-    }
-
-    public Flag[] getFlags() {
-        return flags.toArray(new Flag[0]);
-    }
-
-    /**
-     * Sets specific search group stats to retrieve the stats for. Mainly affects search
-    * when enabled.
-    */
-    public ProtobufCommonStatsFlags groups(String... groups) {
-        this.groups = groups;
-        return this;
-    }
-
-    public String[] groups() {
-        return this.groups;
-    }
-
-    /**
-     * Sets specific search group stats to retrieve the stats for. Mainly affects search
-    * when enabled.
-    */
-    public ProtobufCommonStatsFlags fieldDataFields(String... fieldDataFields) {
-        this.fieldDataFields = fieldDataFields;
-        return this;
-    }
-
-    public String[] fieldDataFields() {
-        return this.fieldDataFields;
-    }
-
-    public ProtobufCommonStatsFlags completionDataFields(String... completionDataFields) {
-        this.completionDataFields = completionDataFields;
-        return this;
-    }
-
-    public String[] completionDataFields() {
-        return this.completionDataFields;
-    }
-
-    public ProtobufCommonStatsFlags includeSegmentFileSizes(boolean includeSegmentFileSizes) {
-        this.includeSegmentFileSizes = includeSegmentFileSizes;
-        return this;
-    }
-
-    public ProtobufCommonStatsFlags includeUnloadedSegments(boolean includeUnloadedSegments) {
-        this.includeUnloadedSegments = includeUnloadedSegments;
-        return this;
-    }
-
-    public ProtobufCommonStatsFlags includeAllShardIndexingPressureTrackers(boolean includeAllShardPressureTrackers) {
-        this.includeAllShardIndexingPressureTrackers = includeAllShardPressureTrackers;
-        return this;
-    }
-
-    public ProtobufCommonStatsFlags includeOnlyTopIndexingPressureMetrics(boolean includeOnlyTopIndexingPressureMetrics) {
-        this.includeOnlyTopIndexingPressureMetrics = includeOnlyTopIndexingPressureMetrics;
-        return this;
-    }
-
-    public boolean includeUnloadedSegments() {
-        return this.includeUnloadedSegments;
-    }
-
-    public boolean includeAllShardIndexingPressureTrackers() {
-        return this.includeAllShardIndexingPressureTrackers;
-    }
-
-    public boolean includeOnlyTopIndexingPressureMetrics() {
-        return this.includeOnlyTopIndexingPressureMetrics;
-    }
-
-    public boolean includeSegmentFileSizes() {
-        return this.includeSegmentFileSizes;
-    }
-
-    public boolean isSet(Flag flag) {
-        return flags.contains(flag);
-    }
-
-    boolean unSet(Flag flag) {
-        return flags.remove(flag);
-    }
-
-    void set(Flag flag) {
-        flags.add(flag);
-    }
-
-    public ProtobufCommonStatsFlags set(Flag flag, boolean add) {
-        if (add) {
-            set(flag);
-        } else {
-            unSet(flag);
-        }
-        return this;
-    }
-
-    @Override
-    public ProtobufCommonStatsFlags clone() {
-        try {
-            ProtobufCommonStatsFlags cloned = (ProtobufCommonStatsFlags) super.clone();
-            cloned.flags = flags.clone();
-            return cloned;
-        } catch (CloneNotSupportedException e) {
-            throw new AssertionError(e);
-        }
-    }
-
-    /**
-     * The flags.
-    *
-    * @opensearch.internal
-    */
-    public enum Flag {
-        Store("store", 0),
-        Indexing("indexing", 1),
-        Get("get", 2),
-        Search("search", 3),
-        Merge("merge", 4),
-        Flush("flush", 5),
-        Refresh("refresh", 6),
-        QueryCache("query_cache", 7),
-        FieldData("fielddata", 8),
-        Docs("docs", 9),
-        Warmer("warmer", 10),
-        Completion("completion", 11),
-        Segments("segments", 12),
-        Translog("translog", 13),
-        // 14 was previously used for Suggest
-        RequestCache("request_cache", 15),
-        Recovery("recovery", 16);
-
-        private final String restName;
-        private final int index;
-
-        Flag(final String restName, final int index) {
-            this.restName = restName;
-            this.index = index;
-        }
-
-        public String getRestName() {
-            return restName;
-        }
-
-        private int getIndex() {
-            return index;
-        }
-
-    }
-}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufIndexShardStats.java b/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufIndexShardStats.java
deleted file mode 100644
index 849061e865d71..0000000000000
--- a/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufIndexShardStats.java
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * 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.
- */
-
-package org.opensearch.action.admin.indices.stats;
-
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.index.shard.ShardId;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.Iterator;
-
-/**
- * ProtobufIndexShardStats for OpenSearch
- *
- * @opensearch.internal
- */
-public class ProtobufIndexShardStats implements Iterable<ProtobufShardStats>, ProtobufWriteable {
-
-    private final ShardId shardId;
-
-    private final ProtobufShardStats[] shards;
-
-    public ProtobufIndexShardStats(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        shardId = new ShardId(in);
-        shards = protobufStreamInput.readArray(ProtobufShardStats::new, ProtobufShardStats[]::new);
-    }
-
-    public ProtobufIndexShardStats(ShardId shardId, ProtobufShardStats[] shards) {
-        this.shardId = shardId;
-        this.shards = shards;
-    }
-
-    public ShardId getShardId() {
-        return this.shardId;
-    }
-
-    public ProtobufShardStats[] getShards() {
-        return shards;
-    }
-
-    public ProtobufShardStats getAt(int position) {
-        return shards[position];
-    }
-
-    @Override
-    public Iterator<ProtobufShardStats> iterator() {
-        return Arrays.stream(shards).iterator();
-    }
-
-    private ProtobufCommonStats total = null;
-
-    public ProtobufCommonStats getTotal() {
-        if (total != null) {
-            return total;
-        }
-        ProtobufCommonStats stats = new ProtobufCommonStats();
-        for (ProtobufShardStats shard : shards) {
-            stats.add(shard.getStats());
-        }
-        total = stats;
-        return stats;
-    }
-
-    private ProtobufCommonStats primary = null;
-
-    public ProtobufCommonStats getPrimary() {
-        if (primary != null) {
-            return primary;
-        }
-        ProtobufCommonStats stats = new ProtobufCommonStats();
-        for (ProtobufShardStats shard : shards) {
-            if (shard.getShardRouting().primary()) {
-                stats.add(shard.getStats());
-            }
-        }
-        primary = stats;
-        return stats;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        shardId.writeTo(out);
-        protobufStreamOutput.writeArray((o, v) -> v.writeTo(o), shards);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufShardStats.java b/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufShardStats.java
deleted file mode 100644
index 514c4195f1b1d..0000000000000
--- a/server/src/main/java/org/opensearch/action/admin/indices/stats/ProtobufShardStats.java
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
- * 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.
- */
-
-package org.opensearch.action.admin.indices.stats;
-
-import org.opensearch.cluster.routing.ShardRouting;
-import org.opensearch.common.Nullable;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.index.engine.CommitStats;
-import org.opensearch.index.seqno.RetentionLeaseStats;
-import org.opensearch.index.seqno.SeqNoStats;
-import org.opensearch.index.shard.ShardPath;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
-import java.io.IOException;
-
-/**
- * Shard Stats for OpenSearch
- *
- * @opensearch.internal
- */
-public class ProtobufShardStats implements ProtobufWriteable, ToXContentFragment {
-
-    private ShardRouting shardRouting;
-    private ProtobufCommonStats commonStats;
-    @Nullable
-    private CommitStats commitStats;
-    @Nullable
-    private SeqNoStats seqNoStats;
-
-    @Nullable
-    private RetentionLeaseStats retentionLeaseStats;
-
-    /**
-     * Gets the current retention lease stats.
-     *
-     * @return the current retention lease stats
-     */
-    public RetentionLeaseStats getRetentionLeaseStats() {
-        return retentionLeaseStats;
-    }
-
-    private String dataPath;
-    private String statePath;
-    private boolean isCustomDataPath;
-
-    public ProtobufShardStats(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        shardRouting = new ShardRouting(in);
-        commonStats = new ProtobufCommonStats(in);
-        commitStats = CommitStats.readOptionalCommitStatsFromProtobuf(in);
-        statePath = in.readString();
-        dataPath = in.readString();
-        isCustomDataPath = in.readBool();
-        seqNoStats = protobufStreamInput.readOptionalWriteable(SeqNoStats::new);
-        retentionLeaseStats = protobufStreamInput.readOptionalWriteable(RetentionLeaseStats::new);
-    }
-
-    public ProtobufShardStats(
-        final ShardRouting routing,
-        final ShardPath shardPath,
-        final ProtobufCommonStats commonStats,
-        final CommitStats commitStats,
-        final SeqNoStats seqNoStats,
-        final RetentionLeaseStats retentionLeaseStats
-    ) {
-        this.shardRouting = routing;
-        this.dataPath = shardPath.getRootDataPath().toString();
-        this.statePath = shardPath.getRootStatePath().toString();
-        this.isCustomDataPath = shardPath.isCustomDataPath();
-        this.commitStats = commitStats;
-        this.commonStats = commonStats;
-        this.seqNoStats = seqNoStats;
-        this.retentionLeaseStats = retentionLeaseStats;
-    }
-
-    /**
-     * The shard routing information (cluster wide shard state).
-     */
-    public ShardRouting getShardRouting() {
-        return this.shardRouting;
-    }
-
-    public ProtobufCommonStats getStats() {
-        return this.commonStats;
-    }
-
-    @Nullable
-    public CommitStats getCommitStats() {
-        return this.commitStats;
-    }
-
-    @Nullable
-    public SeqNoStats getSeqNoStats() {
-        return this.seqNoStats;
-    }
-
-    public String getDataPath() {
-        return dataPath;
-    }
-
-    public String getStatePath() {
-        return statePath;
-    }
-
-    public boolean isCustomDataPath() {
-        return isCustomDataPath;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        shardRouting.writeTo(out);
-        commonStats.writeTo(out);
-        protobufStreamOutput.writeOptionalWriteable(commitStats);
-        out.writeStringNoTag(statePath);
-        out.writeStringNoTag(dataPath);
-        out.writeBoolNoTag(isCustomDataPath);
-        protobufStreamOutput.writeOptionalWriteable(seqNoStats);
-        protobufStreamOutput.writeOptionalWriteable(retentionLeaseStats);
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.ROUTING)
-            .field(Fields.STATE, shardRouting.state())
-            .field(Fields.PRIMARY, shardRouting.primary())
-            .field(Fields.NODE, shardRouting.currentNodeId())
-            .field(Fields.RELOCATING_NODE, shardRouting.relocatingNodeId())
-            .endObject();
-
-        commonStats.toXContent(builder, params);
-        if (commitStats != null) {
-            commitStats.toXContent(builder, params);
-        }
-        if (seqNoStats != null) {
-            seqNoStats.toXContent(builder, params);
-        }
-        if (retentionLeaseStats != null) {
-            retentionLeaseStats.toXContent(builder, params);
-        }
-        builder.startObject(Fields.SHARD_PATH);
-        builder.field(Fields.STATE_PATH, statePath);
-        builder.field(Fields.DATA_PATH, dataPath);
-        builder.field(Fields.IS_CUSTOM_DATA_PATH, isCustomDataPath);
-        builder.endObject();
-        return builder;
-    }
-
-    /**
-     * Fields for parsing and toXContent
-     *
-     * @opensearch.internal
-     */
-    static final class Fields {
-        static final String ROUTING = "routing";
-        static final String STATE = "state";
-        static final String STATE_PATH = "state_path";
-        static final String DATA_PATH = "data_path";
-        static final String IS_CUSTOM_DATA_PATH = "is_custom_data_path";
-        static final String SHARD_PATH = "shard_path";
-        static final String PRIMARY = "primary";
-        static final String NODE = "node";
-        static final String RELOCATING_NODE = "relocating_node";
-    }
-
-}
diff --git a/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java b/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java
index da66b2fb67af2..185209040ca48 100644
--- a/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java
+++ b/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java
@@ -69,7 +69,6 @@
 import org.opensearch.search.internal.ShardSearchRequest;
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequestHandler;
@@ -343,18 +342,6 @@ public void handleException(TransportException exp) {
                             onFailure(shardRouting, exp);
                         }
 
-                        @Override
-                        public FieldCapabilitiesIndexResponse read(CodedInputStream in) throws IOException {
-                            // TODO Auto-generated method stub
-                            throw new UnsupportedOperationException("Unimplemented method 'read'");
-                        }
-
-                        @Override
-                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                            // TODO Auto-generated method stub
-                            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                        }
-
                         @Override
                         public FieldCapabilitiesIndexResponse read(byte[] in) throws IOException {
                             // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/action/main/ProtobufMainRequest.java b/server/src/main/java/org/opensearch/action/main/ProtobufMainRequest.java
index b352a5c3ae55d..a28b75b330fe5 100644
--- a/server/src/main/java/org/opensearch/action/main/ProtobufMainRequest.java
+++ b/server/src/main/java/org/opensearch/action/main/ProtobufMainRequest.java
@@ -8,7 +8,6 @@
 
 package org.opensearch.action.main;
 
-import com.google.protobuf.CodedInputStream;
 import org.opensearch.action.ProtobufActionRequest;
 import org.opensearch.action.ActionRequestValidationException;
 
@@ -23,7 +22,7 @@ public class ProtobufMainRequest extends ProtobufActionRequest {
 
     public ProtobufMainRequest() {}
 
-    ProtobufMainRequest(CodedInputStream in) throws IOException {
+    ProtobufMainRequest(byte[] in) throws IOException {
         super(in);
     }
 
diff --git a/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java b/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java
index fb5359f370620..d9d45a337e84f 100644
--- a/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java
+++ b/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java
@@ -21,6 +21,7 @@
 import org.opensearch.core.xcontent.XContentParser;
 
 import java.io.IOException;
+import java.io.OutputStream;
 import java.util.Objects;
 
 /**
@@ -39,13 +40,8 @@ public class ProtobufMainResponse extends ProtobufActionResponse implements ToXC
 
     ProtobufMainResponse() {}
 
-    ProtobufMainResponse(CodedInputStream in) throws IOException {
+    ProtobufMainResponse(byte[] in) throws IOException {
         super(in);
-        nodeName = in.readString();
-        version = Version.readVersionProtobuf(in);
-        clusterName = new ClusterName(in);
-        clusterUuid = in.readString();
-        build = Build.readBuildProtobuf(in);
     }
 
     public ProtobufMainResponse(String nodeName, Version version, ClusterName clusterName, String clusterUuid, Build build) {
@@ -77,12 +73,8 @@ public Build getBuild() {
     }
 
     @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeStringNoTag(nodeName);
-        out.writeInt32NoTag(version.id);
-        clusterName.writeTo(out);
-        out.writeStringNoTag(clusterUuid);
-        Build.writeBuildProtobuf(build, out);
+    public void writeTo(OutputStream out) throws IOException {
+        
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/action/resync/TransportResyncReplicationAction.java b/server/src/main/java/org/opensearch/action/resync/TransportResyncReplicationAction.java
index c182ff29d69b0..ea51274758911 100644
--- a/server/src/main/java/org/opensearch/action/resync/TransportResyncReplicationAction.java
+++ b/server/src/main/java/org/opensearch/action/resync/TransportResyncReplicationAction.java
@@ -56,7 +56,6 @@
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.threadpool.ThreadPool.Names;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
@@ -254,18 +253,6 @@ public void handleException(TransportException exp) {
                     listener.onFailure(exp);
                 }
 
-                @Override
-                public ResyncReplicationResponse read(CodedInputStream in) throws IOException {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'read'");
-                }
-
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
-
                 @Override
                 public ResyncReplicationResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/action/search/PitService.java b/server/src/main/java/org/opensearch/action/search/PitService.java
index 06f4035d8389a..b42b2734374a4 100644
--- a/server/src/main/java/org/opensearch/action/search/PitService.java
+++ b/server/src/main/java/org/opensearch/action/search/PitService.java
@@ -23,7 +23,6 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.Strings;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
@@ -205,18 +204,6 @@ public GetAllPitNodesResponse read(StreamInput in) throws IOException {
                     return new GetAllPitNodesResponse(in);
                 }
 
-                @Override
-                public GetAllPitNodesResponse read(CodedInputStream in) throws IOException {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'read'");
-                }
-
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
-
                 @Override
                 public GetAllPitNodesResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/action/support/IndicesOptions.java b/server/src/main/java/org/opensearch/action/support/IndicesOptions.java
index 82a7fc82e5f5f..3f58dbbaff12c 100644
--- a/server/src/main/java/org/opensearch/action/support/IndicesOptions.java
+++ b/server/src/main/java/org/opensearch/action/support/IndicesOptions.java
@@ -35,8 +35,6 @@
 import com.google.protobuf.CodedOutputStream;
 import org.opensearch.OpenSearchParseException;
 import org.opensearch.core.ParseField;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.xcontent.ToXContent;
@@ -282,26 +280,12 @@ public void writeIndicesOptions(StreamOutput out) throws IOException {
         out.writeEnumSet(expandWildcards);
     }
 
-    public void writeIndicesOptionsProtobuf(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        EnumSet<Option> options = this.options;
-        protobufStreamOutput.writeEnumSet(options);
-        protobufStreamOutput.writeEnumSet(expandWildcards);
-    }
-
     public static IndicesOptions readIndicesOptions(StreamInput in) throws IOException {
         EnumSet<Option> options = in.readEnumSet(Option.class);
         EnumSet<WildcardStates> states = in.readEnumSet(WildcardStates.class);
         return new IndicesOptions(options, states);
     }
 
-    public static IndicesOptions readIndicesOptionsProtobuf(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        EnumSet<Option> options = protobufStreamInput.readEnumSet(Option.class);
-        EnumSet<WildcardStates> states = protobufStreamInput.readEnumSet(WildcardStates.class);
-        return new IndicesOptions(options, states);
-    }
-
     public static IndicesOptions fromOptions(
         boolean ignoreUnavailable,
         boolean allowNoIndices,
diff --git a/server/src/main/java/org/opensearch/action/support/broadcast/TransportBroadcastAction.java b/server/src/main/java/org/opensearch/action/support/broadcast/TransportBroadcastAction.java
index e54169a683f94..1305bf0b7750b 100644
--- a/server/src/main/java/org/opensearch/action/support/broadcast/TransportBroadcastAction.java
+++ b/server/src/main/java/org/opensearch/action/support/broadcast/TransportBroadcastAction.java
@@ -54,7 +54,6 @@
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequestHandler;
@@ -233,18 +232,6 @@ public void handleException(TransportException e) {
                                     onOperation(shard, shardIt, shardIndex, e);
                                 }
 
-                                @Override
-                                public ShardResponse read(CodedInputStream in) throws IOException {
-                                    // TODO Auto-generated method stub
-                                    throw new UnsupportedOperationException("Unimplemented method 'read'");
-                                }
-
-                                @Override
-                                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                                    // TODO Auto-generated method stub
-                                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                                }
-
                                 @Override
                                 public ShardResponse read(byte[] in) throws IOException {
                                     // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java b/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
index 8bfc28f9d5757..5bef519190427 100644
--- a/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
@@ -59,7 +59,6 @@
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.NodeShouldNotConnectException;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
@@ -397,19 +396,6 @@ public String executor() {
                             return ThreadPool.Names.SAME;
                         }
 
-                        @Override
-                        public TransportBroadcastByNodeAction<Request, Response, ShardOperationResult>.NodeResponse read(
-                                CodedInputStream in) throws IOException {
-                            // TODO Auto-generated method stub
-                            throw new UnsupportedOperationException("Unimplemented method 'read'");
-                        }
-
-                        @Override
-                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                            // TODO Auto-generated method stub
-                            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                        }
-
                         @Override
                         public TransportBroadcastByNodeAction<Request, Response, ShardOperationResult>.NodeResponse read(
                                 byte[] in) throws IOException {
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadRequest.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadRequest.java
index 76021b40b7fb1..d098b4c575bdc 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadRequest.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadRequest.java
@@ -13,10 +13,8 @@
 
 package org.opensearch.action.support.clustermanager;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
+import java.io.OutputStream;
 
 /**
  * Base request for cluster-manager based read operations that allows to read the cluster state from the local node if needed
@@ -30,15 +28,13 @@ public abstract class ProtobufClusterManagerNodeReadRequest<Request extends Prot
 
     protected ProtobufClusterManagerNodeReadRequest() {}
 
-    protected ProtobufClusterManagerNodeReadRequest(CodedInputStream in) throws IOException {
-        super(in);
-        local = in.readBool();
+    protected ProtobufClusterManagerNodeReadRequest(byte[] in) throws IOException {
+        
     }
 
     @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        super.writeTo(out);
-        out.writeBoolNoTag(local);
+    public void writeTo(OutputStream out) throws IOException {
+        
     }
 
     @SuppressWarnings("unchecked")
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeRequest.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeRequest.java
index aef155bd9e9da..ad436e2ac62c9 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeRequest.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeRequest.java
@@ -13,15 +13,9 @@
 
 package org.opensearch.action.support.clustermanager;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import org.opensearch.action.ProtobufActionRequest;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.unit.TimeValue;
 
-import java.io.IOException;
-
 /**
  * A protobuf request for cluster-manager based operation.
 *
@@ -44,19 +38,6 @@ public abstract class ProtobufClusterManagerNodeRequest<Request extends Protobuf
 
     protected ProtobufClusterManagerNodeRequest() {}
 
-    protected ProtobufClusterManagerNodeRequest(CodedInputStream in) throws IOException {
-        super(in);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        clusterManagerNodeTimeout = protobufStreamInput.readTimeValue();
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        super.writeTo(out);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeTimeValue(clusterManagerNodeTimeout);
-    }
-
     /**
      * A timeout value in case the cluster-manager has not been discovered yet or disconnected.
     */
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
index 95c9e8947bf3d..42eca86ba39e7 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
@@ -22,7 +22,6 @@
 import org.opensearch.action.support.RetryableAction;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterStateObserver;
-import org.opensearch.cluster.ClusterStateObserver;
 import org.opensearch.cluster.ClusterManagerNodeChangePredicate;
 import org.opensearch.cluster.NotClusterManagerException;
 import org.opensearch.cluster.block.ClusterBlockException;
@@ -31,7 +30,6 @@
 import org.opensearch.cluster.metadata.ProcessClusterEventTimeoutException;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
-import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.service.ClusterManagerTaskThrottler;
 import org.opensearch.cluster.service.ClusterManagerThrottlingException;
 import org.opensearch.cluster.service.ClusterService;
@@ -42,8 +40,8 @@
 import org.opensearch.tasks.ProtobufTask;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ConnectTransportException;
-import org.opensearch.transport.ProtobufRemoteTransportException;
-import org.opensearch.transport.ProtobufTransportException;
+import org.opensearch.transport.RemoteTransportException;
+import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
@@ -99,8 +97,6 @@ protected ProtobufTransportClusterManagerNodeAction(
 
     protected abstract String executor();
 
-    protected abstract Response read(CodedInputStream in) throws IOException;
-
     protected abstract Response read(byte[] in) throws IOException;
 
     /**
@@ -199,8 +195,8 @@ public boolean shouldRetry(Exception e) {
             // If remote address is not null, i.e request is generated from remote node and received on this master node on transport layer
             // in that case we would want throttling retry to perform on remote node only not on this master node.
             if (request.remoteAddress() == null) {
-                if (e instanceof ProtobufTransportException) {
-                    return ((ProtobufTransportException) e).unwrapCause() instanceof ClusterManagerThrottlingException;
+                if (e instanceof TransportException) {
+                    return ((TransportException) e).unwrapCause() instanceof ClusterManagerThrottlingException;
                 }
                 return e instanceof ClusterManagerThrottlingException;
             }
@@ -273,10 +269,10 @@ protected void doStart(ClusterState clusterState) {
                                 ProtobufTransportClusterManagerNodeAction.this::read
                             ) {
                                 @Override
-                                public void handleExceptionProtobuf(final ProtobufTransportException exp) {
+                                public void handleException(final TransportException exp) {
                                     Throwable cause = exp.unwrapCause();
                                     if (cause instanceof ConnectTransportException
-                                        || (exp instanceof ProtobufRemoteTransportException && cause instanceof NodeClosedException)) {
+                                        || (exp instanceof RemoteTransportException && cause instanceof NodeClosedException)) {
                                         // we want to retry here a bit to see if a new cluster-manager is elected
                                         logger.debug(
                                             "connection exception while trying to forward request with action name [{}] to "
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/BaseNodeResponse.java b/server/src/main/java/org/opensearch/action/support/nodes/BaseNodeResponse.java
index 60bbd7defaacf..4a94f790c3443 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/BaseNodeResponse.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/BaseNodeResponse.java
@@ -37,9 +37,6 @@
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.transport.TransportResponse;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 
 /**
@@ -56,11 +53,6 @@ protected BaseNodeResponse(StreamInput in) throws IOException {
         node = new DiscoveryNode(in);
     }
 
-    protected BaseNodeResponse(CodedInputStream in) throws IOException {
-        super(in);
-        node = new DiscoveryNode(in);
-    }
-
     protected BaseNodeResponse(DiscoveryNode node) {
         assert node != null;
         this.node = node;
@@ -77,9 +69,4 @@ public DiscoveryNode getNode() {
     public void writeTo(StreamOutput out) throws IOException {
         node.writeTo(out);
     }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        node.writeTo(out);
-    }
 }
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
index cd8f53f318ad1..87e46e8897914 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
@@ -13,13 +13,9 @@
 
 package org.opensearch.action.support.nodes;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.transport.TransportResponse;
 
-import java.io.IOException;
-
 /**
  * A base class for node level operations.
 *
@@ -29,11 +25,6 @@ public abstract class ProtobufBaseNodeResponse extends TransportResponse {
 
     private DiscoveryNode node;
 
-    protected ProtobufBaseNodeResponse(CodedInputStream in) throws IOException {
-        super(in);
-        node = new DiscoveryNode(in);
-    }
-
     protected ProtobufBaseNodeResponse(byte[] data) {
         
     }
@@ -50,8 +41,4 @@ public DiscoveryNode getNode() {
         return node;
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        node.writeTo(out);
-    }
 }
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
index 646c83933c60c..6e1fddfece0bb 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
@@ -19,8 +19,6 @@
 import org.opensearch.action.ProtobufActionRequest;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.unit.TimeValue;
 
 import java.io.IOException;
@@ -52,16 +50,7 @@ public abstract class ProtobufBaseNodesRequest<Request extends ProtobufBaseNodes
 
     private TimeValue timeout;
 
-    protected ProtobufBaseNodesRequest(CodedInputStream in) throws IOException {
-        super(in);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        nodesIds = protobufStreamInput.readStringArray();
-        concreteNodes = protobufStreamInput.readOptionalArray(DiscoveryNode::new, DiscoveryNode[]::new);
-        timeout = protobufStreamInput.readOptionalTimeValue();
-    }
-
     protected ProtobufBaseNodesRequest(byte[] data) throws IOException {
-        // this(CodedInputStream.newInstance(data));
     }
 
     protected ProtobufBaseNodesRequest(String... nodesIds) {
@@ -111,13 +100,4 @@ public void setConcreteNodes(DiscoveryNode[] concreteNodes) {
     public ActionRequestValidationException validate() {
         return null;
     }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        super.writeTo(out);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeStringArrayNullable(nodesIds);
-        protobufStreamOutput.writeOptionalArray((o, v) -> v.writeTo(o), concreteNodes);
-        protobufStreamOutput.writeOptionalTimeValue(timeout);
-    }
 }
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java
index 478a010816b1c..85f4d87ba1649 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java
@@ -15,13 +15,13 @@
 
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
+
+import org.opensearch.action.FailedNodeException;
 import org.opensearch.action.ProtobufActionResponse;
-import org.opensearch.action.ProtobufFailedNodeException;
 import org.opensearch.cluster.ClusterName;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
 
 import java.io.IOException;
+import java.io.OutputStream;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -35,19 +35,15 @@
 public abstract class ProtobufBaseNodesResponse<TNodeResponse extends ProtobufBaseNodeResponse> extends ProtobufActionResponse {
 
     private ClusterName clusterName;
-    private List<ProtobufFailedNodeException> failures;
+    private List<FailedNodeException> failures;
     private List<TNodeResponse> nodes;
     private Map<String, TNodeResponse> nodesMap;
 
-    protected ProtobufBaseNodesResponse(CodedInputStream in) throws IOException {
+    protected ProtobufBaseNodesResponse(byte[] in) throws IOException {
         super(in);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        clusterName = new ClusterName(in);
-        nodes = readNodesFrom(in);
-        failures = protobufStreamInput.readList(ProtobufFailedNodeException::new);
     }
 
-    protected ProtobufBaseNodesResponse(ClusterName clusterName, List<TNodeResponse> nodes, List<ProtobufFailedNodeException> failures) {
+    protected ProtobufBaseNodesResponse(ClusterName clusterName, List<TNodeResponse> nodes, List<FailedNodeException> failures) {
         this.clusterName = Objects.requireNonNull(clusterName);
         this.failures = Objects.requireNonNull(failures);
         this.nodes = Objects.requireNonNull(nodes);
@@ -67,14 +63,14 @@ public ClusterName getClusterName() {
     *
     * @return Never {@code null}. Can be empty.
     */
-    public List<ProtobufFailedNodeException> failures() {
+    public List<FailedNodeException> failures() {
         return failures;
     }
 
     /**
      * Determine if there are any node failures in {@link #failures}.
     *
-    * @return {@code true} if {@link #failures} contains at least 1 {@link ProtobufFailedNodeException}.
+    * @return {@code true} if {@link #failures} contains at least 1 {@link FailedNodeException}.
     */
     public boolean hasFailures() {
         return failures.isEmpty() == false;
@@ -107,23 +103,6 @@ public Map<String, TNodeResponse> getNodesMap() {
     }
 
     @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        clusterName.writeTo(out);
-        writeNodesTo(out, nodes);
-        protobufStreamOutput.writeCollection(failures, (o, v) -> v.writeTo(o));
-    }
-
-    /**
-     * Read the {@link #nodes} from the stream.
-    *
-    * @return Never {@code null}.
-    */
-    protected abstract List<TNodeResponse> readNodesFrom(CodedInputStream in) throws IOException;
-
-    /**
-     * Write the {@link #nodes} to the stream.
-    */
-    protected abstract void writeNodesTo(CodedOutputStream out, List<TNodeResponse> nodes) throws IOException;
+    public void writeTo(OutputStream out) throws IOException {}
 
 }
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufNodesOperationRequestBuilder.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufNodesOperationRequestBuilder.java
deleted file mode 100644
index aacc551e41100..0000000000000
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufNodesOperationRequestBuilder.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.action.support.nodes;
-
-import org.opensearch.action.ProtobufActionType;
-import org.opensearch.action.ProtobufActionRequestBuilder;
-import org.opensearch.client.ProtobufOpenSearchClient;
-import org.opensearch.common.unit.TimeValue;
-
-/**
- * Builder for Operation Requests
-*
-* @opensearch.internal
-*/
-public abstract class ProtobufNodesOperationRequestBuilder<
-    Request extends ProtobufBaseNodesRequest<Request>,
-    Response extends ProtobufBaseNodesResponse,
-    RequestBuilder extends ProtobufNodesOperationRequestBuilder<Request, Response, RequestBuilder>> extends ProtobufActionRequestBuilder<
-        Request,
-        Response> {
-
-    protected ProtobufNodesOperationRequestBuilder(ProtobufOpenSearchClient client, ProtobufActionType<Response> action, Request request) {
-        super(client, action, request);
-    }
-
-    @SuppressWarnings("unchecked")
-    public final RequestBuilder setNodesIds(String... nodesIds) {
-        request.nodesIds(nodesIds);
-        return (RequestBuilder) this;
-    }
-
-    @SuppressWarnings("unchecked")
-    public final RequestBuilder setTimeout(TimeValue timeout) {
-        request.timeout(timeout);
-        return (RequestBuilder) this;
-    }
-
-    @SuppressWarnings("unchecked")
-    public final RequestBuilder setTimeout(String timeout) {
-        request.timeout(timeout);
-        return (RequestBuilder) this;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
index a827f6a6c4526..ae2562f21d35b 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
@@ -12,7 +12,7 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.action.ActionListener;
 import org.opensearch.action.ActionRunnable;
-import org.opensearch.action.ProtobufFailedNodeException;
+import org.opensearch.action.FailedNodeException;
 import org.opensearch.action.support.ProtobufActionFilters;
 import org.opensearch.action.support.ProtobufHandledTransportAction;
 import org.opensearch.cluster.ClusterState;
@@ -25,7 +25,6 @@
 import org.opensearch.transport.NodeShouldNotConnectException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.ProtobufTransportRequestHandler;
 import org.opensearch.transport.TransportRequestOptions;
@@ -132,7 +131,7 @@ protected void doExecute(ProtobufTask task, NodesRequest request, ActionListener
     }
 
     /**
-     * Map the responses into {@code nodeResponseClass} responses and {@link ProtobufFailedNodeException}s.
+     * Map the responses into {@code nodeResponseClass} responses and {@link FailedNodeException}s.
     *
     * @param request The associated request.
     * @param nodesResponses All node-level responses
@@ -142,13 +141,13 @@ protected void doExecute(ProtobufTask task, NodesRequest request, ActionListener
     */
     protected NodesResponse newResponse(NodesRequest request, AtomicReferenceArray<?> nodesResponses) {
         final List<NodeResponse> responses = new ArrayList<>();
-        final List<ProtobufFailedNodeException> failures = new ArrayList<>();
+        final List<FailedNodeException> failures = new ArrayList<>();
 
         for (int i = 0; i < nodesResponses.length(); ++i) {
             Object response = nodesResponses.get(i);
 
-            if (response instanceof ProtobufFailedNodeException) {
-                failures.add((ProtobufFailedNodeException) response);
+            if (response instanceof FailedNodeException) {
+                failures.add((FailedNodeException) response);
             } else {
                 responses.add(nodeResponseClass.cast(response));
             }
@@ -169,13 +168,11 @@ protected NodesResponse newResponse(NodesRequest request, AtomicReferenceArray<?
     protected abstract NodesResponse newResponse(
         NodesRequest request,
         List<NodeResponse> responses,
-        List<ProtobufFailedNodeException> failures
+        List<FailedNodeException> failures
     );
 
     protected abstract NodeRequest newNodeRequest(NodesRequest request);
 
-    protected abstract NodeResponse newNodeResponse(CodedInputStream in) throws IOException;
-
     protected abstract NodeResponse newNodeResponse(byte[] in) throws IOException;
 
     protected abstract NodeResponse nodeOperation(NodeRequest request);
@@ -251,21 +248,11 @@ void start() {
                         nodeRequest,
                         builder.build(),
                         new TransportResponseHandler<NodeResponse>() {
-                            @Override
-                            public NodeResponse read(CodedInputStream in) throws IOException {
-                                return newNodeResponse(in);
-                            }
-
                             @Override
                             public void handleResponse(NodeResponse response) {
                                 onOperation(idx, response);
                             }
 
-                            @Override
-                            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                                onFailure(idx, node.getId(), exp);
-                            }
-
                             @Override
                             public String executor() {
                                 return ThreadPool.Names.SAME;
@@ -305,7 +292,7 @@ private void onFailure(int idx, String nodeId, Throwable t) {
             if (logger.isDebugEnabled() && !(t instanceof NodeShouldNotConnectException)) {
                 logger.debug(new ParameterizedMessage("failed to execute on node [{}]", nodeId), t);
             }
-            responses.set(idx, new ProtobufFailedNodeException(nodeId, "Failed node [" + nodeId + "]", t));
+            responses.set(idx, new FailedNodeException(nodeId, "Failed node [" + nodeId + "]", t));
             if (counter.incrementAndGet() == responses.length()) {
                 finishHim();
             }
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java b/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
index e22d9e00ab7fc..f2d8f59f90d0c 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
@@ -46,7 +46,6 @@
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.NodeShouldNotConnectException;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
@@ -290,18 +289,6 @@ public String executor() {
                                 return ThreadPool.Names.SAME;
                             }
 
-                            @Override
-                            public NodeResponse read(CodedInputStream in) throws IOException {
-                                // TODO Auto-generated method stub
-                                throw new UnsupportedOperationException("Unimplemented method 'read'");
-                            }
-
-                            @Override
-                            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                                // TODO Auto-generated method stub
-                                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                            }
-
                             @Override
                             public NodeResponse read(byte[] in) throws IOException {
                                 // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java b/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java
index de25f848d4aab..8f5268b33632f 100644
--- a/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java
+++ b/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java
@@ -85,7 +85,6 @@
 import org.opensearch.tasks.TaskId;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ConnectTransportException;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
@@ -1106,18 +1105,6 @@ public void handleException(TransportException exp) {
                     }
                 }
 
-                @Override
-                public Response read(CodedInputStream in) throws IOException {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'read'");
-                }
-
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
-
                 @Override
                 public Response read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/action/support/single/instance/TransportInstanceSingleOperationAction.java b/server/src/main/java/org/opensearch/action/support/single/instance/TransportInstanceSingleOperationAction.java
index 3cf85ff3311c3..3282e1ff0d847 100644
--- a/server/src/main/java/org/opensearch/action/support/single/instance/TransportInstanceSingleOperationAction.java
+++ b/server/src/main/java/org/opensearch/action/support/single/instance/TransportInstanceSingleOperationAction.java
@@ -58,7 +58,6 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.threadpool.ThreadPool.Names;
 import org.opensearch.transport.ConnectTransportException;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequestHandler;
@@ -249,18 +248,6 @@ public void handleException(TransportException exp) {
                     }
                 }
 
-                @Override
-                public Response read(CodedInputStream in) throws IOException {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'read'");
-                }
-
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
-
                 @Override
                 public Response read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java b/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java
index ac1da4329bc2e..cf7c9bdbc8273 100644
--- a/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java
+++ b/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java
@@ -58,7 +58,6 @@
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequestHandler;
@@ -229,18 +228,6 @@ public void handleException(TransportException exp) {
                             listener.onFailure(exp);
                         }
 
-                        @Override
-                        public Response read(CodedInputStream in) throws IOException {
-                            // TODO Auto-generated method stub
-                            throw new UnsupportedOperationException("Unimplemented method 'read'");
-                        }
-
-                        @Override
-                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                            // TODO Auto-generated method stub
-                            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                        }
-
                         @Override
                         public Response read(byte[] in) throws IOException {
                             // TODO Auto-generated method stub
@@ -326,18 +313,6 @@ public void handleException(TransportException exp) {
                             onFailure(finalShardRouting, exp);
                         }
 
-                        @Override
-                        public Response read(CodedInputStream in) throws IOException {
-                            // TODO Auto-generated method stub
-                            throw new UnsupportedOperationException("Unimplemented method 'read'");
-                        }
-
-                        @Override
-                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                            // TODO Auto-generated method stub
-                            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                        }
-
                         @Override
                         public Response read(byte[] in) throws IOException {
                             // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java b/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java
index 657222e7a31e7..b872d467a63ef 100644
--- a/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java
+++ b/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java
@@ -52,7 +52,6 @@
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.NodeShouldNotConnectException;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
@@ -320,19 +319,6 @@ public String executor() {
                                         return ThreadPool.Names.SAME;
                                     }
 
-                                    @Override
-                                    public TransportTasksAction<OperationTask, TasksRequest, TasksResponse, TaskResponse>.NodeTasksResponse read(
-                                            CodedInputStream in) throws IOException {
-                                        // TODO Auto-generated method stub
-                                        throw new UnsupportedOperationException("Unimplemented method 'read'");
-                                    }
-
-                                    @Override
-                                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                                        // TODO Auto-generated method stub
-                                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                                    }
-
                                     @Override
                                     public TransportTasksAction<OperationTask, TasksRequest, TasksResponse, TaskResponse>.NodeTasksResponse read(
                                             byte[] in) throws IOException {
diff --git a/server/src/main/java/org/opensearch/client/ProtobufClient.java b/server/src/main/java/org/opensearch/client/ProtobufClient.java
index ca5a7889f2939..c1d5970908243 100644
--- a/server/src/main/java/org/opensearch/client/ProtobufClient.java
+++ b/server/src/main/java/org/opensearch/client/ProtobufClient.java
@@ -50,20 +50,4 @@ public interface ProtobufClient extends ProtobufOpenSearchClient, Releasable {
      * Returns this clients settings
     */
     Settings settings();
-
-    /**
-     * Returns a new lightweight ProtobufClient that applies all given headers to each of the requests
-    * issued from it.
-    */
-    ProtobufClient filterWithHeader(Map<String, String> headers);
-
-    /**
-     * Returns a client to a remote cluster with the given cluster alias.
-    *
-    * @throws IllegalArgumentException if the given clusterAlias doesn't exist
-    * @throws UnsupportedOperationException if this functionality is not available on this client.
-    */
-    default ProtobufClient getRemoteClusterClient(String clusterAlias) {
-        throw new UnsupportedOperationException("this client doesn't support remote cluster connections");
-    }
 }
diff --git a/server/src/main/java/org/opensearch/client/ProtobufClusterAdminClient.java b/server/src/main/java/org/opensearch/client/ProtobufClusterAdminClient.java
index ad07cd7a6b697..5f8fdcbfdcfd1 100644
--- a/server/src/main/java/org/opensearch/client/ProtobufClusterAdminClient.java
+++ b/server/src/main/java/org/opensearch/client/ProtobufClusterAdminClient.java
@@ -10,11 +10,9 @@
 
 import org.opensearch.action.ActionFuture;
 import org.opensearch.action.ActionListener;
-import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequestBuilder;
 import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequest;
 import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoResponse;
 import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsRequest;
-import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsRequestBuilder;
 import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsResponse;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequestBuilder;
@@ -70,11 +68,6 @@ public interface ProtobufClusterAdminClient extends ProtobufOpenSearchClient {
     */
     void nodesInfo(ProtobufNodesInfoRequest request, ActionListener<ProtobufNodesInfoResponse> listener);
 
-    /**
-     * Nodes info of the cluster.
-    */
-    ProtobufNodesInfoRequestBuilder prepareNodesInfo(String... nodesIds);
-
     /**
      * Nodes stats of the cluster.
     *
@@ -92,9 +85,4 @@ public interface ProtobufClusterAdminClient extends ProtobufOpenSearchClient {
     * @see org.opensearch.client.Requests#nodesStatsRequest(String...)
     */
     void nodesStats(ProtobufNodesStatsRequest request, ActionListener<ProtobufNodesStatsResponse> listener);
-
-    /**
-     * Nodes stats of the cluster.
-    */
-    ProtobufNodesStatsRequestBuilder prepareNodesStats(String... nodesIds);
 }
diff --git a/server/src/main/java/org/opensearch/client/ProtobufFilterClient.java b/server/src/main/java/org/opensearch/client/ProtobufFilterClient.java
deleted file mode 100644
index f4e76450f679a..0000000000000
--- a/server/src/main/java/org/opensearch/client/ProtobufFilterClient.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.client;
-
-import org.opensearch.action.ProtobufActionType;
-import org.opensearch.action.ActionListener;
-import org.opensearch.action.ProtobufActionRequest;
-import org.opensearch.action.ProtobufActionResponse;
-import org.opensearch.client.support.ProtobufAbstractClient;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.threadpool.ThreadPool;
-
-/**
- * A {@link ProtobufClient} that contains another {@link ProtobufClient} which it
-* uses as its basic source, possibly transforming the requests / responses along the
-* way or providing additional functionality.
-*
-* @opensearch.internal
-*/
-public abstract class ProtobufFilterClient extends ProtobufAbstractClient {
-
-    protected final ProtobufClient in;
-
-    /**
-     * Creates a new ProtobufFilterClient
-    *
-    * @param in the client to delegate to
-    * @see #in()
-    */
-    public ProtobufFilterClient(ProtobufClient in) {
-        this(in.settings(), in.threadPool(), in);
-    }
-
-    /**
-     * A Constructor that allows to pass settings and threadpool separately. This is useful if the
-    * client is a proxy and not yet fully constructed ie. both dependencies are not available yet.
-    */
-    protected ProtobufFilterClient(Settings settings, ThreadPool threadPool, ProtobufClient in) {
-        super(settings, threadPool);
-        this.in = in;
-    }
-
-    @Override
-    public void close() {
-        in().close();
-    }
-
-    @Override
-    protected <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> void doExecute(
-        ProtobufActionType<Response> action,
-        Request request,
-        ActionListener<Response> listener
-    ) {
-        in().execute(action, request, listener);
-    }
-
-    /**
-     * Returns the delegate {@link ProtobufClient}
-    */
-    protected ProtobufClient in() {
-        return in;
-    }
-
-    @Override
-    public ProtobufClient getRemoteClusterClient(String clusterAlias) {
-        return in.getRemoteClusterClient(clusterAlias);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java b/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java
index b5d729b59cb82..78c4671c71305 100644
--- a/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java
+++ b/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java
@@ -128,11 +128,6 @@ Response extends ProtobufActionResponse> ProtobufTransportAction<Request, Respon
         return transportAction;
     }
 
-    @Override
-    public ProtobufClient getRemoteClusterClient(String clusterAlias) {
-        return remoteClusterService.getRemoteClusterClientProtobuf(threadPool(), clusterAlias);
-    }
-
     public NamedWriteableRegistry getNamedWriteableRegistry() {
         return namedWriteableRegistry;
     }
diff --git a/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java b/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
index 0ed6bc96ef3d2..bd8ca5e79178a 100644
--- a/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
+++ b/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
@@ -16,12 +16,10 @@
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.action.ProtobufActionType;
 import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoAction;
-import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequestBuilder;
 import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequest;
 import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoResponse;
 import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsAction;
 import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsRequest;
-import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsRequestBuilder;
 import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsResponse;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateAction;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequestBuilder;
@@ -29,15 +27,12 @@
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
 import org.opensearch.action.support.PlainActionFuture;
 import org.opensearch.client.ProtobufClient;
-import org.opensearch.client.ProtobufFilterClient;
 import org.opensearch.client.ProtobufAdminClient;
 import org.opensearch.client.ProtobufClusterAdminClient;
 import org.opensearch.client.ProtobufOpenSearchClient;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.threadpool.ThreadPool;
 
-import java.util.Map;
 
 /**
  * Base client used to create concrete client implementations
@@ -171,11 +166,6 @@ public void nodesInfo(final ProtobufNodesInfoRequest request, final ActionListen
             execute(ProtobufNodesInfoAction.INSTANCE, request, listener);
         }
 
-        @Override
-        public ProtobufNodesInfoRequestBuilder prepareNodesInfo(String... nodesIds) {
-            return new ProtobufNodesInfoRequestBuilder(this, ProtobufNodesInfoAction.INSTANCE).setNodesIds(nodesIds);
-        }
-
         @Override
         public ActionFuture<ProtobufNodesStatsResponse> nodesStats(final ProtobufNodesStatsRequest request) {
             return execute(ProtobufNodesStatsAction.INSTANCE, request);
@@ -185,27 +175,5 @@ public ActionFuture<ProtobufNodesStatsResponse> nodesStats(final ProtobufNodesSt
         public void nodesStats(final ProtobufNodesStatsRequest request, final ActionListener<ProtobufNodesStatsResponse> listener) {
             execute(ProtobufNodesStatsAction.INSTANCE, request, listener);
         }
-
-        @Override
-        public ProtobufNodesStatsRequestBuilder prepareNodesStats(String... nodesIds) {
-            return new ProtobufNodesStatsRequestBuilder(this, ProtobufNodesStatsAction.INSTANCE).setNodesIds(nodesIds);
-        }
-    }
-
-    @Override
-    public ProtobufClient filterWithHeader(Map<String, String> headers) {
-        return new ProtobufFilterClient(this) {
-            @Override
-            protected <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> void doExecute(
-                ProtobufActionType<Response> action,
-                Request request,
-                ActionListener<Response> listener
-            ) {
-                ThreadContext threadContext = threadPool().getThreadContext();
-                try (ThreadContext.StoredContext ctx = threadContext.stashAndMergeHeaders(headers)) {
-                    super.doExecute(action, request, listener);
-                }
-            }
-        };
     }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java b/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java
index 4f49ac5a0f7eb..186d4af944b33 100644
--- a/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java
+++ b/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java
@@ -48,7 +48,7 @@
  *
  * @opensearch.internal
  */
-public abstract class AbstractDiffable<T extends Diffable<T>, V extends ProtobufDiffable<V>> implements Diffable<T>, ProtobufDiffable<V> {
+public abstract class AbstractDiffable<T extends Diffable<T>> implements Diffable<T> {
 
     private static final Diff<?> EMPTY = new CompleteDiff<>();
 
@@ -62,16 +62,6 @@ public Diff<T> diff(T previousState) {
         }
     }
 
-    @SuppressWarnings("unchecked")
-    @Override
-    public ProtobufDiff<V> protobufDiff(V previousState) {
-        if (this.equals(previousState)) {
-            return (ProtobufDiff<V>) EMPTY;
-        } else {
-            return new CompleteDiffProtobuf<>((V) this);
-        }
-    }
-
     @SuppressWarnings("unchecked")
     public static <T extends Diffable<T>> Diff<T> readDiffFrom(Reader<T> reader, StreamInput in) throws IOException {
         if (in.readBoolean()) {
@@ -80,14 +70,6 @@ public static <T extends Diffable<T>> Diff<T> readDiffFrom(Reader<T> reader, Str
         return (Diff<T>) EMPTY;
     }
 
-    @SuppressWarnings("unchecked")
-    public static <V extends ProtobufDiffable<V>> ProtobufDiff<V> readDiffFromProtobuf(ProtobufWriteable.Reader<V> reader, CodedInputStream in) throws IOException {
-        if (in.readBool()) {
-            return new CompleteDiffProtobuf<>(reader.read(in));
-        }
-        return (ProtobufDiff<V>) EMPTY;
-    }
-
     /**
      * A complete diff.
      *
@@ -132,47 +114,4 @@ public T apply(T part) {
         }
     }
 
-    /**
-     * A complete diff.
-    *
-    * @opensearch.internal
-    */
-    private static class CompleteDiffProtobuf<T extends ProtobufDiffable<T>> implements ProtobufDiff<T> {
-
-        @Nullable
-        private final T part;
-
-        /**
-         * Creates simple diff with changes
-        */
-        CompleteDiffProtobuf(T part) {
-            this.part = part;
-        }
-
-        /**
-         * Creates simple diff without changes
-        */
-        CompleteDiffProtobuf() {
-            this.part = null;
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            if (part != null) {
-                out.writeBoolNoTag(true);
-                part.writeTo(out);
-            } else {
-                out.writeBoolNoTag(false);
-            }
-        }
-
-        @Override
-        public T apply(T part) {
-            if (this.part != null) {
-                return this.part;
-            } else {
-                return part;
-            }
-        }
-    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterName.java b/server/src/main/java/org/opensearch/cluster/ClusterName.java
index b74a393bdd658..3404470846971 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterName.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterName.java
@@ -40,7 +40,6 @@
 import org.opensearch.common.settings.Settings;
 
 import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 
 import java.io.IOException;
 import java.util.Objects;
@@ -51,7 +50,7 @@
  *
  * @opensearch.internal
  */
-public class ClusterName implements Writeable, ProtobufWriteable {
+public class ClusterName implements Writeable {
 
     public static final Setting<ClusterName> CLUSTER_NAME_SETTING = new Setting<>("cluster.name", "opensearch", (s) -> {
         if (s.isEmpty()) {
@@ -88,11 +87,6 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeString(value);
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeStringNoTag(value);
-    }
-
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterState.java b/server/src/main/java/org/opensearch/cluster/ClusterState.java
index 11d8e445509e4..91d72af44c7bd 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterState.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterState.java
@@ -32,8 +32,6 @@
 
 package org.opensearch.cluster;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 
 import org.opensearch.cluster.block.ClusterBlock;
 import org.opensearch.cluster.block.ClusterBlocks;
@@ -56,8 +54,6 @@
 import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.core.common.io.stream.NamedWriteableAwareStreamInput;
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.VersionedNamedWriteable;
@@ -104,7 +100,7 @@
  *
  * @opensearch.internal
  */
-public class ClusterState implements ToXContentFragment, Diffable<ClusterState>, ProtobufDiffable<ClusterState> {
+public class ClusterState implements ToXContentFragment, Diffable<ClusterState> {
 
     public static final ClusterState EMPTY_STATE = builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).build();
 
@@ -753,11 +749,6 @@ public Diff<ClusterState> diff(ClusterState previousState) {
         return new ClusterStateDiff(previousState, this);
     }
 
-    @Override
-    public ProtobufDiff<ClusterState> protobufDiff(ClusterState previousState) {
-        return new ClusterStateDiffProtobuf(previousState, this);
-    }
-
     public static Diff<ClusterState> readDiffFrom(StreamInput in, DiscoveryNode localNode) throws IOException {
         return new ClusterStateDiff(in, localNode);
     }
@@ -780,25 +771,6 @@ public static ClusterState readFrom(StreamInput in, DiscoveryNode localNode) thr
         return builder.build();
     }
 
-    public static ClusterState readFrom(CodedInputStream in, DiscoveryNode localNode) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        ClusterName clusterName = new ClusterName(in);
-        Builder builder = new Builder(clusterName);
-        builder.version = in.readInt64();
-        builder.uuid = in.readString();
-        // builder.metadata = Metadata.readFrom(in);
-        // builder.routingTable = RoutingTable.readFrom(in);
-        builder.nodes = DiscoveryNodes.readFromProtobuf(in, localNode);
-        // builder.blocks = ClusterBlocks.readFrom(in);
-        int customSize = in.readInt32();
-        // for (int i = 0; i < customSize; i++) {
-        //     Custom customIndexMetadata = protobufStreamInput.readNamedWriteable(Custom.class);
-        //     builder.putCustom(customIndexMetadata.getWriteableName(), customIndexMetadata);
-        // }
-        builder.minimumClusterManagerNodesOnPublishingClusterManager = in.readInt32();
-        return builder.build();
-    }
-
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         clusterName.writeTo(out);
@@ -824,32 +796,6 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeVInt(minimumClusterManagerNodesOnPublishingClusterManager);
     }
 
-     @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        clusterName.writeTo(out);
-        out.writeInt64NoTag(version);
-        out.writeStringNoTag(stateUUID);
-        // metadata.writeTo(out);
-        // routingTable.writeTo(out);
-        nodes.writeTo(out);
-        // blocks.writeTo(out);
-        // filter out custom states not supported by the other node
-        int numberOfCustoms = 0;
-        // for (final ObjectCursor<Custom> cursor : customs.values()) {
-        //     if (FeatureAware.shouldSerialize(out, cursor.value)) {
-        //         numberOfCustoms++;
-        //     }
-        // }
-        out.writeInt32NoTag(numberOfCustoms);
-        // for (final ObjectCursor<Custom> cursor : customs.values()) {
-        //     if (FeatureAware.shouldSerialize(out, cursor.value)) {
-        //         protobufStreamOutput.writeNamedWriteable(cursor.value);
-        //     }
-        // }
-        out.writeInt32NoTag(minimumClusterManagerNodesOnPublishingClusterManager);
-    }
-
     /**
      * The cluster state diff.
      *
@@ -939,105 +885,4 @@ public ClusterState apply(ClusterState state) {
             return builder.build();
         }
     }
-
-    /**
-     * The cluster state diff.
-    *
-    * @opensearch.internal
-    */
-    private static class ClusterStateDiffProtobuf implements ProtobufDiff<ClusterState> {
-
-        private final long toVersion;
-
-        private final String fromUuid;
-
-        private final String toUuid;
-
-        private final ClusterName clusterName;
-
-        private final ProtobufDiff<RoutingTable> routingTable;
-
-        private final ProtobufDiff<DiscoveryNodes> nodes;
-
-        private final ProtobufDiff<Metadata> metadata;
-
-        private final ProtobufDiff<ClusterBlocks> blocks;
-
-        private final ProtobufDiff<ImmutableOpenMap<String, Custom>> customs;
-
-        private final int minimumClusterManagerNodesOnPublishingClusterManager;
-
-        ClusterStateDiffProtobuf(ClusterState before, ClusterState after) {
-            fromUuid = before.stateUUID;
-            toUuid = after.stateUUID;
-            toVersion = after.version;
-            clusterName = after.clusterName;
-            routingTable = null;
-            nodes = after.nodes.protobufDiff(before.nodes);;
-            metadata = null;
-            blocks = null;
-            // customs = ProtobufDiffableUtils.diff(
-            //     before.customs,
-            //     after.customs,
-            //     ProtobufDiffableUtils.getStringKeySerializer(),
-            //     CUSTOM_VALUE_SERIALIZER
-            // );
-            customs = null;
-            minimumClusterManagerNodesOnPublishingClusterManager = after.minimumClusterManagerNodesOnPublishingClusterManager;
-        }
-
-        ClusterStateDiffProtobuf(CodedInputStream in, DiscoveryNode localNode) throws IOException {
-            clusterName = new ClusterName(in);
-            fromUuid = in.readString();
-            toUuid = in.readString();
-            toVersion = in.readInt64();
-            routingTable = null;
-            nodes = DiscoveryNodes.readDiffFrom(in, localNode);
-            metadata = null;
-            blocks = null;
-            // customs = ProtobufDiffableUtils.readImmutableOpenMapDiff(
-            //     in,
-            //     ProtobufDiffableUtils.getStringKeySerializer(),
-            //     CUSTOM_VALUE_SERIALIZER
-            // );
-            customs = null;
-            minimumClusterManagerNodesOnPublishingClusterManager = in.readInt32();
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            clusterName.writeTo(out);
-            out.writeStringNoTag(fromUuid);
-            out.writeStringNoTag(toUuid);
-            out.writeInt64NoTag(toVersion);
-            // routingTable.writeTo(out);
-            nodes.writeTo(out);
-            // metadata.writeTo(out);
-            // blocks.writeTo(out);
-            // customs.writeTo(out);
-            // out.writeVInt(minimumClusterManagerNodesOnPublishingClusterManager);
-        }
-
-        @Override
-        public ClusterState apply(ClusterState state) {
-            Builder builder = new Builder(clusterName);
-            if (toUuid.equals(state.stateUUID)) {
-                // no need to read the rest - cluster state didn't change
-                return state;
-            }
-            if (fromUuid.equals(state.stateUUID) == false) {
-                throw new IncompatibleClusterStateVersionException(state.version, state.stateUUID, toVersion, fromUuid);
-            }
-            builder.stateUUID(toUuid);
-            builder.version(toVersion);
-            builder.routingTable(routingTable.apply(state.routingTable));
-            builder.nodes(nodes.apply(state.nodes));
-            builder.metadata(metadata.apply(state.metadata));
-            builder.blocks(blocks.apply(state.blocks));
-            builder.customs(customs.apply(state.customs));
-            builder.minimumClusterManagerNodesOnPublishingClusterManager(minimumClusterManagerNodesOnPublishingClusterManager);
-            builder.fromDiff(true);
-            return builder.build();
-        }
-    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufAbstractDiffable.java b/server/src/main/java/org/opensearch/cluster/ProtobufAbstractDiffable.java
deleted file mode 100644
index 3e90bb2a7d377..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/ProtobufAbstractDiffable.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.cluster;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
-import org.opensearch.cluster.node.DiscoveryNodes;
-import org.opensearch.common.Nullable;
-
-import java.io.IOException;
-
-/**
- * Abstract diffable object with simple diffs implementation that sends the entire object if object has changed or
-* nothing if object remained the same.
-*
-* @opensearch.internal
-*/
-public abstract class ProtobufAbstractDiffable<T extends ProtobufDiffable<T>> implements ProtobufDiffable<T> {
-
-    private static final ProtobufDiff<?> EMPTY = new CompleteDiff<>();
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public ProtobufDiff<T> protobufDiff(T previousState) {
-        if (this.equals(previousState)) {
-            return (ProtobufDiff<T>) EMPTY;
-        } else {
-            return new CompleteDiff<>((T) this);
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    public static <T extends ProtobufDiffable<T>> ProtobufDiff<T> readDiffFrom(Reader<T> reader, CodedInputStream in) throws IOException {
-        if (in.readBool()) {
-            return new CompleteDiff<>(reader.read(in));
-        }
-        return (ProtobufDiff<T>) EMPTY;
-    }
-
-    /**
-     * A complete diff.
-    *
-    * @opensearch.internal
-    */
-    private static class CompleteDiff<T extends ProtobufDiffable<T>> implements ProtobufDiff<T> {
-
-        @Nullable
-        private final T part;
-
-        /**
-         * Creates simple diff with changes
-        */
-        CompleteDiff(T part) {
-            this.part = part;
-        }
-
-        /**
-         * Creates simple diff without changes
-        */
-        CompleteDiff() {
-            this.part = null;
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            if (part != null) {
-                out.writeBoolNoTag(true);
-                part.writeTo(out);
-            } else {
-                out.writeBoolNoTag(false);
-            }
-        }
-
-        @Override
-        public T apply(T part) {
-            if (this.part != null) {
-                return this.part;
-            } else {
-                return part;
-            }
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufDiffableUtils.java b/server/src/main/java/org/opensearch/cluster/ProtobufDiffableUtils.java
deleted file mode 100644
index fef838ff6eefa..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/ProtobufDiffableUtils.java
+++ /dev/null
@@ -1,812 +0,0 @@
-/*
-* 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.
-*/
-
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
-package org.opensearch.cluster;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import com.carrotsearch.hppc.cursors.IntCursor;
-import com.carrotsearch.hppc.cursors.IntObjectCursor;
-import com.carrotsearch.hppc.cursors.ObjectCursor;
-import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
-import org.opensearch.Version;
-import org.opensearch.common.collect.ImmutableOpenIntMap;
-import org.opensearch.common.collect.ImmutableOpenMap;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * Utility class for a diffable
-*
-* @opensearch.internal
-*/
-public final class ProtobufDiffableUtils {
-    private ProtobufDiffableUtils() {}
-
-    /**
-     * Returns a map key serializer for String keys
-    */
-    public static KeySerializer<String> getStringKeySerializer() {
-        return StringKeySerializer.INSTANCE;
-    }
-
-    /**
-     * Returns a map key serializer for Integer keys. Encodes as Int.
-    */
-    public static KeySerializer<Integer> getIntKeySerializer() {
-        return IntKeySerializer.INSTANCE;
-    }
-
-    /**
-     * Returns a map key serializer for Integer keys. Encodes as VInt.
-    */
-    public static KeySerializer<Integer> getVIntKeySerializer() {
-        return VIntKeySerializer.INSTANCE;
-    }
-
-    /**
-     * Calculates diff between two ImmutableOpenMaps of Diffable objects
-    */
-    public static <K, T extends ProtobufDiffable<T>> MapDiff<K, T, ImmutableOpenMap<K, T>> diff(
-        ImmutableOpenMap<K, T> before,
-        ImmutableOpenMap<K, T> after,
-        KeySerializer<K> keySerializer
-    ) {
-        assert after != null && before != null;
-        return new ImmutableOpenMapDiff<>(before, after, keySerializer, DiffableValueSerializer.getWriteOnlyInstance());
-    }
-
-    /**
-     * Calculates diff between two ImmutableOpenMaps of non-diffable objects
-    */
-    public static <K, T> MapDiff<K, T, ImmutableOpenMap<K, T>> diff(
-        ImmutableOpenMap<K, T> before,
-        ImmutableOpenMap<K, T> after,
-        KeySerializer<K> keySerializer,
-        ValueSerializer<K, T> valueSerializer
-    ) {
-        assert after != null && before != null;
-        return new ImmutableOpenMapDiff<>(before, after, keySerializer, valueSerializer);
-    }
-
-    /**
-     * Calculates diff between two ImmutableOpenIntMaps of Diffable objects
-    */
-    public static <T extends ProtobufDiffable<T>> MapDiff<Integer, T, ImmutableOpenIntMap<T>> diff(
-        ImmutableOpenIntMap<T> before,
-        ImmutableOpenIntMap<T> after,
-        KeySerializer<Integer> keySerializer
-    ) {
-        assert after != null && before != null;
-        return new ImmutableOpenIntMapDiff<>(before, after, keySerializer, DiffableValueSerializer.getWriteOnlyInstance());
-    }
-
-    /**
-     * Calculates diff between two ImmutableOpenIntMaps of non-diffable objects
-    */
-    public static <T> MapDiff<Integer, T, ImmutableOpenIntMap<T>> diff(
-        ImmutableOpenIntMap<T> before,
-        ImmutableOpenIntMap<T> after,
-        KeySerializer<Integer> keySerializer,
-        ValueSerializer<Integer, T> valueSerializer
-    ) {
-        assert after != null && before != null;
-        return new ImmutableOpenIntMapDiff<>(before, after, keySerializer, valueSerializer);
-    }
-
-    /**
-     * Calculates diff between two Maps of Diffable objects.
-    */
-    public static <K, T extends ProtobufDiffable<T>> MapDiff<K, T, Map<K, T>> diff(
-        Map<K, T> before,
-        Map<K, T> after,
-        KeySerializer<K> keySerializer
-    ) {
-        assert after != null && before != null;
-        return new JdkMapDiff<>(before, after, keySerializer, DiffableValueSerializer.getWriteOnlyInstance());
-    }
-
-    /**
-     * Calculates diff between two Maps of non-diffable objects
-    */
-    public static <K, T> MapDiff<K, T, Map<K, T>> diff(
-        Map<K, T> before,
-        Map<K, T> after,
-        KeySerializer<K> keySerializer,
-        ValueSerializer<K, T> valueSerializer
-    ) {
-        assert after != null && before != null;
-        return new JdkMapDiff<>(before, after, keySerializer, valueSerializer);
-    }
-
-    /**
-     * Loads an object that represents difference between two ImmutableOpenMaps
-    */
-    public static <K, T> MapDiff<K, T, ImmutableOpenMap<K, T>> readImmutableOpenMapDiff(
-        CodedInputStream in,
-        KeySerializer<K> keySerializer,
-        ValueSerializer<K, T> valueSerializer
-    ) throws IOException {
-        return new ImmutableOpenMapDiff<>(in, keySerializer, valueSerializer);
-    }
-
-    /**
-     * Loads an object that represents difference between two ImmutableOpenMaps
-    */
-    public static <T> MapDiff<Integer, T, ImmutableOpenIntMap<T>> readImmutableOpenIntMapDiff(
-        CodedInputStream in,
-        KeySerializer<Integer> keySerializer,
-        ValueSerializer<Integer, T> valueSerializer
-    ) throws IOException {
-        return new ImmutableOpenIntMapDiff<>(in, keySerializer, valueSerializer);
-    }
-
-    /**
-     * Loads an object that represents difference between two Maps of Diffable objects
-    */
-    public static <K, T> MapDiff<K, T, Map<K, T>> readJdkMapDiff(
-        CodedInputStream in,
-        KeySerializer<K> keySerializer,
-        ValueSerializer<K, T> valueSerializer
-    ) throws IOException {
-        return new JdkMapDiff<>(in, keySerializer, valueSerializer);
-    }
-
-    /**
-     * Loads an object that represents difference between two ImmutableOpenMaps of Diffable objects using Diffable proto object
-    */
-    public static <K, T extends ProtobufDiffable<T>> MapDiff<K, T, ImmutableOpenMap<K, T>> readImmutableOpenMapDiff(
-        CodedInputStream in,
-        KeySerializer<K> keySerializer,
-        DiffableValueReader<K, T> diffableValueReader
-    ) throws IOException {
-        return new ImmutableOpenMapDiff<>(in, keySerializer, diffableValueReader);
-    }
-
-    /**
-     * Loads an object that represents difference between two ImmutableOpenIntMaps of Diffable objects using Diffable proto object
-    */
-    public static <T extends ProtobufDiffable<T>> MapDiff<Integer, T, ImmutableOpenIntMap<T>> readImmutableOpenIntMapDiff(
-        CodedInputStream in,
-        KeySerializer<Integer> keySerializer,
-        ProtobufWriteable.Reader<T> reader,
-        ProtobufWriteable.Reader<ProtobufDiff<T>> diffReader
-    ) throws IOException {
-        return new ImmutableOpenIntMapDiff<>(in, keySerializer, new DiffableValueReader<>(reader, diffReader));
-    }
-
-    /**
-     * Loads an object that represents difference between two Maps of Diffable objects using Diffable proto object
-    */
-    public static <K, T extends ProtobufDiffable<T>> MapDiff<K, T, Map<K, T>> readJdkMapDiff(
-        CodedInputStream in,
-        KeySerializer<K> keySerializer,
-        ProtobufWriteable.Reader<T> reader,
-        ProtobufWriteable.Reader<ProtobufDiff<T>> diffReader
-    ) throws IOException {
-        return new JdkMapDiff<>(in, keySerializer, new DiffableValueReader<>(reader, diffReader));
-    }
-
-    /**
-     * Represents differences between two Maps of (possibly diffable) objects.
-    *
-    * @param <T> the diffable object
-    *
-    * @opensearch.internal
-    */
-    private static class JdkMapDiff<K, T> extends MapDiff<K, T, Map<K, T>> {
-
-        protected JdkMapDiff(CodedInputStream in, KeySerializer<K> keySerializer, ValueSerializer<K, T> valueSerializer)
-            throws IOException {
-            super(in, keySerializer, valueSerializer);
-        }
-
-        JdkMapDiff(Map<K, T> before, Map<K, T> after, KeySerializer<K> keySerializer, ValueSerializer<K, T> valueSerializer) {
-            super(keySerializer, valueSerializer);
-            assert after != null && before != null;
-
-            for (K key : before.keySet()) {
-                if (!after.containsKey(key)) {
-                    deletes.add(key);
-                }
-            }
-
-            for (Map.Entry<K, T> partIter : after.entrySet()) {
-                T beforePart = before.get(partIter.getKey());
-                if (beforePart == null) {
-                    upserts.put(partIter.getKey(), partIter.getValue());
-                } else if (partIter.getValue().equals(beforePart) == false) {
-                    if (valueSerializer.supportsDiffableValues()) {
-                        diffs.put(partIter.getKey(), valueSerializer.diff(partIter.getValue(), beforePart));
-                    } else {
-                        upserts.put(partIter.getKey(), partIter.getValue());
-                    }
-                }
-            }
-        }
-
-        @Override
-        public Map<K, T> apply(Map<K, T> map) {
-            Map<K, T> builder = new HashMap<>(map);
-
-            for (K part : deletes) {
-                builder.remove(part);
-            }
-
-            for (Map.Entry<K, ProtobufDiff<T>> diff : diffs.entrySet()) {
-                builder.put(diff.getKey(), diff.getValue().apply(builder.get(diff.getKey())));
-            }
-
-            for (Map.Entry<K, T> upsert : upserts.entrySet()) {
-                builder.put(upsert.getKey(), upsert.getValue());
-            }
-            return builder;
-        }
-    }
-
-    /**
-     * Represents differences between two ImmutableOpenMap of (possibly diffable) objects
-    *
-    * @param <T> the object type
-    *
-    * @opensearch.internal
-    */
-    public static class ImmutableOpenMapDiff<K, T> extends MapDiff<K, T, ImmutableOpenMap<K, T>> {
-
-        protected ImmutableOpenMapDiff(CodedInputStream in, KeySerializer<K> keySerializer, ValueSerializer<K, T> valueSerializer)
-            throws IOException {
-            super(in, keySerializer, valueSerializer);
-        }
-
-        private ImmutableOpenMapDiff(
-            KeySerializer<K> keySerializer,
-            ValueSerializer<K, T> valueSerializer,
-            List<K> deletes,
-            Map<K, ProtobufDiff<T>> diffs,
-            Map<K, T> upserts
-        ) {
-            super(keySerializer, valueSerializer, deletes, diffs, upserts);
-        }
-
-        public ImmutableOpenMapDiff(
-            ImmutableOpenMap<K, T> before,
-            ImmutableOpenMap<K, T> after,
-            KeySerializer<K> keySerializer,
-            ValueSerializer<K, T> valueSerializer
-        ) {
-            super(keySerializer, valueSerializer);
-            assert after != null && before != null;
-
-            for (ObjectCursor<K> key : before.keys()) {
-                if (!after.containsKey(key.value)) {
-                    deletes.add(key.value);
-                }
-            }
-
-            for (ObjectObjectCursor<K, T> partIter : after) {
-                T beforePart = before.get(partIter.key);
-                if (beforePart == null) {
-                    upserts.put(partIter.key, partIter.value);
-                } else if (partIter.value.equals(beforePart) == false) {
-                    if (valueSerializer.supportsDiffableValues()) {
-                        diffs.put(partIter.key, valueSerializer.diff(partIter.value, beforePart));
-                    } else {
-                        upserts.put(partIter.key, partIter.value);
-                    }
-                }
-            }
-        }
-
-        /**
-         * Returns a new diff map with the given key removed, does not modify the invoking instance.
-        * If the key does not exist in the diff map, the same instance is returned.
-        */
-        public ImmutableOpenMapDiff<K, T> withKeyRemoved(K key) {
-            if (this.diffs.containsKey(key) == false && this.upserts.containsKey(key) == false) {
-                return this;
-            }
-            Map<K, ProtobufDiff<T>> newDiffs = new HashMap<>(this.diffs);
-            newDiffs.remove(key);
-            Map<K, T> newUpserts = new HashMap<>(this.upserts);
-            newUpserts.remove(key);
-            return new ImmutableOpenMapDiff<>(this.keySerializer, this.valueSerializer, this.deletes, newDiffs, newUpserts);
-        }
-
-        @Override
-        public ImmutableOpenMap<K, T> apply(ImmutableOpenMap<K, T> map) {
-            ImmutableOpenMap.Builder<K, T> builder = ImmutableOpenMap.builder();
-            builder.putAll(map);
-
-            for (K part : deletes) {
-                builder.remove(part);
-            }
-
-            for (Map.Entry<K, ProtobufDiff<T>> diff : diffs.entrySet()) {
-                builder.put(diff.getKey(), diff.getValue().apply(builder.get(diff.getKey())));
-            }
-
-            for (Map.Entry<K, T> upsert : upserts.entrySet()) {
-                builder.put(upsert.getKey(), upsert.getValue());
-            }
-            return builder.build();
-        }
-    }
-
-    /**
-     * Represents differences between two ImmutableOpenIntMap of (possibly diffable) objects
-    *
-    * @param <T> the object type
-    *
-    * @opensearch.internal
-    */
-    private static class ImmutableOpenIntMapDiff<T> extends MapDiff<Integer, T, ImmutableOpenIntMap<T>> {
-
-        protected ImmutableOpenIntMapDiff(
-            CodedInputStream in,
-            KeySerializer<Integer> keySerializer,
-            ValueSerializer<Integer, T> valueSerializer
-        ) throws IOException {
-            super(in, keySerializer, valueSerializer);
-        }
-
-        ImmutableOpenIntMapDiff(
-            ImmutableOpenIntMap<T> before,
-            ImmutableOpenIntMap<T> after,
-            KeySerializer<Integer> keySerializer,
-            ValueSerializer<Integer, T> valueSerializer
-        ) {
-            super(keySerializer, valueSerializer);
-            assert after != null && before != null;
-
-            for (IntCursor key : before.keys()) {
-                if (!after.containsKey(key.value)) {
-                    deletes.add(key.value);
-                }
-            }
-
-            for (IntObjectCursor<T> partIter : after) {
-                T beforePart = before.get(partIter.key);
-                if (beforePart == null) {
-                    upserts.put(partIter.key, partIter.value);
-                } else if (partIter.value.equals(beforePart) == false) {
-                    if (valueSerializer.supportsDiffableValues()) {
-                        diffs.put(partIter.key, valueSerializer.diff(partIter.value, beforePart));
-                    } else {
-                        upserts.put(partIter.key, partIter.value);
-                    }
-                }
-            }
-        }
-
-        @Override
-        public ImmutableOpenIntMap<T> apply(ImmutableOpenIntMap<T> map) {
-            ImmutableOpenIntMap.Builder<T> builder = ImmutableOpenIntMap.builder();
-            builder.putAll(map);
-
-            for (Integer part : deletes) {
-                builder.remove(part);
-            }
-
-            for (Map.Entry<Integer, ProtobufDiff<T>> diff : diffs.entrySet()) {
-                builder.put(diff.getKey(), diff.getValue().apply(builder.get(diff.getKey())));
-            }
-
-            for (Map.Entry<Integer, T> upsert : upserts.entrySet()) {
-                builder.put(upsert.getKey(), upsert.getValue());
-            }
-            return builder.build();
-        }
-    }
-
-    /**
-     * Represents differences between two maps of objects and is used as base class for different map implementations.
-    *
-    * Implements serialization. How differences are applied is left to subclasses.
-    *
-    * @param <K> the type of map keys
-    * @param <T> the type of map values
-    * @param <M> the map implementation type
-    *
-    * @opensearch.internal
-    */
-    public abstract static class MapDiff<K, T, M> implements ProtobufDiff<M> {
-
-        protected final List<K> deletes;
-        protected final Map<K, ProtobufDiff<T>> diffs; // incremental updates
-        protected final Map<K, T> upserts; // additions or full updates
-        protected final KeySerializer<K> keySerializer;
-        protected final ValueSerializer<K, T> valueSerializer;
-
-        protected MapDiff(KeySerializer<K> keySerializer, ValueSerializer<K, T> valueSerializer) {
-            this.keySerializer = keySerializer;
-            this.valueSerializer = valueSerializer;
-            deletes = new ArrayList<>();
-            diffs = new HashMap<>();
-            upserts = new HashMap<>();
-        }
-
-        protected MapDiff(
-            KeySerializer<K> keySerializer,
-            ValueSerializer<K, T> valueSerializer,
-            List<K> deletes,
-            Map<K, ProtobufDiff<T>> diffs,
-            Map<K, T> upserts
-        ) {
-            this.keySerializer = keySerializer;
-            this.valueSerializer = valueSerializer;
-            this.deletes = deletes;
-            this.diffs = diffs;
-            this.upserts = upserts;
-        }
-
-        protected MapDiff(CodedInputStream in, KeySerializer<K> keySerializer, ValueSerializer<K, T> valueSerializer) throws IOException {
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-            this.keySerializer = keySerializer;
-            this.valueSerializer = valueSerializer;
-            deletes = protobufStreamInput.readList(keySerializer::readKey);
-            int diffsCount = protobufStreamInput.readVInt();
-            diffs = diffsCount == 0 ? Collections.emptyMap() : new HashMap<>(diffsCount);
-            for (int i = 0; i < diffsCount; i++) {
-                K key = keySerializer.readKey(in);
-                ProtobufDiff<T> diff = valueSerializer.readDiff(in, key);
-                diffs.put(key, diff);
-            }
-            int upsertsCount = protobufStreamInput.readVInt();
-            upserts = upsertsCount == 0 ? Collections.emptyMap() : new HashMap<>(upsertsCount);
-            for (int i = 0; i < upsertsCount; i++) {
-                K key = keySerializer.readKey(in);
-                T newValue = valueSerializer.read(in, key);
-                upserts.put(key, newValue);
-            }
-        }
-
-        /**
-         * The keys that, when this diff is applied to a map, should be removed from the map.
-        *
-        * @return the list of keys that are deleted
-        */
-        public List<K> getDeletes() {
-            return deletes;
-        }
-
-        /**
-         * Map entries that, when this diff is applied to a map, should be
-        * incrementally updated. The incremental update is represented using
-        * the {@link Diff} interface.
-        *
-        * @return the map entries that are incrementally updated
-        */
-        public Map<K, ProtobufDiff<T>> getDiffs() {
-            return diffs;
-        }
-
-        /**
-         * Map entries that, when this diff is applied to a map, should be
-        * added to the map or fully replace the previous value.
-        *
-        * @return the map entries that are additions or full updates
-        */
-        public Map<K, T> getUpserts() {
-            return upserts;
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            protobufStreamOutput.writeCollection(deletes, (o, v) -> keySerializer.writeKey(v, o));
-            Version version = protobufStreamOutput.getVersion();
-            // filter out custom states not supported by the other node
-            int diffCount = 0;
-            for (ProtobufDiff<T> diff : diffs.values()) {
-                if (valueSerializer.supportsVersion(diff, version)) {
-                    diffCount++;
-                }
-            }
-            out.writeInt32NoTag(diffCount);
-            for (Map.Entry<K, ProtobufDiff<T>> entry : diffs.entrySet()) {
-                if (valueSerializer.supportsVersion(entry.getValue(), version)) {
-                    keySerializer.writeKey(entry.getKey(), out);
-                    valueSerializer.writeDiff(entry.getValue(), out);
-                }
-            }
-            // filter out custom states not supported by the other node
-            int upsertsCount = 0;
-            for (T upsert : upserts.values()) {
-                if (valueSerializer.supportsVersion(upsert, version)) {
-                    upsertsCount++;
-                }
-            }
-            out.writeInt32NoTag(upsertsCount);
-            for (Map.Entry<K, T> entry : upserts.entrySet()) {
-                if (valueSerializer.supportsVersion(entry.getValue(), version)) {
-                    keySerializer.writeKey(entry.getKey(), out);
-                    valueSerializer.write(entry.getValue(), out);
-                }
-            }
-        }
-    }
-
-    /**
-     * Provides read and write operations to serialize keys of map
-    * @param <K> type of key
-    *
-    * @opensearch.internal
-    */
-    public interface KeySerializer<K> {
-        void writeKey(K key, CodedOutputStream out) throws IOException;
-
-        K readKey(CodedInputStream in) throws IOException;
-    }
-
-    /**
-     * Serializes String keys of a map
-    *
-    * @opensearch.internal
-    */
-    private static final class StringKeySerializer implements KeySerializer<String> {
-        private static final StringKeySerializer INSTANCE = new StringKeySerializer();
-
-        @Override
-        public void writeKey(String key, CodedOutputStream out) throws IOException {
-            out.writeStringNoTag(key);
-        }
-
-        @Override
-        public String readKey(CodedInputStream in) throws IOException {
-            return in.readString();
-        }
-    }
-
-    /**
-     * Serializes Integer keys of a map as an Int
-    *
-    * @opensearch.internal
-    */
-    private static final class IntKeySerializer implements KeySerializer<Integer> {
-        public static final IntKeySerializer INSTANCE = new IntKeySerializer();
-
-        @Override
-        public void writeKey(Integer key, CodedOutputStream out) throws IOException {
-            out.writeInt32NoTag(key);
-        }
-
-        @Override
-        public Integer readKey(CodedInputStream in) throws IOException {
-            return in.readInt32();
-        }
-    }
-
-    /**
-     * Serializes Integer keys of a map as a VInt. Requires keys to be positive.
-    *
-    * @opensearch.internal
-    */
-    private static final class VIntKeySerializer implements KeySerializer<Integer> {
-        public static final IntKeySerializer INSTANCE = new IntKeySerializer();
-
-        @Override
-        public void writeKey(Integer key, CodedOutputStream out) throws IOException {
-            if (key < 0) {
-                throw new IllegalArgumentException("Map key [" + key + "] must be positive");
-            }
-            out.writeInt32NoTag(key);
-        }
-
-        @Override
-        public Integer readKey(CodedInputStream in) throws IOException {
-            return in.readInt32();
-        }
-    }
-
-    /**
-     * Provides read and write operations to serialize map values.
-    * Reading of values can be made dependent on map key.
-    *
-    * Also provides operations to distinguish whether map values are diffable.
-    *
-    * Should not be directly implemented, instead implement either
-    * {@link DiffableValueSerializer} or {@link NonDiffableValueSerializer}.
-    *
-    * @param <K> key type of map
-    * @param <V> value type of map
-    *
-    * @opensearch.internal
-    */
-    public interface ValueSerializer<K, V> {
-
-        /**
-         * Writes value to stream
-        */
-        void write(V value, CodedOutputStream out) throws IOException;
-
-        /**
-         * Reads value from stream. Reading operation can be made dependent on map key.
-        */
-        V read(CodedInputStream in, K key) throws IOException;
-
-        /**
-         * Whether this serializer supports diffable values
-        */
-        boolean supportsDiffableValues();
-
-        /**
-         * Whether this serializer supports the version of the output stream
-        */
-        default boolean supportsVersion(ProtobufDiff<V> value, Version version) {
-            return true;
-        }
-
-        /**
-         * Whether this serializer supports the version of the output stream
-        */
-        default boolean supportsVersion(V value, Version version) {
-            return true;
-        }
-
-        /**
-         * Computes diff if this serializer supports diffable values
-        */
-        ProtobufDiff<V> diff(V value, V beforePart);
-
-        /**
-         * Writes value as diff to stream if this serializer supports diffable values
-        */
-        void writeDiff(ProtobufDiff<V> value, CodedOutputStream out) throws IOException;
-
-        /**
-         * Reads value as diff from stream if this serializer supports diffable values.
-        * Reading operation can be made dependent on map key.
-        */
-        ProtobufDiff<V> readDiff(CodedInputStream in, K key) throws IOException;
-    }
-
-    /**
-     * Serializer for Diffable map values. Needs to implement read and readDiff methods.
-    *
-    * @param <K> type of map keys
-    * @param <V> type of map values
-    *
-    * @opensearch.internal
-    */
-    public abstract static class DiffableValueSerializer<K, V extends ProtobufDiffable<V>> implements ValueSerializer<K, V> {
-        private static final DiffableValueSerializer WRITE_ONLY_INSTANCE = new DiffableValueSerializer() {
-            @Override
-            public Object read(CodedInputStream in, Object key) throws IOException {
-                throw new UnsupportedOperationException();
-            }
-
-            @Override
-            public ProtobufDiff<Object> readDiff(CodedInputStream in, Object key) throws IOException {
-                throw new UnsupportedOperationException();
-            }
-        };
-
-        private static <K, V extends ProtobufDiffable<V>> DiffableValueSerializer<K, V> getWriteOnlyInstance() {
-            return WRITE_ONLY_INSTANCE;
-        }
-
-        @Override
-        public boolean supportsDiffableValues() {
-            return true;
-        }
-
-        @Override
-        public ProtobufDiff<V> diff(V value, V beforePart) {
-            return value.protobufDiff(beforePart);
-        }
-
-        @Override
-        public void write(V value, CodedOutputStream out) throws IOException {
-            value.writeTo(out);
-        }
-
-        public void writeDiff(ProtobufDiff<V> value, CodedOutputStream out) throws IOException {
-            value.writeTo(out);
-        }
-    }
-
-    /**
-     * Serializer for non-diffable map values
-    *
-    * @param <K> type of map keys
-    * @param <V> type of map values
-    *
-    * @opensearch.internal
-    */
-    public abstract static class NonDiffableValueSerializer<K, V> implements ValueSerializer<K, V> {
-        @Override
-        public boolean supportsDiffableValues() {
-            return false;
-        }
-
-        @Override
-        public ProtobufDiff<V> diff(V value, V beforePart) {
-            throw new UnsupportedOperationException();
-        }
-
-        @Override
-        public void writeDiff(ProtobufDiff<V> value, CodedOutputStream out) throws IOException {
-            throw new UnsupportedOperationException();
-        }
-
-        @Override
-        public ProtobufDiff<V> readDiff(CodedInputStream in, K key) throws IOException {
-            throw new UnsupportedOperationException();
-        }
-    }
-
-    /**
-     * Implementation of the ValueSerializer that wraps value and diff readers.
-    *
-    * Note: this implementation is ignoring the key.
-    *
-    * @opensearch.internal
-    */
-    public static class DiffableValueReader<K, V extends ProtobufDiffable<V>> extends DiffableValueSerializer<K, V> {
-        private final ProtobufWriteable.Reader<V> reader;
-        private final ProtobufWriteable.Reader<ProtobufDiff<V>> diffReader;
-
-        public DiffableValueReader(ProtobufWriteable.Reader<V> reader, ProtobufWriteable.Reader<ProtobufDiff<V>> diffReader) {
-            this.reader = reader;
-            this.diffReader = diffReader;
-        }
-
-        @Override
-        public V read(CodedInputStream in, K key) throws IOException {
-            return reader.read(in);
-        }
-
-        @Override
-        public ProtobufDiff<V> readDiff(CodedInputStream in, K key) throws IOException {
-            return diffReader.read(in);
-        }
-    }
-
-    /**
-     * Implementation of ValueSerializer that serializes immutable sets
-    *
-    * @param <K> type of map key
-    *
-    * @opensearch.internal
-    */
-    public static class StringSetValueSerializer<K> extends NonDiffableValueSerializer<K, Set<String>> {
-        private static final StringSetValueSerializer INSTANCE = new StringSetValueSerializer();
-
-        public static <K> StringSetValueSerializer<K> getInstance() {
-            return INSTANCE;
-        }
-
-        @Override
-        public void write(Set<String> value, CodedOutputStream out) throws IOException {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            protobufStreamOutput.writeStringCollection(value);
-        }
-
-        @Override
-        public Set<String> read(CodedInputStream in, K key) throws IOException {
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-            return Collections.unmodifiableSet(new HashSet<>(Arrays.asList(protobufStreamInput.readStringArray())));
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiff.java b/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiff.java
deleted file mode 100644
index 85f6e29d31458..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiff.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
-* 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.
-*/
-
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
-package org.opensearch.cluster;
-
-import org.opensearch.Version;
-import org.opensearch.common.io.stream.ProtobufNamedWriteable;
-
-/**
- * Diff that also support NamedWriteable interface
-*
-* @opensearch.internal
-*/
-public interface ProtobufNamedDiff<T extends ProtobufDiffable<T>> extends ProtobufDiff<T>, ProtobufNamedWriteable {
-    /**
-     * The minimal version of the recipient this custom object can be sent to
-    */
-    default Version getMinimalSupportedVersion() {
-        return Version.CURRENT.minimumIndexCompatibilityVersion();
-    }
-
-}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffable.java b/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffable.java
deleted file mode 100644
index 4c1ff98666e5f..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffable.java
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
-* 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.
-*/
-
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
-package org.opensearch.cluster;
-
-import org.opensearch.common.io.stream.ProtobufVersionedNamedWriteable;
-import org.opensearch.common.io.stream.VersionedNamedWriteable;
-
-/**
- * Diff that also support {@link VersionedNamedWriteable} interface
-*
-* @opensearch.internal
-*/
-public interface ProtobufNamedDiffable<T> extends ProtobufDiffable<T>, ProtobufVersionedNamedWriteable {}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffableValueSerializer.java b/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffableValueSerializer.java
deleted file mode 100644
index a5d142efa670c..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/ProtobufNamedDiffableValueSerializer.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
-* 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.
-*/
-
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
-package org.opensearch.cluster;
-
-import com.google.protobuf.CodedInputStream;
-import org.opensearch.Version;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-
-import java.io.IOException;
-
-/**
- * Value Serializer for named diffables
-*
-* @opensearch.internal
-*/
-public class ProtobufNamedDiffableValueSerializer<T extends ProtobufNamedDiffable<T>> extends ProtobufDiffableUtils.DiffableValueSerializer<
-    String,
-    T> {
-
-    private final Class<T> tClass;
-
-    public ProtobufNamedDiffableValueSerializer(Class<T> tClass) {
-        this.tClass = tClass;
-    }
-
-    @Override
-    public T read(CodedInputStream in, String key) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        return protobufStreamInput.readNamedWriteable(tClass, key);
-    }
-
-    @Override
-    public boolean supportsVersion(ProtobufDiff<T> value, Version version) {
-        return version.onOrAfter(((ProtobufNamedDiff<?>) value).getMinimalSupportedVersion());
-    }
-
-    @Override
-    public boolean supportsVersion(T value, Version version) {
-        return version.onOrAfter(value.getMinimalSupportedVersion());
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public ProtobufDiff<T> readDiff(CodedInputStream in, String key) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        return protobufStreamInput.readNamedWriteable(ProtobufNamedDiff.class, key);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java b/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java
index d5295aae148bc..b7cc92ee8d539 100644
--- a/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java
+++ b/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java
@@ -63,7 +63,7 @@
  *
  * @opensearch.internal
  */
-public class ClusterBlocks extends AbstractDiffable<ClusterBlocks, ClusterBlocks> {
+public class ClusterBlocks extends AbstractDiffable<ClusterBlocks> {
     public static final ClusterBlocks EMPTY_CLUSTER_BLOCK = new ClusterBlocks(emptySet(), Map.of());
 
     private final Set<ClusterBlock> global;
@@ -481,9 +481,4 @@ public ClusterBlocks build() {
         }
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
-    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
index 3910861cbe9bd..4f214021abeb1 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
@@ -80,7 +80,6 @@
 import org.opensearch.discovery.DiscoveryStats;
 import org.opensearch.discovery.HandshakingTransportAddressConnector;
 import org.opensearch.discovery.PeerFinder;
-import org.opensearch.discovery.ProtobufDiscoveryStats;
 import org.opensearch.discovery.SeedHostsProvider;
 import org.opensearch.discovery.SeedHostsResolver;
 import org.opensearch.monitor.NodeHealthService;
@@ -864,11 +863,6 @@ public DiscoveryStats stats() {
         return new DiscoveryStats(new PendingClusterStateStats(0, 0, 0), publicationHandler.stats());
     }
 
-    @Override
-    public ProtobufDiscoveryStats protobufStats() {
-        return new ProtobufDiscoveryStats(new ProtobufPendingClusterStateStats(0, 0, 0), publicationHandler.protobufStats());
-    }
-
     @Override
     public void startInitialJoin() {
         synchronized (mutex) {
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java b/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java
index 29f38a8056d95..1a2d990195259 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java
@@ -48,7 +48,6 @@
 import org.opensearch.monitor.StatusInfo;
 import org.opensearch.threadpool.ThreadPool.Names;
 import org.opensearch.transport.ConnectTransportException;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportConnectionListener;
@@ -404,18 +403,6 @@ public String executor() {
                         return Names.SAME;
                     }
 
-                    @Override
-                    public Empty read(CodedInputStream in) throws IOException {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'read'");
-                    }
-
-                    @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                    }
-
                     @Override
                     public Empty read(byte[] in) throws IOException {
                         // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java b/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java
index fb5fe5ffc6232..299262928ac42 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java
@@ -62,7 +62,6 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.threadpool.ThreadPool.Names;
 import org.opensearch.transport.BytesTransportRequest;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.RemoteTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
@@ -417,18 +416,6 @@ public String executor() {
                         return Names.SAME;
                     }
 
-                    @Override
-                    public Empty read(CodedInputStream in) throws IOException {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'read'");
-                    }
-
-                    @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                    }
-
                     @Override
                     public Empty read(byte[] in) throws IOException {
                         // TODO Auto-generated method stub
@@ -465,18 +452,6 @@ public String executor() {
                 return ThreadPool.Names.SAME;
             }
 
-            @Override
-            public Empty read(CodedInputStream in) throws IOException {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'read'");
-            }
-
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
-
             @Override
             public Empty read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java b/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java
index 2dfcbcd1e2418..80a1b3c5eccda 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java
@@ -50,7 +50,6 @@
 import org.opensearch.threadpool.ThreadPool.Names;
 import org.opensearch.transport.ConnectTransportException;
 import org.opensearch.transport.NodeDisconnectedException;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportConnectionListener;
 import org.opensearch.transport.TransportException;
@@ -344,18 +343,6 @@ public String executor() {
                         return Names.SAME;
                     }
 
-                    @Override
-                    public Empty read(CodedInputStream in) throws IOException {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'read'");
-                    }
-
-                    @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                    }
-
                     @Override
                     public Empty read(byte[] in) throws IOException {
                         // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/PreVoteCollector.java b/server/src/main/java/org/opensearch/cluster/coordination/PreVoteCollector.java
index 038f2c77bcc67..621c8a645bb8a 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/PreVoteCollector.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/PreVoteCollector.java
@@ -45,7 +45,6 @@
 import org.opensearch.monitor.NodeHealthService;
 import org.opensearch.monitor.StatusInfo;
 import org.opensearch.threadpool.ThreadPool.Names;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
@@ -221,18 +220,6 @@ public String toString() {
                             return "TransportResponseHandler{" + PreVoteCollector.this + ", node=" + n + '}';
                         }
 
-                        @Override
-                        public PreVoteResponse read(CodedInputStream in) throws IOException {
-                            // TODO Auto-generated method stub
-                            throw new UnsupportedOperationException("Unimplemented method 'read'");
-                        }
-
-                        @Override
-                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                            // TODO Auto-generated method stub
-                            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                        }
-
                         @Override
                         public PreVoteResponse read(byte[] in) throws IOException {
                             // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/ProtobufPendingClusterStateStats.java b/server/src/main/java/org/opensearch/cluster/coordination/ProtobufPendingClusterStateStats.java
deleted file mode 100644
index 1270f8214ef49..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/coordination/ProtobufPendingClusterStateStats.java
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.cluster.coordination;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-
-/**
- * Class encapsulating stats about the PendingClusterStatsQueue
-*
-* @opensearch.internal
-*/
-public class ProtobufPendingClusterStateStats implements ProtobufWriteable, ToXContentFragment {
-
-    private final int total;
-    private final int pending;
-    private final int committed;
-
-    public ProtobufPendingClusterStateStats(int total, int pending, int committed) {
-        this.total = total;
-        this.pending = pending;
-        this.committed = committed;
-    }
-
-    public ProtobufPendingClusterStateStats(CodedInputStream in) throws IOException {
-        total = in.readInt32();
-        pending = in.readInt32();
-        committed = in.readInt32();
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt32NoTag(total);
-        out.writeInt32NoTag(pending);
-        out.writeInt32NoTag(committed);
-    }
-
-    public int getCommitted() {
-        return committed;
-    }
-
-    public int getPending() {
-        return pending;
-    }
-
-    public int getTotal() {
-        return total;
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.QUEUE);
-        builder.field(Fields.TOTAL, total);
-        builder.field(Fields.PENDING, pending);
-        builder.field(Fields.COMMITTED, committed);
-        builder.endObject();
-        return builder;
-    }
-
-    /**
-     * Fields for parsing and toXContent
-    *
-    * @opensearch.internal
-    */
-    static final class Fields {
-        static final String QUEUE = "cluster_state_queue";
-        static final String TOTAL = "total";
-        static final String PENDING = "pending";
-        static final String COMMITTED = "committed";
-    }
-
-    @Override
-    public String toString() {
-        return "ProtobufPendingClusterStateStats(total=" + total + ", pending=" + pending + ", committed=" + committed + ")";
-    }
-}
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/ProtobufPublishClusterStateStats.java b/server/src/main/java/org/opensearch/cluster/coordination/ProtobufPublishClusterStateStats.java
deleted file mode 100644
index 83604bf3dae9b..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/coordination/ProtobufPublishClusterStateStats.java
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.cluster.coordination;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.core.xcontent.ToXContentObject;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-
-/**
- * Class encapsulating stats about the PublishClusterStateAction
-*
-* @opensearch.internal
-*/
-public class ProtobufPublishClusterStateStats implements ProtobufWriteable, ToXContentObject {
-
-    private final long fullClusterStateReceivedCount;
-    private final long incompatibleClusterStateDiffReceivedCount;
-    private final long compatibleClusterStateDiffReceivedCount;
-
-    /**
-     * @param fullClusterStateReceivedCount the number of times this node has received a full copy of the cluster state from the cluster-manager.
-    * @param incompatibleClusterStateDiffReceivedCount the number of times this node has received a cluster-state diff from the cluster-manager.
-    * @param compatibleClusterStateDiffReceivedCount the number of times that received cluster-state diffs were compatible with
-    */
-    public ProtobufPublishClusterStateStats(
-        long fullClusterStateReceivedCount,
-        long incompatibleClusterStateDiffReceivedCount,
-        long compatibleClusterStateDiffReceivedCount
-    ) {
-        this.fullClusterStateReceivedCount = fullClusterStateReceivedCount;
-        this.incompatibleClusterStateDiffReceivedCount = incompatibleClusterStateDiffReceivedCount;
-        this.compatibleClusterStateDiffReceivedCount = compatibleClusterStateDiffReceivedCount;
-    }
-
-    public ProtobufPublishClusterStateStats(CodedInputStream in) throws IOException {
-        fullClusterStateReceivedCount = in.readInt64();
-        incompatibleClusterStateDiffReceivedCount = in.readInt64();
-        compatibleClusterStateDiffReceivedCount = in.readInt64();
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(fullClusterStateReceivedCount);
-        out.writeInt64NoTag(incompatibleClusterStateDiffReceivedCount);
-        out.writeInt64NoTag(compatibleClusterStateDiffReceivedCount);
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject("published_cluster_states");
-        {
-            builder.field("full_states", fullClusterStateReceivedCount);
-            builder.field("incompatible_diffs", incompatibleClusterStateDiffReceivedCount);
-            builder.field("compatible_diffs", compatibleClusterStateDiffReceivedCount);
-        }
-        builder.endObject();
-        return builder;
-    }
-
-    public long getFullClusterStateReceivedCount() {
-        return fullClusterStateReceivedCount;
-    }
-
-    public long getIncompatibleClusterStateDiffReceivedCount() {
-        return incompatibleClusterStateDiffReceivedCount;
-    }
-
-    public long getCompatibleClusterStateDiffReceivedCount() {
-        return compatibleClusterStateDiffReceivedCount;
-    }
-
-    @Override
-    public String toString() {
-        return "ProtobufPublishClusterStateStats(full="
-            + fullClusterStateReceivedCount
-            + ", incompatible="
-            + incompatibleClusterStateDiffReceivedCount
-            + ", compatible="
-            + compatibleClusterStateDiffReceivedCount
-            + ")";
-    }
-}
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java b/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
index 6655fdce381ef..92230d161049d 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
@@ -48,7 +48,6 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.BytesTransportRequest;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequestOptions;
@@ -163,14 +162,6 @@ public PublishClusterStateStats stats() {
         );
     }
 
-    public ProtobufPublishClusterStateStats protobufStats() {
-        return new ProtobufPublishClusterStateStats(
-            fullClusterStateReceivedCount.get(),
-            incompatibleClusterStateDiffReceivedCount.get(),
-            compatibleClusterStateDiffReceivedCount.get()
-        );
-    }
-
     private PublishWithJoinResponse handleIncomingPublishRequest(BytesTransportRequest request) throws IOException {
         try (StreamInput in = CompressedStreamUtils.decompressBytes(request, namedWriteableRegistry)) {
             ClusterState incomingState;
@@ -393,18 +384,6 @@ public String executor() {
                         return ThreadPool.Names.GENERIC;
                     }
 
-                    @Override
-                    public Empty read(CodedInputStream in) throws IOException {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'read'");
-                    }
-
-                    @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                    }
-
                     @Override
                     public Empty read(byte[] in) throws IOException {
                         // TODO Auto-generated method stub
@@ -482,18 +461,6 @@ public String executor() {
                         return ThreadPool.Names.GENERIC;
                     }
 
-                    @Override
-                    public PublishWithJoinResponse read(CodedInputStream in) throws IOException {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'read'");
-                    }
-
-                    @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                    }
-
                     @Override
                     public PublishWithJoinResponse read(byte[] in) throws IOException {
                         // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/cluster/decommission/DecommissionController.java b/server/src/main/java/org/opensearch/cluster/decommission/DecommissionController.java
index f9be3a2de5b8f..9a19d4d4ee944 100644
--- a/server/src/main/java/org/opensearch/cluster/decommission/DecommissionController.java
+++ b/server/src/main/java/org/opensearch/cluster/decommission/DecommissionController.java
@@ -31,7 +31,6 @@
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.http.HttpStats;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
@@ -261,18 +260,6 @@ public NodesStatsResponse read(StreamInput in) throws IOException {
                     return new NodesStatsResponse(in);
                 }
 
-                @Override
-                public NodesStatsResponse read(CodedInputStream in) throws IOException {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'read'");
-                }
-
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
-
                 @Override
                 public NodesStatsResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/AliasMetadata.java b/server/src/main/java/org/opensearch/cluster/metadata/AliasMetadata.java
index 05ea4ff948386..7721bd4e148f7 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/AliasMetadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/AliasMetadata.java
@@ -66,7 +66,7 @@
  *
  * @opensearch.internal
  */
-public class AliasMetadata extends AbstractDiffable<AliasMetadata, AliasMetadata> implements ToXContentFragment {
+public class AliasMetadata extends AbstractDiffable<AliasMetadata> implements ToXContentFragment {
 
     private final String alias;
 
@@ -434,9 +434,4 @@ public static AliasMetadata fromXContent(XContentParser parser) throws IOExcepti
         }
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
-    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/ComponentTemplate.java b/server/src/main/java/org/opensearch/cluster/metadata/ComponentTemplate.java
index 03aedc2635e20..42e13ff65dcd9 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/ComponentTemplate.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/ComponentTemplate.java
@@ -59,7 +59,7 @@
  *
  * @opensearch.internal
  */
-public class ComponentTemplate extends AbstractDiffable<ComponentTemplate, ComponentTemplate> implements ToXContentObject {
+public class ComponentTemplate extends AbstractDiffable<ComponentTemplate> implements ToXContentObject {
     private static final ParseField TEMPLATE = new ParseField("template");
     private static final ParseField VERSION = new ParseField("version");
     private static final ParseField METADATA = new ParseField("_meta");
@@ -171,9 +171,4 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         return builder;
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
-    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java b/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java
index b7d7ffecd5001..823601058cf87 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java
@@ -67,7 +67,7 @@
  *
  * @opensearch.internal
  */
-public class ComposableIndexTemplate extends AbstractDiffable<ComposableIndexTemplate, ComposableIndexTemplate> implements ToXContentObject {
+public class ComposableIndexTemplate extends AbstractDiffable<ComposableIndexTemplate> implements ToXContentObject {
     private static final ParseField INDEX_PATTERNS = new ParseField("index_patterns");
     private static final ParseField TEMPLATE = new ParseField("template");
     private static final ParseField PRIORITY = new ParseField("priority");
@@ -361,9 +361,4 @@ public int hashCode() {
         }
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
-    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/DataStream.java b/server/src/main/java/org/opensearch/cluster/metadata/DataStream.java
index 391f005e224d1..95aa0a935345d 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/DataStream.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/DataStream.java
@@ -63,7 +63,7 @@
  *
  * @opensearch.internal
  */
-public final class DataStream extends AbstractDiffable<DataStream, DataStream> implements ToXContentObject {
+public final class DataStream extends AbstractDiffable<DataStream> implements ToXContentObject {
 
     public static final String BACKING_INDEX_PREFIX = ".ds-";
     public static final String TIMESERIES_FIELDNAME = "@timestamp";
@@ -321,9 +321,4 @@ public int hashCode() {
         }
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
-    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java b/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java
index bb286cde40781..95cbc8e108baf 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java
@@ -68,7 +68,7 @@
  *
  * @opensearch.internal
  */
-public class IndexTemplateMetadata extends AbstractDiffable<IndexTemplateMetadata, IndexTemplateMetadata> {
+public class IndexTemplateMetadata extends AbstractDiffable<IndexTemplateMetadata> {
 
     private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(IndexTemplateMetadata.class);
 
@@ -544,10 +544,4 @@ private static String skipTemplateName(XContentParser parser) throws IOException
         }
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
-    }
-
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/MappingMetadata.java b/server/src/main/java/org/opensearch/cluster/metadata/MappingMetadata.java
index 2074511a1f075..162c1d5a38b40 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/MappingMetadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/MappingMetadata.java
@@ -45,8 +45,6 @@
 import org.opensearch.index.mapper.DocumentMapper;
 import org.opensearch.index.mapper.MapperService;
 
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.util.Collections;
@@ -60,7 +58,7 @@
  *
  * @opensearch.internal
  */
-public class MappingMetadata extends AbstractDiffable<MappingMetadata, MappingMetadata> {
+public class MappingMetadata extends AbstractDiffable<MappingMetadata> {
     public static final MappingMetadata EMPTY_MAPPINGS = new MappingMetadata(MapperService.SINGLE_MAPPING_NAME, Collections.emptyMap());
 
     private final String type;
@@ -194,9 +192,4 @@ public static Diff<MappingMetadata> readDiffFrom(StreamInput in) throws IOExcept
         return readDiffFrom(MappingMetadata::new, in);
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
-    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/Template.java b/server/src/main/java/org/opensearch/cluster/metadata/Template.java
index 326711ffc8274..9db260e9bb481 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/Template.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/Template.java
@@ -63,7 +63,7 @@
  *
  * @opensearch.internal
  */
-public class Template extends AbstractDiffable<Template, Template> implements ToXContentObject {
+public class Template extends AbstractDiffable<Template> implements ToXContentObject {
     private static final ParseField SETTINGS = new ParseField("settings");
     private static final ParseField MAPPINGS = new ParseField("mappings");
     private static final ParseField ALIASES = new ParseField("aliases");
@@ -217,9 +217,4 @@ private static Map<String, Object> reduceMapping(Map<String, Object> mapping) {
         }
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
-    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
index 3b46495e443fc..2fa1ef93db94c 100644
--- a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
+++ b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
@@ -34,8 +34,6 @@
 
 import org.opensearch.Version;
 import org.opensearch.common.UUIDs;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
@@ -72,7 +70,7 @@
  *
  * @opensearch.internal
  */
-public class DiscoveryNode implements Writeable, ProtobufWriteable, ToXContentFragment {
+public class DiscoveryNode implements Writeable, ToXContentFragment {
 
     static final String COORDINATING_ONLY = "coordinating_only";
 
@@ -353,51 +351,6 @@ public DiscoveryNode(StreamInput in) throws IOException {
         this.version = in.readVersion();
     }
 
-    /**
-     * Creates a new {@link DiscoveryNode} by reading from the stream provided as argument
-    * @param in the stream
-    * @throws IOException if there is an error while reading from the stream
-    */
-    public DiscoveryNode(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        this.nodeName = in.readString();
-        this.nodeId = in.readString();
-        this.ephemeralId = in.readString();
-        this.hostName = in.readString();
-        this.hostAddress = in.readString();
-        this.address = new TransportAddress(in);
-        int size = in.readInt32();
-        this.attributes = new HashMap<>(size);
-        for (int i = 0; i < size; i++) {
-            this.attributes.put(in.readString(), in.readString());
-        }
-        int rolesSize = in.readInt32();
-        final Set<DiscoveryNodeRole> roles = new HashSet<>(rolesSize);
-        for (int i = 0; i < rolesSize; i++) {
-            final String roleName = in.readString();
-            final String roleNameAbbreviation = in.readString();
-            final boolean canContainData = in.readBool();
-            final DiscoveryNodeRole role = roleMap.get(roleName);
-            if (role == null) {
-                if (protobufStreamInput.getVersion().onOrAfter(Version.V_2_1_0)) {
-                    roles.add(new DiscoveryNodeRole.DynamicRole(roleName, roleNameAbbreviation, canContainData));
-                } else {
-                    roles.add(new DiscoveryNodeRole.UnknownRole(roleName, roleNameAbbreviation, canContainData));
-                }
-            } else {
-                assert roleName.equals(role.roleName()) : "role name [" + roleName + "] does not match role [" + role.roleName() + "]";
-                assert roleNameAbbreviation.equals(role.roleNameAbbreviation()) : "role name abbreviation ["
-                    + roleName
-                    + "] does not match role ["
-                    + role.roleNameAbbreviation()
-                    + "]";
-                roles.add(role);
-            }
-        }
-        this.roles = Collections.unmodifiableSortedSet(new TreeSet<>(roles));
-        this.version = Version.readVersionProtobuf(in);
-    }
-
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         out.writeString(nodeName);
@@ -421,30 +374,6 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeVersion(version);
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeStringNoTag(nodeName);
-        out.writeStringNoTag(nodeId);
-        out.writeStringNoTag(ephemeralId);
-        out.writeStringNoTag(hostName);
-        out.writeStringNoTag(hostAddress);
-        address.writeTo(out);
-        out.writeInt32NoTag(attributes.size());
-        for (Map.Entry<String, String> entry : attributes.entrySet()) {
-            out.writeStringNoTag(entry.getKey());
-            out.writeStringNoTag(entry.getValue());
-        }
-        out.writeInt32NoTag(roles.size());
-        for (final DiscoveryNodeRole role : roles) {
-            final DiscoveryNodeRole compatibleRole = role.getCompatibilityRole(protobufStreamOutput.getVersion());
-            out.writeStringNoTag(compatibleRole.roleName());
-            out.writeStringNoTag(compatibleRole.roleNameAbbreviation());
-            out.writeBoolNoTag(compatibleRole.canContainData());
-        }
-        out.writeInt32NoTag(version.id);
-    }
-
     /**
      * The address that the node can be communicated with.
      */
diff --git a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java
index 1916da47e2f00..b20519ae644fa 100644
--- a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java
+++ b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java
@@ -32,14 +32,9 @@
 
 package org.opensearch.cluster.node;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import org.opensearch.Version;
 import org.opensearch.cluster.AbstractDiffable;
 import org.opensearch.cluster.Diff;
-import org.opensearch.cluster.ProtobufAbstractDiffable;
-import org.opensearch.cluster.ProtobufDiff;
 import org.opensearch.common.Booleans;
 import org.opensearch.common.Nullable;
 import org.opensearch.core.common.io.stream.StreamInput;
@@ -48,8 +43,6 @@
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.util.set.Sets;
 import org.opensearch.core.common.Strings;
-import org.opensearch.discovery.Discovery;
-
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -70,7 +63,7 @@
  *
  * @opensearch.internal
  */
-public class DiscoveryNodes extends AbstractDiffable<DiscoveryNodes, DiscoveryNodes> implements Iterable<DiscoveryNode> {
+public class DiscoveryNodes extends AbstractDiffable<DiscoveryNodes> implements Iterable<DiscoveryNode> {
 
     public static final DiscoveryNodes EMPTY_NODES = builder().build();
 
@@ -703,19 +696,6 @@ public void writeTo(StreamOutput out) throws IOException {
         }
     }
 
-    public void writeTo(CodedOutputStream out) throws IOException {
-        if (clusterManagerNodeId == null) {
-            out.writeBoolNoTag(false);
-        } else {
-            out.writeBoolNoTag(true);
-            out.writeStringNoTag(clusterManagerNodeId);
-        }
-        out.writeInt32NoTag(nodes.size());
-        for (DiscoveryNode node : this) {
-            node.writeTo(out);
-        }
-    }
-
     public static DiscoveryNodes readFrom(StreamInput in, DiscoveryNode localNode) throws IOException {
         Builder builder = new Builder();
         if (in.readBoolean()) {
@@ -739,37 +719,10 @@ public static DiscoveryNodes readFrom(StreamInput in, DiscoveryNode localNode) t
         return builder.build();
     }
 
-    public static DiscoveryNodes readFromProtobuf(CodedInputStream in, DiscoveryNode localNode) throws IOException {
-        Builder builder = new Builder();
-        if (in.readBool()) {
-            builder.clusterManagerNodeId(in.readString());
-        }
-        if (localNode != null) {
-            builder.localNodeId(localNode.getId());
-        }
-        int size = in.readInt32();
-        for (int i = 0; i < size; i++) {
-            DiscoveryNode node = new DiscoveryNode(in);
-            if (localNode != null && node.getId().equals(localNode.getId())) {
-                // reuse the same instance of our address and local node id for faster equality
-                node = localNode;
-            }
-            // some one already built this and validated it's OK, skip the n2 scans
-            assert builder.validateAdd(node) == null : "building disco nodes from network doesn't pass preflight: "
-                + builder.validateAdd(node);
-            builder.putUnsafe(node);
-        }
-        return builder.build();
-    }
-
     public static Diff<DiscoveryNodes> readDiffFrom(StreamInput in, DiscoveryNode localNode) throws IOException {
         return AbstractDiffable.readDiffFrom(in1 -> readFrom(in1, localNode), in);
     }
 
-    public static ProtobufDiff<DiscoveryNodes> readDiffFrom(CodedInputStream in, DiscoveryNode localNode) throws IOException {
-        return AbstractDiffable.readDiffFromProtobuf(in1 -> readFromProtobuf(in1, localNode), in);
-    }
-
     public static Builder builder() {
         return new Builder();
     }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/AllocationId.java b/server/src/main/java/org/opensearch/cluster/routing/AllocationId.java
index 3965f1f72f668..5cb8a8e04613a 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/AllocationId.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/AllocationId.java
@@ -38,8 +38,6 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.xcontent.ObjectParser;
 import org.opensearch.core.xcontent.ToXContentObject;
@@ -63,7 +61,7 @@
  *
  * @opensearch.internal
  */
-public class AllocationId implements ToXContentObject, Writeable, ProtobufWriteable {
+public class AllocationId implements ToXContentObject, Writeable {
     private static final String ID_KEY = "id";
     private static final String RELOCATION_ID_KEY = "relocation_id";
 
@@ -100,25 +98,12 @@ public AllocationId build() {
         this.relocationId = in.readOptionalString();
     }
 
-    AllocationId(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        this.id = in.readString();
-        this.relocationId = protobufStreamInput.readOptionalString();
-    }
-
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         out.writeString(this.id);
         out.writeOptionalString(this.relocationId);
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeStringNoTag(this.id);
-        protobufStreamOutput.writeOptionalString(this.relocationId);
-    }
-
     private AllocationId(String id, String relocationId) {
         Objects.requireNonNull(id, "Argument [id] must be non-null");
         this.id = id;
diff --git a/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java b/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java
index 3462b58507f0a..b9077465a7504 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java
@@ -32,8 +32,6 @@
 
 package org.opensearch.cluster.routing;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 
 import org.apache.lucene.util.CollectionUtil;
 import org.opensearch.cluster.AbstractDiffable;
@@ -80,7 +78,7 @@
  *
  * @opensearch.internal
  */
-public class IndexRoutingTable extends AbstractDiffable<IndexRoutingTable, IndexRoutingTable> implements Iterable<IndexShardRoutingTable> {
+public class IndexRoutingTable extends AbstractDiffable<IndexRoutingTable> implements Iterable<IndexShardRoutingTable> {
 
     private final Index index;
     private final ShardShuffler shuffler;
@@ -350,18 +348,6 @@ public static IndexRoutingTable readFrom(StreamInput in) throws IOException {
         return builder.build();
     }
 
-    public static IndexRoutingTable readFrom(CodedInputStream in) throws IOException {
-        Index index = new Index(in);
-        Builder builder = new Builder(index);
-
-        int size = in.readInt32();
-        for (int i = 0; i < size; i++) {
-            builder.addIndexShard(IndexShardRoutingTable.Builder.readFromThin(in, index));
-        }
-
-        return builder.build();
-    }
-
     public static Diff<IndexRoutingTable> readDiffFrom(StreamInput in) throws IOException {
         return readDiffFrom(IndexRoutingTable::readFrom, in);
     }
@@ -677,10 +663,4 @@ public String prettyPrint() {
         return sb.toString();
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
-    }
-
 }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java b/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java
index 423b841f0939d..f9f57eeda4e98 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java
@@ -47,8 +47,6 @@
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.node.ResponseCollectorService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -1052,20 +1050,6 @@ public static IndexShardRoutingTable readFromThin(StreamInput in, Index index) t
             return builder.build();
         }
 
-        public static IndexShardRoutingTable readFromThin(CodedInputStream in, Index index) throws IOException {
-            int iShardId = in.readInt32();
-            ShardId shardId = new ShardId(index, iShardId);
-            Builder builder = new Builder(shardId);
-
-            int size = in.readInt32();
-            for (int i = 0; i < size; i++) {
-                ShardRouting shard = new ShardRouting(shardId, in);
-                builder.addShard(shard);
-            }
-
-            return builder.build();
-        }
-
         public static void writeTo(IndexShardRoutingTable indexShard, StreamOutput out) throws IOException {
             indexShard.shardId().getIndex().writeTo(out);
             writeToThin(indexShard, out);
diff --git a/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java b/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java
index 9c8328f5a529c..5502317c51d2b 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java
@@ -384,18 +384,6 @@ public static RoutingTable readFrom(StreamInput in) throws IOException {
         return builder.build();
     }
 
-    public static RoutingTable readFrom(CodedInputStream in) throws IOException {
-        Builder builder = new Builder();
-        builder.version = in.readInt64();
-        int size = in.readInt32();
-        for (int i = 0; i < size; i++) {
-            IndexRoutingTable index = IndexRoutingTable.readFrom(in);
-            builder.add(index);
-        }
-
-        return builder.build();
-    }
-
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         out.writeLong(version);
diff --git a/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java b/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java
index f047ad4d60310..18d093ad78708 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java
@@ -36,8 +36,6 @@
 import org.opensearch.cluster.routing.RecoverySource.PeerRecoverySource;
 import org.opensearch.cluster.routing.allocation.allocator.BalancedShardsAllocator;
 import org.opensearch.common.Nullable;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
@@ -60,7 +58,7 @@
  *
  * @opensearch.internal
  */
-public class ShardRouting implements Writeable, ToXContentObject, ProtobufWriteable {
+public class ShardRouting implements Writeable, ToXContentObject {
 
     /**
      * Used if shard size is not available
@@ -329,35 +327,10 @@ public ShardRouting(ShardId shardId, StreamInput in) throws IOException {
         targetRelocatingShard = initializeTargetRelocatingShard();
     }
 
-    public ShardRouting(ShardId shardId, CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        this.shardId = shardId;
-        currentNodeId = protobufStreamInput.readOptionalString();
-        relocatingNodeId = protobufStreamInput.readOptionalString();
-        primary = in.readBool();
-        state = ShardRoutingState.fromValue(in.readRawByte());
-        recoverySource = null;
-        unassignedInfo = protobufStreamInput.readOptionalWriteable(UnassignedInfo::new);
-        allocationId = protobufStreamInput.readOptionalWriteable(AllocationId::new);
-        final long shardSize;
-        if (state == ShardRoutingState.RELOCATING || state == ShardRoutingState.INITIALIZING) {
-            shardSize = in.readInt64();
-        } else {
-            shardSize = UNAVAILABLE_EXPECTED_SHARD_SIZE;
-        }
-        expectedShardSize = shardSize;
-        asList = Collections.singletonList(this);
-        targetRelocatingShard = initializeTargetRelocatingShard();
-    }
-
     public ShardRouting(StreamInput in) throws IOException {
         this(new ShardId(in), in);
     }
 
-    public ShardRouting(CodedInputStream in) throws IOException {
-        this(new ShardId(in), in);
-    }
-
     /**
      * Writes shard information to {@link StreamOutput} without writing index name and shard id
      *
@@ -379,40 +352,12 @@ public void writeToThin(StreamOutput out) throws IOException {
         }
     }
 
-    /**
-     * Writes shard information to without writing index name and shard id
-     *
-     * @param out to write shard information to
-     * @throws IOException if something happens during write
-     */
-    public void writeToThin(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeOptionalString(currentNodeId);
-        protobufStreamOutput.writeOptionalString(relocatingNodeId);
-        out.writeBoolNoTag(primary);
-        out.write(state.value());
-        // if (state == ShardRoutingState.UNASSIGNED || state == ShardRoutingState.INITIALIZING) {
-        // recoverySource.writeTo(out);
-        // }
-        protobufStreamOutput.writeOptionalWriteable(unassignedInfo);
-        protobufStreamOutput.writeOptionalWriteable(allocationId);
-        if (state == ShardRoutingState.RELOCATING || state == ShardRoutingState.INITIALIZING) {
-            out.writeInt64NoTag(expectedShardSize);
-        }
-    }
-
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         shardId.writeTo(out);
         writeToThin(out);
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        shardId.writeTo(out);
-        writeToThin(out);
-    }
-
     public ShardRouting updateUnassigned(UnassignedInfo unassignedInfo, RecoverySource recoverySource) {
         assert this.unassignedInfo != null : "can only update unassign info if they are already set";
         assert this.unassignedInfo.isDelayed() || (unassignedInfo.isDelayed() == false) : "cannot transition from non-delayed to delayed";
diff --git a/server/src/main/java/org/opensearch/cluster/routing/UnassignedInfo.java b/server/src/main/java/org/opensearch/cluster/routing/UnassignedInfo.java
index 3de86101e3de3..80a2470ac53ea 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/UnassignedInfo.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/UnassignedInfo.java
@@ -38,8 +38,6 @@
 import org.opensearch.cluster.routing.allocation.RoutingAllocation;
 import org.opensearch.cluster.routing.allocation.decider.Decision;
 import org.opensearch.common.Nullable;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
@@ -71,7 +69,7 @@
  *
  * @opensearch.internal
  */
-public final class UnassignedInfo implements ToXContentFragment, Writeable, ProtobufWriteable {
+public final class UnassignedInfo implements ToXContentFragment, Writeable {
 
     public static final DateFormatter DATE_TIME_FORMATTER = DateFormatter.forPattern("date_optional_time").withZone(ZoneOffset.UTC);
 
@@ -166,7 +164,7 @@ public enum Reason {
      *
      * @opensearch.internal
      */
-    public enum AllocationStatus implements Writeable, ProtobufWriteable {
+    public enum AllocationStatus implements Writeable {
         /**
          * The shard was denied allocation to a node because the allocation deciders all returned a NO decision
          */
@@ -204,11 +202,6 @@ public void writeTo(StreamOutput out) throws IOException {
             out.writeByte(id);
         }
 
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.write(id);
-        }
-
         public static AllocationStatus readFrom(StreamInput in) throws IOException {
             byte id = in.readByte();
             switch (id) {
@@ -348,21 +341,6 @@ public UnassignedInfo(StreamInput in) throws IOException {
         this.failedNodeIds = Collections.unmodifiableSet(in.readSet(StreamInput::readString));
     }
 
-    public UnassignedInfo(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        this.reason = Reason.values()[(int) in.readRawByte()];
-        this.unassignedTimeMillis = in.readInt64();
-        // As System.nanoTime() cannot be compared across different JVMs, reset it to now.
-        // This means that in cluster-manager fail-over situations, elapsed delay time is forgotten.
-        this.unassignedTimeNanos = System.nanoTime();
-        this.delayed = in.readBool();
-        this.message = protobufStreamInput.readOptionalString();
-        this.failure = protobufStreamInput.readException();
-        this.failedAllocations = in.readInt32();
-        this.lastAllocationStatus = AllocationStatus.readFrom(in);
-        this.failedNodeIds = protobufStreamInput.readCollection(CodedInputStream::readString, HashSet::new, Collections.emptySet());
-    }
-
     public void writeTo(StreamOutput out) throws IOException {
         out.writeByte((byte) reason.ordinal());
         out.writeLong(unassignedTimeMillis);
@@ -375,19 +353,6 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeCollection(failedNodeIds, StreamOutput::writeString);
     }
 
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.write((byte) reason.ordinal());
-        out.writeInt64NoTag(unassignedTimeMillis);
-        // Do not serialize unassignedTimeNanos as System.nanoTime() cannot be compared across different JVMs
-        out.writeBoolNoTag(delayed);
-        protobufStreamOutput.writeOptionalString(message);
-        protobufStreamOutput.writeException(failure);
-        out.writeInt32NoTag(failedAllocations);
-        lastAllocationStatus.writeTo(out);
-        protobufStreamOutput.writeCollection(failedNodeIds, CodedOutputStream::writeStringNoTag);
-    }
-
     /**
      * Returns the number of previously failed allocations of this shard.
      */
diff --git a/server/src/main/java/org/opensearch/common/ProtobufFieldMemoryStats.java b/server/src/main/java/org/opensearch/common/ProtobufFieldMemoryStats.java
deleted file mode 100644
index 511f8deea3a97..0000000000000
--- a/server/src/main/java/org/opensearch/common/ProtobufFieldMemoryStats.java
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.common;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import com.carrotsearch.hppc.ObjectLongHashMap;
-import com.carrotsearch.hppc.cursors.ObjectLongCursor;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.util.Iterator;
-import java.util.Objects;
-
-/**
- * A reusable class to encode {@code field -&gt; memory size} mappings
-*
-* @opensearch.internal
-*/
-public final class ProtobufFieldMemoryStats implements ProtobufWriteable, Iterable<ObjectLongCursor<String>> {
-
-    private final ObjectLongHashMap<String> stats;
-
-    /**
-     * Creates a new ProtobufFieldMemoryStats instance
-    */
-    public ProtobufFieldMemoryStats(ObjectLongHashMap<String> stats) {
-        this.stats = Objects.requireNonNull(stats, "status must be non-null");
-        assert !stats.containsKey(null);
-    }
-
-    /**
-     * Creates a new ProtobufFieldMemoryStats instance from a stream
-    */
-    public ProtobufFieldMemoryStats(CodedInputStream input) throws IOException {
-        int size = input.readInt32();
-        stats = new ObjectLongHashMap<>(size);
-        for (int i = 0; i < size; i++) {
-            stats.put(input.readString(), input.readInt64());
-        }
-    }
-
-    /**
-     * Adds / merges the given field memory stats into this stats instance
-    */
-    public void add(ProtobufFieldMemoryStats fieldMemoryStats) {
-        for (ObjectLongCursor<String> entry : fieldMemoryStats.stats) {
-            stats.addTo(entry.key, entry.value);
-        }
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt32NoTag(stats.size());
-        for (ObjectLongCursor<String> entry : stats) {
-            out.writeStringNoTag(entry.key);
-            out.writeInt64NoTag(entry.value);
-        }
-    }
-
-    /**
-     * Generates x-content into the given builder for each of the fields in this stats instance
-    * @param builder the builder to generated on
-    * @param key the top level key for this stats object
-    * @param rawKey the raw byte key for each of the fields byte sizes
-    * @param readableKey the readable key for each of the fields byte sizes
-    */
-    public void toXContent(XContentBuilder builder, String key, String rawKey, String readableKey) throws IOException {
-        builder.startObject(key);
-        for (ObjectLongCursor<String> entry : stats) {
-            builder.startObject(entry.key);
-            builder.humanReadableField(rawKey, readableKey, new ByteSizeValue(entry.value));
-            builder.endObject();
-        }
-        builder.endObject();
-    }
-
-    /**
-     * Creates a deep copy of this stats instance
-    */
-    public ProtobufFieldMemoryStats copy() {
-        return new ProtobufFieldMemoryStats(stats.clone());
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        ProtobufFieldMemoryStats that = (ProtobufFieldMemoryStats) o;
-        return Objects.equals(stats, that.stats);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(stats);
-    }
-
-    @Override
-    public Iterator<ObjectLongCursor<String>> iterator() {
-        return stats.iterator();
-    }
-
-    /**
-     * Returns the fields value in bytes or <code>0</code> if it's not present in the stats
-    */
-    public long get(String field) {
-        return stats.get(field);
-    }
-
-    /**
-     * Returns <code>true</code> iff the given field is in the stats
-    */
-    public boolean containsField(String field) {
-        return stats.containsKey(field);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufNotSerializableExceptionWrapper.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufNotSerializableExceptionWrapper.java
deleted file mode 100644
index 2552fbf099f1f..0000000000000
--- a/server/src/main/java/org/opensearch/common/io/stream/ProtobufNotSerializableExceptionWrapper.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.common.io.stream;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.ProtobufOpenSearchException;
-import org.opensearch.ExceptionsHelper;
-import org.opensearch.rest.RestStatus;
-
-import java.io.IOException;
-
-/**
- * This exception can be used to wrap a given, not serializable exception
-* to serialize via {@link ProtobufStreamOutput#writeException(Throwable)}.
-* This class will preserve the stacktrace as well as the suppressed exceptions of
-* the throwable it was created with instead of it's own. The stacktrace has no indication
-* of where this exception was created.
-*
-* @opensearch.internal
-*/
-public final class ProtobufNotSerializableExceptionWrapper extends ProtobufOpenSearchException {
-
-    private final String name;
-    private final RestStatus status;
-
-    public ProtobufNotSerializableExceptionWrapper(Throwable other) {
-        super(ProtobufOpenSearchException.getExceptionName(other) + ": " + other.getMessage(), other.getCause());
-        this.name = ProtobufOpenSearchException.getExceptionName(other);
-        this.status = ExceptionsHelper.status(other);
-        setStackTrace(other.getStackTrace());
-        for (Throwable otherSuppressed : other.getSuppressed()) {
-            addSuppressed(otherSuppressed);
-        }
-        if (other instanceof ProtobufOpenSearchException) {
-            ProtobufOpenSearchException ex = (ProtobufOpenSearchException) other;
-            for (String key : ex.getHeaderKeys()) {
-                this.addHeader(key, ex.getHeader(key));
-            }
-            for (String key : ex.getMetadataKeys()) {
-                this.addMetadata(key, ex.getMetadata(key));
-            }
-        }
-    }
-
-    public ProtobufNotSerializableExceptionWrapper(CodedInputStream in) throws IOException {
-        super(in);
-        name = in.readString();
-        status = RestStatus.readFromProtobuf(in);
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        super.writeTo(out);
-        out.writeStringNoTag(name);
-        RestStatus.writeToProtobuf(out, status);
-    }
-
-    @Override
-    protected String getExceptionName() {
-        return name;
-    }
-
-    @Override
-    public RestStatus status() {
-        return status;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java
deleted file mode 100644
index 4caed83b07941..0000000000000
--- a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamInput.java
+++ /dev/null
@@ -1,436 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.common.io.stream;
-
-import com.google.protobuf.CodedInputStream;
-
-import java.io.IOException;
-import java.nio.file.AccessDeniedException;
-import java.nio.file.AtomicMoveNotSupportedException;
-import java.nio.file.DirectoryNotEmptyException;
-import java.nio.file.FileAlreadyExistsException;
-import java.nio.file.FileSystemException;
-import java.nio.file.FileSystemLoopException;
-import java.nio.file.NoSuchFileException;
-import java.nio.file.NotDirectoryException;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.EnumSet;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.concurrent.TimeUnit;
-import java.util.function.IntFunction;
-
-import org.apache.lucene.util.ArrayUtil;
-
-import org.opensearch.common.bytes.BytesArray;
-import org.opensearch.common.bytes.BytesReference;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.ProtobufOpenSearchException;
-import org.opensearch.Version;
-import org.opensearch.common.Nullable;
-import org.opensearch.common.Strings;
-
-import static org.opensearch.ProtobufOpenSearchException.readStackTrace;
-
-/**
- * A class for additional methods to read from a {@link CodedInputStream}.
- */
-public class ProtobufStreamInput {
-
-    private CodedInputStream in;
-    private Version version = Version.CURRENT;
-
-    private static final TimeUnit[] TIME_UNITS = TimeUnit.values();
-
-    public ProtobufStreamInput(CodedInputStream in) {
-        this.in = in;
-    }
-
-    /**
-     * The version of the node on the other side of this stream.
-     */
-    public Version getVersion() {
-        return this.version;
-    }
-
-    /**
-     * Set the version of the node on the other side of this stream.
-     */
-    public void setVersion(Version version) {
-        this.version = version;
-    }
-
-    @Nullable
-    public String readOptionalString() throws IOException {
-        if (readBoolean()) {
-            return this.in.readString();
-        }
-        return null;
-    }
-
-    @Nullable
-    public Long readOptionalLong() throws IOException {
-        if (readBoolean()) {
-            return this.in.readInt64();
-        }
-        return null;
-    }
-
-    @Nullable
-    public final Boolean readOptionalBoolean() throws IOException {
-        final byte value = this.in.readRawByte();
-        if (value == 2) {
-            return null;
-        } else {
-            return readBoolean(value);
-        }
-    }
-
-    /**
-     * If the returned map contains any entries it will be mutable. If it is empty it might be immutable.
-     */
-    public <K, V> Map<K, V> readMap(ProtobufWriteable.Reader<K> keyReader, ProtobufWriteable.Reader<V> valueReader) throws IOException {
-        int size = readArraySize();
-        if (size == 0) {
-            return Collections.emptyMap();
-        }
-        Map<K, V> map = new HashMap<>(size);
-        for (int i = 0; i < size; i++) {
-            K key = keyReader.read(this.in);
-            V value = valueReader.read(this.in);
-            map.put(key, value);
-        }
-        return map;
-    }
-
-    @Nullable
-    public <T extends ProtobufWriteable> T readOptionalWriteable(ProtobufWriteable.Reader<T> reader) throws IOException {
-        if (readBoolean()) {
-            T t = reader.read(this.in);
-            if (t == null) {
-                throw new IOException(
-                    "Writeable.Reader [" + reader + "] returned null which is not allowed and probably means it screwed up the stream."
-                );
-            }
-            return t;
-        } else {
-            return null;
-        }
-    }
-
-    private int readArraySize() throws IOException {
-        final int arraySize = readVInt();
-        if (arraySize > ArrayUtil.MAX_ARRAY_LENGTH) {
-            throw new IllegalStateException("array length must be <= to " + ArrayUtil.MAX_ARRAY_LENGTH + " but was: " + arraySize);
-        }
-        if (arraySize < 0) {
-            throw new NegativeArraySizeException("array size must be positive but was: " + arraySize);
-        }
-        // lets do a sanity check that if we are reading an array size that is bigger that the remaining bytes we can safely
-        // throw an exception instead of allocating the array based on the size. A simple corrutpted byte can make a node go OOM
-        // if the size is large and for perf reasons we allocate arrays ahead of time
-        // ensureCanReadBytes(arraySize);
-        return arraySize;
-    }
-
-    public int readVInt() throws IOException {
-        byte b = this.in.readRawByte();
-        int i = b & 0x7F;
-        if ((b & 0x80) == 0) {
-            return i;
-        }
-        b = this.in.readRawByte();
-        i |= (b & 0x7F) << 7;
-        if ((b & 0x80) == 0) {
-            return i;
-        }
-        b = this.in.readRawByte();
-        i |= (b & 0x7F) << 14;
-        if ((b & 0x80) == 0) {
-            return i;
-        }
-        b = this.in.readRawByte();
-        i |= (b & 0x7F) << 21;
-        if ((b & 0x80) == 0) {
-            return i;
-        }
-        b = this.in.readRawByte();
-        if ((b & 0x80) != 0) {
-            throw new IOException("Invalid vInt ((" + Integer.toHexString(b) + " & 0x7f) << 28) | " + Integer.toHexString(i));
-        }
-        return i | ((b & 0x7F) << 28);
-    }
-
-    /**
-     * Reads a boolean.
-     */
-    public final boolean readBoolean() throws IOException {
-        return readBoolean(this.in.readRawByte());
-    }
-
-    /**
-     * Reads an optional bytes reference from this stream. It might hold an actual reference to the underlying bytes of the stream. Use this
-     * only if you must differentiate null from empty.
-     */
-    @Nullable
-    public BytesReference readOptionalBytesReference() throws IOException {
-        int length = readVInt() - 1;
-        if (length < 0) {
-            return null;
-        }
-        return readBytesReference(length);
-    }
-
-    /**
-     * Reads a bytes reference from this stream, might hold an actual reference to the underlying
-     * bytes of the stream.
-     */
-    public BytesReference readBytesReference() throws IOException {
-        int length = readArraySize();
-        return readBytesReference(length);
-    }
-
-    /**
-     * Reads a bytes reference from this stream, might hold an actual reference to the underlying
-     * bytes of the stream.
-     */
-    public BytesReference readBytesReference(int length) throws IOException {
-        if (length == 0) {
-            return BytesArray.EMPTY;
-        }
-        byte[] bytes = new byte[length];
-        bytes = this.in.readByteArray();
-        return new BytesArray(bytes, 0, length);
-    }
-
-    /**
-     * Read a {@link TimeValue} from the stream
-     */
-    public TimeValue readTimeValue() throws IOException {
-        long duration = this.in.readInt64();
-        TimeUnit timeUnit = TIME_UNITS[this.in.readRawByte()];
-        return new TimeValue(duration, timeUnit);
-    }
-
-    public String[] readStringArray() throws IOException {
-        int size = readArraySize();
-        if (size == 0) {
-            return Strings.EMPTY_ARRAY;
-        }
-        String[] ret = new String[size];
-        for (int i = 0; i < size; i++) {
-            ret[i] = this.in.readString();
-        }
-        return ret;
-    }
-
-    /**
-    * Reads an enum with type E that was serialized based on the value of its ordinal
-    */
-    public <E extends Enum<E>> E readEnum(Class<E> enumClass) throws IOException {
-        return readEnum(enumClass, enumClass.getEnumConstants());
-    }
-
-    private <E extends Enum<E>> E readEnum(Class<E> enumClass, E[] values) throws IOException {
-        int ordinal = readVInt();
-        if (ordinal < 0 || ordinal >= values.length) {
-            throw new IOException("Unknown " + enumClass.getSimpleName() + " ordinal [" + ordinal + "]");
-        }
-        return values[ordinal];
-    }
-
-    /**
-     * Reads an enum with type E that was serialized based on the value of it's ordinal
-     */
-    public <E extends Enum<E>> EnumSet<E> readEnumSet(Class<E> enumClass) throws IOException {
-        int size = readVInt();
-        final EnumSet<E> res = EnumSet.noneOf(enumClass);
-        if (size == 0) {
-            return res;
-        }
-        final E[] values = enumClass.getEnumConstants();
-        for (int i = 0; i < size; i++) {
-            res.add(readEnum(enumClass, values));
-        }
-        return res;
-    }
-
-    private boolean readBoolean(final byte value) {
-        if (value == 0) {
-            return false;
-        } else if (value == 1) {
-            return true;
-        } else {
-            final String message = String.format(Locale.ROOT, "unexpected byte [0x%02x]", value);
-            throw new IllegalStateException(message);
-        }
-    }
-
-    /**
-     * Reads a list of objects. The list is expected to have been written using {@link StreamOutput#writeList(List)}.
-     * If the returned list contains any entries it will be mutable. If it is empty it might be immutable.
-     *
-     * @return the list of objects
-     * @throws IOException if an I/O exception occurs reading the list
-     */
-    public <T> List<T> readList(final ProtobufWriteable.Reader<T> reader) throws IOException {
-        return readCollection(reader, ArrayList::new, Collections.emptyList());
-    }
-
-    /**
-     * Reads a collection of objects
-     */
-    public <T, C extends Collection<? super T>> C readCollection(ProtobufWriteable.Reader<T> reader, IntFunction<C> constructor, C empty)
-        throws IOException {
-        int count = readArraySize();
-        if (count == 0) {
-            return empty;
-        }
-        C builder = constructor.apply(count);
-        for (int i = 0; i < count; i++) {
-            builder.add(reader.read(this.in));
-        }
-        return builder;
-    }
-
-    /**
-     * Reads a {@link NamedWriteable} from the current stream, by first reading its name and then looking for
-     * the corresponding entry in the registry by name, so that the proper object can be read and returned.
-     * Default implementation throws {@link UnsupportedOperationException} as StreamInput doesn't hold a registry.
-     */
-    @Nullable
-    public <C extends ProtobufNamedWriteable> C readNamedWriteable(@SuppressWarnings("unused") Class<C> categoryClass) throws IOException {
-        throw new UnsupportedOperationException("can't read named writeable from StreamInput");
-    }
-
-    /**
-     * Reads a {@link ProtobufNamedWriteable} from the current stream with the given name. It is assumed that the caller obtained the name
-     * from other source, so it's not read from the stream. The name is used for looking for
-     * the corresponding entry in the registry by name, so that the proper object can be read and returned.
-     * Default implementation throws {@link UnsupportedOperationException} as StreamInput doesn't hold a registry.
-     */
-    @Nullable
-    public <C extends ProtobufNamedWriteable> C readNamedWriteable(
-        @SuppressWarnings("unused") Class<C> categoryClass,
-        @SuppressWarnings("unused") String name
-    ) throws IOException {
-        throw new UnsupportedOperationException("can't read named writeable from StreamInput");
-    }
-
-    public <T> T[] readOptionalArray(ProtobufWriteable.Reader<T> reader, IntFunction<T[]> arraySupplier) throws IOException {
-        return readBoolean() ? readArray(reader, arraySupplier) : null;
-    }
-
-    public <T> T[] readArray(final ProtobufWriteable.Reader<T> reader, final IntFunction<T[]> arraySupplier) throws IOException {
-        final int length = readArraySize();
-        final T[] values = arraySupplier.apply(length);
-        for (int i = 0; i < length; i++) {
-            values[i] = reader.read(this.in);
-        }
-        return values;
-    }
-
-    /**
-     * Read an optional {@link TimeValue} from the stream, returning null if no TimeValue was written.
-     */
-    public @Nullable TimeValue readOptionalTimeValue() throws IOException {
-        if (readBoolean()) {
-            return readTimeValue();
-        } else {
-            return null;
-        }
-    }
-
-    @Nullable
-    @SuppressWarnings("unchecked")
-    public <T extends Exception> T readException() throws IOException {
-        if (readBoolean()) {
-            int key = readVInt();
-            switch (key) {
-                case 0:
-                    final int ord = readVInt();
-                    return (T) ProtobufOpenSearchException.readException(this.in, ord);
-                case 4:
-                    return (T) readStackTrace(new NullPointerException(readOptionalString()), this.in);
-                case 5:
-                    return (T) readStackTrace(new NumberFormatException(readOptionalString()), this.in);
-                case 6:
-                    return (T) readStackTrace(new IllegalArgumentException(readOptionalString(), readException()), this.in);
-                case 13:
-                    final int subclass = readVInt();
-                    final String file = readOptionalString();
-                    final String other = readOptionalString();
-                    final String reason = readOptionalString();
-                    readOptionalString(); // skip the msg - it's composed from file, other and reason
-                    final Exception exception;
-                    switch (subclass) {
-                        case 0:
-                            exception = new NoSuchFileException(file, other, reason);
-                            break;
-                        case 1:
-                            exception = new NotDirectoryException(file);
-                            break;
-                        case 2:
-                            exception = new DirectoryNotEmptyException(file);
-                            break;
-                        case 3:
-                            exception = new AtomicMoveNotSupportedException(file, other, reason);
-                            break;
-                        case 4:
-                            exception = new FileAlreadyExistsException(file, other, reason);
-                            break;
-                        case 5:
-                            exception = new AccessDeniedException(file, other, reason);
-                            break;
-                        case 6:
-                            exception = new FileSystemLoopException(file);
-                            break;
-                        case 7:
-                            exception = new FileSystemException(file, other, reason);
-                            break;
-                        default:
-                            throw new IllegalStateException("unknown FileSystemException with index " + subclass);
-                    }
-                    return (T) readStackTrace(exception, this.in);
-                case 14:
-                    return (T) readStackTrace(new IllegalStateException(readOptionalString(), readException()), this.in);
-                case 16:
-                    return (T) readStackTrace(new InterruptedException(readOptionalString()), this.in);
-                case 17:
-                    return (T) readStackTrace(new IOException(readOptionalString(), readException()), this.in);
-                default:
-                    throw new IOException("no such exception for id: " + key);
-            }
-        }
-        return null;
-    }
-
-    public short readShort() throws IOException {
-        return (short) (((this.in.readRawByte() & 0xFF) << 8) | (this.in.readRawByte() & 0xFF));
-    }
-
-    private static final double[] EMPTY_DOUBLE_ARRAY = new double[0];
-
-    public double[] readDoubleArray() throws IOException {
-        int length = readArraySize();
-        if (length == 0) {
-            return EMPTY_DOUBLE_ARRAY;
-        }
-        double[] values = new double[length];
-        for (int i = 0; i < length; i++) {
-            values[i] = this.in.readDouble();
-        }
-        return values;
-    }
-
-}
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java
deleted file mode 100644
index ab58c4ba749a1..0000000000000
--- a/server/src/main/java/org/opensearch/common/io/stream/ProtobufStreamOutput.java
+++ /dev/null
@@ -1,358 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.common.io.stream;
-
-import com.google.protobuf.CodedOutputStream;
-
-import java.io.EOFException;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.nio.file.AccessDeniedException;
-import java.nio.file.AtomicMoveNotSupportedException;
-import java.nio.file.DirectoryNotEmptyException;
-import java.nio.file.FileAlreadyExistsException;
-import java.nio.file.FileSystemException;
-import java.nio.file.FileSystemLoopException;
-import java.nio.file.NoSuchFileException;
-import java.nio.file.NotDirectoryException;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.EnumSet;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-import org.apache.lucene.store.AlreadyClosedException;
-import org.apache.lucene.store.LockObtainFailedException;
-import org.opensearch.ProtobufOpenSearchException;
-import org.opensearch.Version;
-import org.opensearch.common.Nullable;
-import org.opensearch.common.io.stream.ProtobufWriteable.Writer;
-import org.opensearch.common.unit.TimeValue;
-
-/**
- * A class for additional methods to write to a {@link CodedOutputStream}.
- */
-public class ProtobufStreamOutput {
-
-    private static final int MAX_NESTED_EXCEPTION_LEVEL = 100;
-    private CodedOutputStream out;
-    private Version version = Version.CURRENT;
-    private Set<String> features = Collections.emptySet();
-
-    public ProtobufStreamOutput(CodedOutputStream out) {
-        this.out = out;
-    }
-
-    /**
-     * The version of the node on the other side of this stream.
-     */
-    public Version getVersion() {
-        return this.version;
-    }
-
-    /**
-     * Set the version of the node on the other side of this stream.
-     */
-    public void setVersion(Version version) {
-        this.version = version;
-    }
-
-    /**
-     * Write a {@link Map} of {@code K}-type keys to {@code V}-type.
-     * <pre><code>
-     * Map&lt;String, String&gt; map = ...;
-     * out.writeMap(map, StreamOutput::writeString, StreamOutput::writeString);
-     * </code></pre>
-     *
-     * @param keyWriter The key writer
-     * @param valueWriter The value writer
-     */
-    public final <K, V> void writeMap(
-        final Map<K, V> map,
-        final ProtobufWriteable.Writer<K> keyWriter,
-        final ProtobufWriteable.Writer<V> valueWriter
-    ) throws IOException {
-        for (final Map.Entry<K, V> entry : map.entrySet()) {
-            keyWriter.write(this.out, entry.getKey());
-            valueWriter.write(this.out, entry.getValue());
-        }
-    }
-
-    public void writeOptionalWriteable(@Nullable ProtobufWriteable writeable) throws IOException {
-        if (writeable != null) {
-            this.out.writeBoolNoTag(true);
-            writeable.writeTo(this.out);
-        } else {
-            this.out.writeBoolNoTag(false);
-        }
-    }
-
-    /**
-     * Write a {@link TimeValue} to the stream
-     */
-    public void writeTimeValue(TimeValue timeValue) throws IOException {
-        this.out.writeInt64NoTag(timeValue.duration());
-        this.out.writeRawByte((byte) timeValue.timeUnit().ordinal());
-    }
-
-    /**
-     * Writes an EnumSet with type E that by serialized it based on it's ordinal value
-     */
-    public <E extends Enum<E>> void writeEnumSet(EnumSet<E> enumSet) throws IOException {
-        this.out.writeInt32NoTag(enumSet.size());
-        for (E e : enumSet) {
-            this.out.writeEnumNoTag(e.ordinal());
-        }
-    }
-
-    public void writeOptionalLong(@Nullable Long l) throws IOException {
-        if (l == null) {
-            this.out.writeBoolNoTag(false);
-        } else {
-            this.out.writeBoolNoTag(true);
-            this.out.writeInt64NoTag(l);
-        }
-    }
-
-    public void writeOptionalString(@Nullable String str) throws IOException {
-        if (str == null) {
-            this.out.writeBoolNoTag(false);
-        } else {
-            this.out.writeBoolNoTag(true);
-            this.out.writeStringNoTag(str);
-        }
-    }
-
-    public void writeOptionalBoolean(@Nullable Boolean b) throws IOException {
-        byte two = 2;
-        if (b == null) {
-            this.out.write(two);
-        } else {
-            this.out.writeBoolNoTag(b);
-        }
-    }
-
-    /**
-     * Writes a collection of a strings. The corresponding collection can be read from a stream input using
-     * {@link ProtobufStreamInput#readList(ProtobufWriteable.Reader)}.
-     *
-     * @param collection the collection of strings
-     * @throws IOException if an I/O exception occurs writing the collection
-     */
-    public void writeStringCollection(final Collection<String> collection) throws IOException {
-        writeCollection(collection, CodedOutputStream::writeStringNoTag);
-    }
-
-    /**
-     * Writes a collection of objects via a {@link Writer}.
-     *
-     * @param collection the collection of objects
-     * @throws IOException if an I/O exception occurs writing the collection
-     */
-    public <T> void writeCollection(final Collection<T> collection, final Writer<T> writer) throws IOException {
-        this.out.writeInt32NoTag(collection.size());
-        for (final T val : collection) {
-            writer.write(this.out, val);
-        }
-    }
-
-    public void writeStringArray(String[] array) throws IOException {
-        this.out.writeInt32NoTag(array.length);
-        for (String s : array) {
-            this.out.writeStringNoTag(s);
-        }
-    }
-
-    /**
-     * Writes a {@link ProtobufNamedWriteable} to the current stream, by first writing its name and then the object itself
-     */
-    public void writeNamedWriteable(ProtobufNamedWriteable namedWriteable) throws IOException {
-        this.out.writeStringNoTag(namedWriteable.getWriteableName());
-        namedWriteable.writeTo(this.out);
-    }
-
-    /**
-     * Writes a string array, for nullable string, writes it as 0 (empty string).
-     */
-    public void writeStringArrayNullable(@Nullable String[] array) throws IOException {
-        if (array == null) {
-            this.out.writeInt32NoTag(0);
-        } else {
-            writeStringArray(array);
-        }
-    }
-
-    /**
-     * Write an optional {@link TimeValue} to the stream.
-     */
-    public void writeOptionalTimeValue(@Nullable TimeValue timeValue) throws IOException {
-        if (timeValue == null) {
-            this.out.writeBoolNoTag(false);
-        } else {
-            this.out.writeBoolNoTag(true);
-            writeTimeValue(timeValue);
-        }
-    }
-
-    /**
-     * Same as {@link #writeArray(Writer, Object[])} but the provided array may be null. An additional boolean value is
-     * serialized to indicate whether the array was null or not.
-     */
-    public <T> void writeOptionalArray(final Writer<T> writer, final @Nullable T[] array) throws IOException {
-        if (array == null) {
-            this.out.writeBoolNoTag(false);
-        } else {
-            this.out.writeBoolNoTag(true);
-            writeArray(writer, array);
-        }
-    }
-
-    public <T> void writeArray(final Writer<T> writer, final T[] array) throws IOException {
-        this.out.writeInt32NoTag(array.length);
-        for (T value : array) {
-            writer.write(this.out, value);
-        }
-    }
-
-    /**
-    * Set the features on the stream. See {@link StreamOutput#hasFeature(String)}.
-    *
-    * @param features the features on the stream
-    */
-    public void setFeatures(final Set<String> features) {
-        assert this.features.isEmpty() : this.features;
-        this.features = Collections.unmodifiableSet(new HashSet<>(features));
-    }
-
-    public Set<String> getFeatures() {
-        return this.features;
-    }
-
-    public void writeException(Throwable throwable) throws IOException {
-        writeException(throwable, throwable, 0);
-    }
-
-    private void writeException(Throwable rootException, Throwable throwable, int nestedLevel) throws IOException {
-        if (throwable == null) {
-            this.out.writeBoolNoTag(false);
-        } else if (nestedLevel > MAX_NESTED_EXCEPTION_LEVEL) {
-            assert failOnTooManyNestedExceptions(rootException);
-            writeException(new IllegalStateException("too many nested exceptions"));
-        } else {
-            this.out.writeBoolNoTag(true);
-            boolean writeCause = true;
-            boolean writeMessage = true;
-            if (throwable instanceof NullPointerException) {
-                this.out.writeInt32NoTag(4);
-                writeCause = false;
-            } else if (throwable instanceof NumberFormatException) {
-                this.out.writeInt32NoTag(5);
-                writeCause = false;
-            } else if (throwable instanceof IllegalArgumentException) {
-                this.out.writeInt32NoTag(6);
-            } else if (throwable instanceof AlreadyClosedException) {
-                this.out.writeInt32NoTag(7);
-            } else if (throwable instanceof EOFException) {
-                this.out.writeInt32NoTag(8);
-                writeCause = false;
-            } else if (throwable instanceof SecurityException) {
-                this.out.writeInt32NoTag(9);
-            } else if (throwable instanceof StringIndexOutOfBoundsException) {
-                this.out.writeInt32NoTag(10);
-                writeCause = false;
-            } else if (throwable instanceof ArrayIndexOutOfBoundsException) {
-                this.out.writeInt32NoTag(11);
-                writeCause = false;
-            } else if (throwable instanceof FileNotFoundException) {
-                this.out.writeInt32NoTag(12);
-                writeCause = false;
-            } else if (throwable instanceof FileSystemException) {
-                this.out.writeInt32NoTag(13);
-                if (throwable instanceof NoSuchFileException) {
-                    this.out.writeInt32NoTag(0);
-                } else if (throwable instanceof NotDirectoryException) {
-                    this.out.writeInt32NoTag(1);
-                } else if (throwable instanceof DirectoryNotEmptyException) {
-                    this.out.writeInt32NoTag(2);
-                } else if (throwable instanceof AtomicMoveNotSupportedException) {
-                    this.out.writeInt32NoTag(3);
-                } else if (throwable instanceof FileAlreadyExistsException) {
-                    this.out.writeInt32NoTag(4);
-                } else if (throwable instanceof AccessDeniedException) {
-                    this.out.writeInt32NoTag(5);
-                } else if (throwable instanceof FileSystemLoopException) {
-                    this.out.writeInt32NoTag(6);
-                } else {
-                    this.out.writeInt32NoTag(7);
-                }
-                writeOptionalString(((FileSystemException) throwable).getFile());
-                writeOptionalString(((FileSystemException) throwable).getOtherFile());
-                writeOptionalString(((FileSystemException) throwable).getReason());
-                writeCause = false;
-            } else if (throwable instanceof IllegalStateException) {
-                this.out.writeInt32NoTag(14);
-            } else if (throwable instanceof LockObtainFailedException) {
-                this.out.writeInt32NoTag(15);
-            } else if (throwable instanceof InterruptedException) {
-                this.out.writeInt32NoTag(16);
-                writeCause = false;
-            } else if (throwable instanceof IOException) {
-                this.out.writeInt32NoTag(17);
-            } else {
-                final ProtobufOpenSearchException ex;
-                if (throwable instanceof ProtobufOpenSearchException
-                    && ProtobufOpenSearchException.isRegistered(throwable.getClass(), version)) {
-                    ex = (ProtobufOpenSearchException) throwable;
-                } else {
-                    ex = new ProtobufNotSerializableExceptionWrapper(throwable);
-                }
-                this.out.writeInt32NoTag(0);
-                this.out.writeInt32NoTag(ProtobufOpenSearchException.getId(ex.getClass()));
-                ex.writeTo(this.out);
-                return;
-            }
-            if (writeMessage) {
-                writeOptionalString(throwable.getMessage());
-            }
-            if (writeCause) {
-                writeException(rootException, throwable.getCause(), nestedLevel + 1);
-            }
-            ProtobufOpenSearchException.writeStackTraces(throwable, this.out, new ProtobufStreamOutput(this.out));
-        }
-    }
-
-    boolean failOnTooManyNestedExceptions(Throwable throwable) {
-        throw new AssertionError("too many nested exceptions", throwable);
-    }
-
-    /**
-     * Writes an enum with type E based on its ordinal value
-     */
-    public <E extends Enum<E>> void writeEnum(E enumValue) throws IOException {
-        this.out.writeInt32NoTag(enumValue.ordinal());
-    }
-
-    private static final ThreadLocal<byte[]> scratch = ThreadLocal.withInitial(() -> new byte[1024]);
-
-    public final void writeShort(short v) throws IOException {
-        final byte[] buffer = scratch.get();
-        buffer[0] = (byte) (v >> 8);
-        buffer[1] = (byte) v;
-        this.out.writeByteArrayNoTag(buffer);
-    }
-
-    public void writeDoubleArray(double[] values) throws IOException {
-        this.out.writeInt32NoTag(values.length);
-        for (double value : values) {
-            this.out.writeDoubleNoTag(value);
-        }
-    }
-
-}
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufWriteable.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufWriteable.java
index 86f71cf6e5bf2..9abc2ed7a93e2 100644
--- a/server/src/main/java/org/opensearch/common/io/stream/ProtobufWriteable.java
+++ b/server/src/main/java/org/opensearch/common/io/stream/ProtobufWriteable.java
@@ -14,27 +14,26 @@
 package org.opensearch.common.io.stream;
 
 import java.io.IOException;
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
+import java.io.OutputStream;
 
 /**
  * Implementers can be written to write to output and read from input using Protobuf.
 *
 * @opensearch.internal
 */
-public interface ProtobufWriteable extends BaseWriteable<CodedOutputStream, CodedInputStream> {
+public interface ProtobufWriteable {
 
     /**
      * Write this into the stream output.
     */
-    public void writeTo(CodedOutputStream out) throws IOException;
+    public void writeTo(OutputStream out) throws IOException;
 
     /**
-     * Reference to a method that can write some object to a {@link CodedOutputStream}.
-     * Most classes should implement {@link ProtobufWriteable} and the {@link ProtobufWriteable#writeTo(CodedOutputStream)} method should <em>use</em>
-     * {@link CodedOutputStream} methods directly or this indirectly:
+     * Reference to a method that can write some object to a {@link OutputStream}.
+     * Most classes should implement {@link ProtobufWriteable} and the {@link ProtobufWriteable#writeTo(OutputStream)} method should <em>use</em>
+     * {@link OutputStream} methods directly or this indirectly:
      * <pre><code>
-     * public void writeTo(CodedOutputStream out) throws IOException {
+     * public void writeTo(OutputStream out) throws IOException {
      *     out.writeVInt(someValue);
      * }
      * </code></pre>
@@ -48,15 +47,15 @@ interface Writer<V> {
         * @param out Output to write the {@code value} too
         * @param value The value to add
         */
-        void write(CodedOutputStream out, V value) throws IOException;
+        void write(OutputStream out, V value) throws IOException;
 
     }
 
     /**
      * Reference to a method that can read some object from a stream. By convention this is a constructor that takes
-     * {@linkplain CodedInputStream} as an argument for most classes and a static method for things like enums.
+     * {@linkplain byte[]} as an argument for most classes and a static method for things like enums.
      * <pre><code>
-     * public MyClass(final CodedInputStream in) throws IOException {
+     * public MyClass(final byte[] in) throws IOException {
      *     this.someValue = in.readVInt();
      * }
      * </code></pre>
@@ -69,7 +68,7 @@ interface Reader<V> {
         *
         * @param in Input to read the value from
         */
-        V read(CodedInputStream in) throws IOException;
+        V read(byte[] in) throws IOException;
 
     }
 
diff --git a/server/src/main/java/org/opensearch/common/transport/BoundTransportAddress.java b/server/src/main/java/org/opensearch/common/transport/BoundTransportAddress.java
index 0a12589f58752..3f1a74402640e 100644
--- a/server/src/main/java/org/opensearch/common/transport/BoundTransportAddress.java
+++ b/server/src/main/java/org/opensearch/common/transport/BoundTransportAddress.java
@@ -50,7 +50,7 @@
  *
  * @opensearch.internal
  */
-public class BoundTransportAddress implements Writeable, ProtobufWriteable {
+public class BoundTransportAddress implements Writeable {
 
     private TransportAddress[] boundAddresses;
 
@@ -65,16 +65,6 @@ public BoundTransportAddress(StreamInput in) throws IOException {
         publishAddress = new TransportAddress(in);
     }
 
-    public BoundTransportAddress(CodedInputStream in) throws IOException {
-        int boundAddressLength = in.readInt32();
-        boundAddresses = new TransportAddress[boundAddressLength];
-        for (int i = 0; i < boundAddressLength; i++) {
-            boundAddresses[i] = new TransportAddress(in);
-        }
-        publishAddress = new TransportAddress(in);
-    }
-
-
     public BoundTransportAddress(TransportAddress[] boundAddresses, TransportAddress publishAddress) {
         if (boundAddresses == null || boundAddresses.length < 1) {
             throw new IllegalArgumentException("at least one bound address must be provided");
@@ -100,15 +90,6 @@ public void writeTo(StreamOutput out) throws IOException {
         publishAddress.writeTo(out);
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt32NoTag(boundAddresses.length);
-        for (TransportAddress address : boundAddresses) {
-            address.writeTo(out);
-        }
-        publishAddress.writeTo(out);
-    }
-
     @Override
     public String toString() {
         StringBuilder builder = new StringBuilder("publish_address {");
diff --git a/server/src/main/java/org/opensearch/common/transport/ProtobufBoundTransportAddress.java b/server/src/main/java/org/opensearch/common/transport/ProtobufBoundTransportAddress.java
deleted file mode 100644
index 3b3d27ec91de1..0000000000000
--- a/server/src/main/java/org/opensearch/common/transport/ProtobufBoundTransportAddress.java
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
-* 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.
-*/
-
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
-package org.opensearch.common.transport;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.network.InetAddresses;
-
-import java.io.IOException;
-
-/** not used
- * A bounded transport address is a tuple of {@link TransportAddress}, one array that represents
-* the addresses the transport is bound to, and the other is the published one that represents the address clients
-* should communicate on.
-*
-* @opensearch.internal
-*/
-public class ProtobufBoundTransportAddress implements ProtobufWriteable {
-
-    private TransportAddress[] boundAddresses;
-
-    private TransportAddress publishAddress;
-
-    public ProtobufBoundTransportAddress(CodedInputStream in) throws IOException {
-        int boundAddressLength = in.readInt32();
-        boundAddresses = new TransportAddress[boundAddressLength];
-        for (int i = 0; i < boundAddressLength; i++) {
-            boundAddresses[i] = new TransportAddress(in);
-        }
-        publishAddress = new TransportAddress(in);
-    }
-
-    public ProtobufBoundTransportAddress(TransportAddress[] boundAddresses, TransportAddress publishAddress) {
-        if (boundAddresses == null || boundAddresses.length < 1) {
-            throw new IllegalArgumentException("at least one bound address must be provided");
-        }
-        this.boundAddresses = boundAddresses;
-        this.publishAddress = publishAddress;
-    }
-
-    public TransportAddress[] boundAddresses() {
-        return boundAddresses;
-    }
-
-    public TransportAddress publishAddress() {
-        return publishAddress;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt32NoTag(boundAddresses.length);
-        for (TransportAddress address : boundAddresses) {
-            address.writeTo(out);
-        }
-        publishAddress.writeTo(out);
-    }
-
-    @Override
-    public String toString() {
-        StringBuilder builder = new StringBuilder("publish_address {");
-        String hostString = publishAddress.address().getHostString();
-        String publishAddressString = publishAddress.toString();
-        if (InetAddresses.isInetAddress(hostString) == false) {
-            publishAddressString = hostString + '/' + publishAddress.toString();
-        }
-        builder.append(publishAddressString);
-        builder.append("}, bound_addresses ");
-        boolean firstAdded = false;
-        for (TransportAddress address : boundAddresses) {
-            if (firstAdded) {
-                builder.append(", ");
-            } else {
-                firstAdded = true;
-            }
-
-            builder.append("{").append(address).append("}");
-        }
-        return builder.toString();
-    }
-}
diff --git a/server/src/main/java/org/opensearch/common/transport/TransportAddress.java b/server/src/main/java/org/opensearch/common/transport/TransportAddress.java
index f19d83e5b1f7b..737e8f3496143 100644
--- a/server/src/main/java/org/opensearch/common/transport/TransportAddress.java
+++ b/server/src/main/java/org/opensearch/common/transport/TransportAddress.java
@@ -32,18 +32,13 @@
 
 package org.opensearch.common.transport;
 
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.common.network.NetworkAddress;
-import org.opensearch.core.xcontent.ToXContent.Params;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
@@ -54,7 +49,7 @@
  *
  * @opensearch.internal
  */
-public final class TransportAddress implements Writeable, ProtobufWriteable, ToXContentFragment {
+public final class TransportAddress implements Writeable, ToXContentFragment {
 
     /**
      * A <a href="https://en.wikipedia.org/wiki/0.0.0.0">non-routeable v4 meta transport address</a> that can be used for
@@ -111,31 +106,6 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeInt(address.getPort());
     }
 
-    /**
-     * Read from a stream.
-     */
-    public TransportAddress(CodedInputStream in) throws IOException {
-        final int len = in.readRawByte();
-        final byte[] a = new byte[len]; // 4 bytes (IPv4) or 16 bytes (IPv6)
-        in.readRawBytes(len);
-        String host = in.readString(); // the host string was serialized so we can ignore the passed in version
-        final InetAddress inetAddress = InetAddress.getByAddress(host, a);
-        int port = in.readInt32();
-        this.address = new InetSocketAddress(inetAddress, port);
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        byte[] bytes = address.getAddress().getAddress();  // 4 bytes (IPv4) or 16 bytes (IPv6)
-        out.write((byte) bytes.length); // 1 byte
-        out.write(bytes, 0, bytes.length);
-        out.writeStringNoTag(address.getHostString());
-        // don't serialize scope ids over the network!!!!
-        // these only make sense with respect to the local machine, and will only formulate
-        // the address incorrectly remotely.
-        out.writeInt32NoTag(address.getPort());
-    }
-
     /**
      * Returns a string representation of the enclosed {@link InetSocketAddress}
      * @see NetworkAddress#format(InetAddress)
diff --git a/server/src/main/java/org/opensearch/common/unit/ProtobufSizeValue.java b/server/src/main/java/org/opensearch/common/unit/ProtobufSizeValue.java
deleted file mode 100644
index b17e0606eccd2..0000000000000
--- a/server/src/main/java/org/opensearch/common/unit/ProtobufSizeValue.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.common.unit;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-
-import java.io.IOException;
-
-/**
- * Conversion values.
-*
-* @opensearch.internal
-*/
-public class ProtobufSizeValue implements ProtobufWriteable {
-
-    private final long size;
-    private final SizeUnit sizeUnit;
-
-    public ProtobufSizeValue(long singles) {
-        this(singles, SizeUnit.SINGLE);
-    }
-
-    public ProtobufSizeValue(long size, SizeUnit sizeUnit) {
-        if (size < 0) {
-            throw new IllegalArgumentException("size in SizeValue may not be negative");
-        }
-        this.size = size;
-        this.sizeUnit = sizeUnit;
-    }
-
-    public ProtobufSizeValue(CodedInputStream in) throws IOException {
-        size = in.readInt64();
-        sizeUnit = SizeUnit.SINGLE;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(singles());
-    }
-
-    public long getSize() {
-        return size;
-    }
-
-    public SizeUnit getSizeUnit() {
-        return sizeUnit;
-    }
-
-    public long singles() {
-        return sizeUnit.toSingles(size);
-    }
-
-    public long getSingles() {
-        return singles();
-    }
-
-    public long kilo() {
-        return sizeUnit.toKilo(size);
-    }
-
-    public long getKilo() {
-        return kilo();
-    }
-
-    public long mega() {
-        return sizeUnit.toMega(size);
-    }
-
-    public long getMega() {
-        return mega();
-    }
-
-    public long giga() {
-        return sizeUnit.toGiga(size);
-    }
-
-    public long getGiga() {
-        return giga();
-    }
-
-    public long tera() {
-        return sizeUnit.toTera(size);
-    }
-
-    public long getTera() {
-        return tera();
-    }
-
-    public long peta() {
-        return sizeUnit.toPeta(size);
-    }
-
-    public long getPeta() {
-        return peta();
-    }
-
-    public double kiloFrac() {
-        return ((double) singles()) / SizeUnit.C1;
-    }
-
-    public double getKiloFrac() {
-        return kiloFrac();
-    }
-
-    public double megaFrac() {
-        return ((double) singles()) / SizeUnit.C2;
-    }
-
-    public double getMegaFrac() {
-        return megaFrac();
-    }
-
-    public double gigaFrac() {
-        return ((double) singles()) / SizeUnit.C3;
-    }
-
-    public double getGigaFrac() {
-        return gigaFrac();
-    }
-
-    public double teraFrac() {
-        return ((double) singles()) / SizeUnit.C4;
-    }
-
-    public double getTeraFrac() {
-        return teraFrac();
-    }
-
-    public double petaFrac() {
-        return ((double) singles()) / SizeUnit.C5;
-    }
-
-    public double getPetaFrac() {
-        return petaFrac();
-    }
-}
diff --git a/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java b/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
index 348fb83d60338..ffb21270d6977 100644
--- a/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
+++ b/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
@@ -39,8 +39,6 @@
 import org.opensearch.client.OriginSettingClient;
 import org.opensearch.common.collect.MapBuilder;
 import org.opensearch.common.collect.Tuple;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
@@ -104,7 +102,7 @@
  *
  * @opensearch.internal
  */
-public final class ThreadContext implements Writeable, ProtobufWriteable {
+public final class ThreadContext implements Writeable {
 
     public static final String PREFIX = "request.headers";
     public static final Setting<Settings> DEFAULT_HEADERS_SETTING = Setting.groupSetting(PREFIX + ".", Property.NodeScope);
@@ -201,14 +199,6 @@ public ProtobufWriteable captureAsWriteable() {
         };
     }
 
-    /**
-     * Captures the current thread context as writeable, allowing it to be serialized out later
-     */
-    public ProtobufWriteable captureAsProtobufWriteable() {
-        final ThreadContextStruct context = threadLocal.get();
-        return out -> context.writeTo(out, defaultHeader);
-    }
-
     /**
      * Removes the current context and resets a default context marked with as
      * originating from the supplied string. The removed context can be
@@ -389,29 +379,6 @@ public static Tuple<Map<String, String>, Map<String, Set<String>>> readHeadersFr
         return new Tuple<>(requestHeaders, responseHeaders);
     }
 
-    public static Tuple<Map<String, String>, Map<String, Set<String>>> readHeadersFromStreamProtobuf(CodedInputStream in) throws IOException {
-        ProtobufStreamInput streamInput = new ProtobufStreamInput(in);
-        final Map<String, String> requestHeaders = streamInput.readMap(CodedInputStream::readString, CodedInputStream::readString);
-        final Map<String, Set<String>> responseHeaders = streamInput.readMap(CodedInputStream::readString, input -> {
-            final int size = in.readInt32();
-            if (size == 0) {
-                return Collections.emptySet();
-            } else if (size == 1) {
-                return Collections.singleton(input.readString());
-            } else {
-                // use a linked hash set to preserve order
-                final LinkedHashSet<String> values = new LinkedHashSet<>(size);
-                for (int i = 0; i < size; i++) {
-                    final String value = input.readString();
-                    final boolean added = values.add(value);
-                    assert added : value;
-                }
-                return values;
-            }
-        });
-        return new Tuple<>(requestHeaders, responseHeaders);
-    }
-
     /**
      * Returns the header for the given key or <code>null</code> if not present
      */
@@ -646,7 +613,6 @@ private static final class ThreadContextStruct {
         private final boolean isSystemContext;
         // saving current warning headers' size not to recalculate the size with every new warning header
         private final long warningHeadersSize;
-        private ProtobufStreamOutput protobufStreamOutput;
 
         private ThreadContextStruct setSystemContext() {
             if (isSystemContext) {
@@ -876,30 +842,6 @@ private void writeTo(StreamOutput out, Map<String, String> defaultHeaders, Map<S
 
             out.writeMap(responseHeaders, StreamOutput::writeString, StreamOutput::writeStringCollection);
         }
-
-        private void writeTo(CodedOutputStream out, Map<String, String> defaultHeaders) throws IOException {
-            final Map<String, String> requestHeaders;
-            if (defaultHeaders.isEmpty()) {
-                requestHeaders = this.requestHeaders;
-            } else {
-                requestHeaders = new HashMap<>(defaultHeaders);
-                requestHeaders.putAll(this.requestHeaders);
-            }
-
-            out.writeInt32NoTag(requestHeaders.size());
-            for (Map.Entry<String, String> entry : requestHeaders.entrySet()) {
-                out.writeStringNoTag(entry.getKey());
-                out.writeStringNoTag(entry.getValue());
-            }
-
-            protobufStreamOutput = new ProtobufStreamOutput(out);
-            protobufStreamOutput.writeMap(responseHeaders, CodedOutputStream::writeStringNoTag, (o, v) -> {
-                o.writeInt32NoTag(v.size());
-                for (String s : v) {
-                    o.writeStringNoTag(s);
-                }
-            });
-        }
     }
 
     /**
@@ -1032,9 +974,4 @@ public Set<Characteristics> characteristics() {
         }
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        threadLocal.get().writeTo(out, defaultHeader);
-    }
-
 }
diff --git a/server/src/main/java/org/opensearch/discovery/Discovery.java b/server/src/main/java/org/opensearch/discovery/Discovery.java
index 9418632d52e1f..9d6807b6522c9 100644
--- a/server/src/main/java/org/opensearch/discovery/Discovery.java
+++ b/server/src/main/java/org/opensearch/discovery/Discovery.java
@@ -49,11 +49,6 @@ public interface Discovery extends LifecycleComponent, ClusterStatePublisher {
      */
     DiscoveryStats stats();
 
-    /**
-     * @return stats about the discovery
-     */
-    ProtobufDiscoveryStats protobufStats();
-
     /**
      * Triggers the first join cycle
      */
diff --git a/server/src/main/java/org/opensearch/discovery/PeerFinder.java b/server/src/main/java/org/opensearch/discovery/PeerFinder.java
index f979b6b45e0d0..d2877d3d035e7 100644
--- a/server/src/main/java/org/opensearch/discovery/PeerFinder.java
+++ b/server/src/main/java/org/opensearch/discovery/PeerFinder.java
@@ -50,7 +50,6 @@
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
 import org.opensearch.threadpool.ThreadPool.Names;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequestOptions;
 import org.opensearch.transport.TransportResponseHandler;
@@ -508,18 +507,6 @@ public String executor() {
                     return Names.GENERIC;
                 }
 
-                @Override
-                public PeersResponse read(CodedInputStream in) throws IOException {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'read'");
-                }
-
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
-
                 @Override
                 public PeersResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/discovery/ProtobufDiscoveryStats.java b/server/src/main/java/org/opensearch/discovery/ProtobufDiscoveryStats.java
deleted file mode 100644
index e11d0535852d1..0000000000000
--- a/server/src/main/java/org/opensearch/discovery/ProtobufDiscoveryStats.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
-* 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.discovery;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.cluster.coordination.ProtobufPendingClusterStateStats;
-import org.opensearch.cluster.coordination.ProtobufPublishClusterStateStats;
-
-import java.io.IOException;
-
-/**
- * Stores discovery stats
-*
-* @opensearch.internal
-*/
-public class ProtobufDiscoveryStats implements ProtobufWriteable, ToXContentFragment {
-
-    private final ProtobufPendingClusterStateStats queueStats;
-    private final ProtobufPublishClusterStateStats publishStats;
-
-    public ProtobufDiscoveryStats(ProtobufPendingClusterStateStats queueStats, ProtobufPublishClusterStateStats publishStats) {
-        this.queueStats = queueStats;
-        this.publishStats = publishStats;
-    }
-
-    public ProtobufDiscoveryStats(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        queueStats = protobufStreamInput.readOptionalWriteable(ProtobufPendingClusterStateStats::new);
-        publishStats = protobufStreamInput.readOptionalWriteable(ProtobufPublishClusterStateStats::new);
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeOptionalWriteable(queueStats);
-        protobufStreamOutput.writeOptionalWriteable(publishStats);
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.DISCOVERY);
-        if (queueStats != null) {
-            queueStats.toXContent(builder, params);
-        }
-        if (publishStats != null) {
-            publishStats.toXContent(builder, params);
-        }
-        builder.endObject();
-        return builder;
-    }
-
-    static final class Fields {
-        static final String DISCOVERY = "discovery";
-    }
-
-    public ProtobufPendingClusterStateStats getQueueStats() {
-        return queueStats;
-    }
-
-    public ProtobufPublishClusterStateStats getPublishStats() {
-        return publishStats;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java b/server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java
index 2e3d6f95927ed..17b01dc898964 100644
--- a/server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java
+++ b/server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java
@@ -36,13 +36,6 @@ public ExampleProtoRequest(int id, String message) {
         this.request = ExampleRequest.newBuilder().setId(id).setMessage(message).build();
     }
 
-    public ExampleProtoRequest(CodedInputStream in) throws IOException {
-        super(in);
-        System.out.println("ExampleProtoRequest constructor");
-        System.out.println("in: " + in);
-        this.request = ExampleRequest.parseFrom(in);
-    }
-
     public ExampleProtoRequest(byte[] data) throws InvalidProtocolBufferException {
         this.request = ExampleRequest.parseFrom(data);
     }
diff --git a/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java b/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
index ab41083f92ec3..6962a60b18d5e 100644
--- a/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
+++ b/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
@@ -51,7 +51,6 @@
 import org.opensearch.extensions.settings.RegisterCustomSettingsRequest;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ConnectTransportException;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
@@ -374,18 +373,6 @@ public String executor() {
                 return ThreadPool.Names.GENERIC;
             }
 
-            @Override
-            public InitializeExtensionResponse read(CodedInputStream in) throws IOException {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'read'");
-            }
-
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
-
             @Override
             public InitializeExtensionResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/extensions/UpdateSettingsResponseHandler.java b/server/src/main/java/org/opensearch/extensions/UpdateSettingsResponseHandler.java
index 858cd4d88630e..f003af99d8afc 100644
--- a/server/src/main/java/org/opensearch/extensions/UpdateSettingsResponseHandler.java
+++ b/server/src/main/java/org/opensearch/extensions/UpdateSettingsResponseHandler.java
@@ -14,7 +14,6 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 
@@ -51,18 +50,6 @@ public String executor() {
         return ThreadPool.Names.GENERIC;
     }
 
-    @Override
-    public AcknowledgedResponse read(CodedInputStream in) throws IOException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'read'");
-    }
-
-    @Override
-    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-    }
-
     @Override
     public AcknowledgedResponse read(byte[] in) throws IOException {
         // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java b/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java
index 42875056ef0fe..ce240c0c005e8 100644
--- a/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java
+++ b/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java
@@ -21,7 +21,6 @@
 import org.opensearch.extensions.ExtensionsManager;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ActionNotFoundTransportException;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
@@ -223,18 +222,6 @@ public String executor() {
                     return ThreadPool.Names.GENERIC;
                 }
 
-                @Override
-                public ExtensionActionResponse read(CodedInputStream in) throws IOException {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'read'");
-                }
-
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
-
                 @Override
                 public ExtensionActionResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
@@ -305,18 +292,6 @@ public String executor() {
                     return ThreadPool.Names.GENERIC;
                 }
 
-                @Override
-                public RemoteExtensionActionResponse read(CodedInputStream in) throws IOException {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'read'");
-                }
-
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
-
                 @Override
                 public RemoteExtensionActionResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java b/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java
index 771d3e20d6829..10f89ea1886a2 100644
--- a/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java
+++ b/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java
@@ -24,7 +24,6 @@
 import org.opensearch.rest.RestRequest.Method;
 import org.opensearch.core.rest.RestStatus;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
@@ -242,18 +241,6 @@ public String executor() {
                 return ThreadPool.Names.GENERIC;
             }
 
-            @Override
-            public RestExecuteOnExtensionResponse read(CodedInputStream in) throws IOException {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'read'");
-            }
-
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
-
             @Override
             public RestExecuteOnExtensionResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java b/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java
index 90d4e7362d677..0ba49be01d193 100644
--- a/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java
+++ b/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java
@@ -46,8 +46,6 @@
 import org.opensearch.common.transport.BoundTransportAddress;
 import org.opensearch.common.transport.NetworkExceptionHelper;
 import org.opensearch.common.transport.PortsRange;
-import org.opensearch.common.transport.ProtobufBoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.common.util.BigArrays;
@@ -157,35 +155,11 @@ public HttpInfo info() {
         return new HttpInfo(boundTransportAddress, maxContentLength.getBytes());
     }
 
-    @Override
-    public ProtobufHttpInfo protobufInfo() {
-        BoundTransportAddress boundTransportAddress = boundAddress();
-        if (boundTransportAddress == null) {
-            return null;
-        }
-        TransportAddress[] transportAddress = boundTransportAddress.boundAddresses();
-        TransportAddress publishAddress = boundTransportAddress.publishAddress();
-        // TransportAddress[] protobufTransportAddresses = new TransportAddress[transportAddress.length];
-        // for (int i = 0; i < transportAddress.length; i++) {
-        //     protobufTransportAddresses[i] = new TransportAddress(transportAddress[i].address());
-        // }
-        // ProtobufBoundTransportAddress protobufBoundTransportAddress = new ProtobufBoundTransportAddress(
-        //     protobufTransportAddresses,
-        //     new TransportAddress(publishAddress.address())
-        // );
-        return new ProtobufHttpInfo(boundTransportAddress, maxContentLength.getBytes());
-    }
-
     @Override
     public HttpStats stats() {
         return new HttpStats(httpChannels.size(), totalChannelsAccepted.get());
     }
 
-    @Override
-    public ProtobufHttpStats protobufStats() {
-        return new ProtobufHttpStats(httpChannels.size(), totalChannelsAccepted.get());
-    }
-
     protected void bindServer() {
         // Bind and start to accept incoming connections.
         InetAddress hostAddresses[];
diff --git a/server/src/main/java/org/opensearch/http/HttpServerTransport.java b/server/src/main/java/org/opensearch/http/HttpServerTransport.java
index 0d4ac79535c25..6549f0786fcda 100644
--- a/server/src/main/java/org/opensearch/http/HttpServerTransport.java
+++ b/server/src/main/java/org/opensearch/http/HttpServerTransport.java
@@ -35,7 +35,6 @@
 import org.opensearch.common.lifecycle.LifecycleComponent;
 import org.opensearch.common.transport.BoundTransportAddress;
 import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.node.ReportingService;
 import org.opensearch.rest.RestChannel;
 import org.opensearch.rest.RestRequest;
@@ -45,7 +44,7 @@
  *
  * @opensearch.internal
  */
-public interface HttpServerTransport extends LifecycleComponent, ReportingService<HttpInfo>, ProtobufReportingService<ProtobufHttpInfo> {
+public interface HttpServerTransport extends LifecycleComponent, ReportingService<HttpInfo> {
 
     String HTTP_SERVER_WORKER_THREAD_NAME_PREFIX = "http_server_worker";
 
@@ -54,13 +53,8 @@ public interface HttpServerTransport extends LifecycleComponent, ReportingServic
     @Override
     HttpInfo info();
 
-    @Override
-    ProtobufHttpInfo protobufInfo();
-
     HttpStats stats();
 
-    ProtobufHttpStats protobufStats();
-
     /**
      * Dispatches HTTP requests.
      */
diff --git a/server/src/main/java/org/opensearch/http/ProtobufHttpInfo.java b/server/src/main/java/org/opensearch/http/ProtobufHttpInfo.java
deleted file mode 100644
index 1fe3472a28444..0000000000000
--- a/server/src/main/java/org/opensearch/http/ProtobufHttpInfo.java
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
-* 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.
-*/
-
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
-package org.opensearch.http;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
-import org.opensearch.common.logging.DeprecationLogger;
-import org.opensearch.common.network.InetAddresses;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.node.ProtobufReportingService;
-
-import java.io.IOException;
-
-/**
- * Information about an http connection
-*
-* @opensearch.internal
-*/
-public class ProtobufHttpInfo implements ProtobufReportingService.ProtobufInfo {
-
-    private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(ProtobufHttpInfo.class);
-
-    /** Deprecated property, just here for deprecation logging in 7.x. */
-    private static final boolean CNAME_IN_PUBLISH_HOST = System.getProperty("opensearch.http.cname_in_publish_address") != null;
-
-    private final BoundTransportAddress address;
-    private final long maxContentLength;
-
-    public ProtobufHttpInfo(CodedInputStream in) throws IOException {
-        this(new BoundTransportAddress(in), in.readInt64());
-    }
-
-    public ProtobufHttpInfo(BoundTransportAddress address, long maxContentLength) {
-        this.address = address;
-        this.maxContentLength = maxContentLength;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        address.writeTo(out);
-        out.writeInt64NoTag(maxContentLength);
-    }
-
-    public BoundTransportAddress address() {
-        return address;
-    }
-
-    public BoundTransportAddress getAddress() {
-        return address();
-    }
-
-    public ByteSizeValue maxContentLength() {
-        return new ByteSizeValue(maxContentLength);
-    }
-
-    public ByteSizeValue getMaxContentLength() {
-        return maxContentLength();
-    }
-
-    static final class Fields {
-        static final String HTTP = "http";
-        static final String BOUND_ADDRESS = "bound_address";
-        static final String PUBLISH_ADDRESS = "publish_address";
-        static final String MAX_CONTENT_LENGTH = "max_content_length";
-        static final String MAX_CONTENT_LENGTH_IN_BYTES = "max_content_length_in_bytes";
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.HTTP);
-        builder.array(Fields.BOUND_ADDRESS, (Object[]) address.boundAddresses());
-        TransportAddress publishAddress = address.publishAddress();
-        String publishAddressString = publishAddress.toString();
-        String hostString = publishAddress.address().getHostString();
-        if (CNAME_IN_PUBLISH_HOST) {
-            deprecationLogger.deprecate(
-                "cname_in_publish_address",
-                "opensearch.http.cname_in_publish_address system property is deprecated and no longer affects http.publish_address "
-                    + "formatting. Remove this property to get rid of this deprecation warning."
-            );
-        }
-        if (InetAddresses.isInetAddress(hostString) == false) {
-            publishAddressString = hostString + '/' + publishAddress.toString();
-        }
-        builder.field(Fields.PUBLISH_ADDRESS, publishAddressString);
-        builder.humanReadableField(Fields.MAX_CONTENT_LENGTH_IN_BYTES, Fields.MAX_CONTENT_LENGTH, maxContentLength());
-        builder.endObject();
-        return builder;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/http/ProtobufHttpStats.java b/server/src/main/java/org/opensearch/http/ProtobufHttpStats.java
deleted file mode 100644
index eedd4148575ea..0000000000000
--- a/server/src/main/java/org/opensearch/http/ProtobufHttpStats.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.http;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-
-/**
- * Stats for HTTP connections
-*
-* @opensearch.internal
-*/
-public class ProtobufHttpStats implements ProtobufWriteable, ToXContentFragment {
-
-    private final long serverOpen;
-    private final long totalOpen;
-
-    public ProtobufHttpStats(long serverOpen, long totalOpened) {
-        this.serverOpen = serverOpen;
-        this.totalOpen = totalOpened;
-    }
-
-    public ProtobufHttpStats(CodedInputStream in) throws IOException {
-        serverOpen = in.readInt64();
-        totalOpen = in.readInt64();
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(serverOpen);
-        out.writeInt64NoTag(totalOpen);
-    }
-
-    public long getServerOpen() {
-        return this.serverOpen;
-    }
-
-    public long getTotalOpen() {
-        return this.totalOpen;
-    }
-
-    static final class Fields {
-        static final String HTTP = "http";
-        static final String CURRENT_OPEN = "current_open";
-        static final String TOTAL_OPENED = "total_opened";
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.HTTP);
-        builder.field(Fields.CURRENT_OPEN, serverOpen);
-        builder.field(Fields.TOTAL_OPENED, totalOpen);
-        builder.endObject();
-        return builder;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/index/cache/query/ProtobufQueryCacheStats.java b/server/src/main/java/org/opensearch/index/cache/query/ProtobufQueryCacheStats.java
deleted file mode 100644
index f3b936f7b7c91..0000000000000
--- a/server/src/main/java/org/opensearch/index/cache/query/ProtobufQueryCacheStats.java
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.index.cache.query;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.apache.lucene.search.DocIdSet;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.core.xcontent.ToXContent;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-
-/**
- * Stats for the query cache
-*
-* @opensearch.internal
-*/
-public class ProtobufQueryCacheStats implements ProtobufWriteable, ToXContentFragment {
-
-    private long ramBytesUsed;
-    private long hitCount;
-    private long missCount;
-    private long cacheCount;
-    private long cacheSize;
-
-    public ProtobufQueryCacheStats() {}
-
-    public ProtobufQueryCacheStats(CodedInputStream in) throws IOException {
-        ramBytesUsed = in.readInt64();
-        hitCount = in.readInt64();
-        missCount = in.readInt64();
-        cacheCount = in.readInt64();
-        cacheSize = in.readInt64();
-    }
-
-    public ProtobufQueryCacheStats(long ramBytesUsed, long hitCount, long missCount, long cacheCount, long cacheSize) {
-        this.ramBytesUsed = ramBytesUsed;
-        this.hitCount = hitCount;
-        this.missCount = missCount;
-        this.cacheCount = cacheCount;
-        this.cacheSize = cacheSize;
-    }
-
-    public void add(ProtobufQueryCacheStats stats) {
-        ramBytesUsed += stats.ramBytesUsed;
-        hitCount += stats.hitCount;
-        missCount += stats.missCount;
-        cacheCount += stats.cacheCount;
-        cacheSize += stats.cacheSize;
-    }
-
-    public long getMemorySizeInBytes() {
-        return ramBytesUsed;
-    }
-
-    public ByteSizeValue getMemorySize() {
-        return new ByteSizeValue(ramBytesUsed);
-    }
-
-    /**
-     * The total number of lookups in the cache.
-    */
-    public long getTotalCount() {
-        return hitCount + missCount;
-    }
-
-    /**
-     * The number of successful lookups in the cache.
-    */
-    public long getHitCount() {
-        return hitCount;
-    }
-
-    /**
-     * The number of lookups in the cache that failed to retrieve a {@link DocIdSet}.
-    */
-    public long getMissCount() {
-        return missCount;
-    }
-
-    /**
-     * The number of {@link DocIdSet}s that have been cached.
-    */
-    public long getCacheCount() {
-        return cacheCount;
-    }
-
-    /**
-     * The number of {@link DocIdSet}s that are in the cache.
-    */
-    public long getCacheSize() {
-        return cacheSize;
-    }
-
-    /**
-     * The number of {@link DocIdSet}s that have been evicted from the cache.
-    */
-    public long getEvictions() {
-        return cacheCount - cacheSize;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(ramBytesUsed);
-        out.writeInt64NoTag(hitCount);
-        out.writeInt64NoTag(missCount);
-        out.writeInt64NoTag(cacheCount);
-        out.writeInt64NoTag(cacheSize);
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params params) throws IOException {
-        builder.startObject(Fields.QUERY_CACHE);
-        builder.humanReadableField(Fields.MEMORY_SIZE_IN_BYTES, Fields.MEMORY_SIZE, getMemorySize());
-        builder.field(Fields.TOTAL_COUNT, getTotalCount());
-        builder.field(Fields.HIT_COUNT, getHitCount());
-        builder.field(Fields.MISS_COUNT, getMissCount());
-        builder.field(Fields.CACHE_SIZE, getCacheSize());
-        builder.field(Fields.CACHE_COUNT, getCacheCount());
-        builder.field(Fields.EVICTIONS, getEvictions());
-        builder.endObject();
-        return builder;
-    }
-
-    /**
-     * Fields used for parsing and toXContent
-    *
-    * @opensearch.internal
-    */
-    static final class Fields {
-        static final String QUERY_CACHE = "query_cache";
-        static final String MEMORY_SIZE = "memory_size";
-        static final String MEMORY_SIZE_IN_BYTES = "memory_size_in_bytes";
-        static final String TOTAL_COUNT = "total_count";
-        static final String HIT_COUNT = "hit_count";
-        static final String MISS_COUNT = "miss_count";
-        static final String CACHE_SIZE = "cache_size";
-        static final String CACHE_COUNT = "cache_count";
-        static final String EVICTIONS = "evictions";
-    }
-
-}
diff --git a/server/src/main/java/org/opensearch/index/cache/request/ProtobufRequestCacheStats.java b/server/src/main/java/org/opensearch/index/cache/request/ProtobufRequestCacheStats.java
deleted file mode 100644
index 7825adc584287..0000000000000
--- a/server/src/main/java/org/opensearch/index/cache/request/ProtobufRequestCacheStats.java
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.index.cache.request;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-
-/**
- * Request for the query cache statistics
-*
-* @opensearch.internal
-*/
-public class ProtobufRequestCacheStats implements ProtobufWriteable, ToXContentFragment {
-
-    private long memorySize;
-    private long evictions;
-    private long hitCount;
-    private long missCount;
-
-    public ProtobufRequestCacheStats() {}
-
-    public ProtobufRequestCacheStats(CodedInputStream in) throws IOException {
-        memorySize = in.readInt64();
-        evictions = in.readInt64();
-        hitCount = in.readInt64();
-        missCount = in.readInt64();
-    }
-
-    public ProtobufRequestCacheStats(long memorySize, long evictions, long hitCount, long missCount) {
-        this.memorySize = memorySize;
-        this.evictions = evictions;
-        this.hitCount = hitCount;
-        this.missCount = missCount;
-    }
-
-    public void add(ProtobufRequestCacheStats stats) {
-        this.memorySize += stats.memorySize;
-        this.evictions += stats.evictions;
-        this.hitCount += stats.hitCount;
-        this.missCount += stats.missCount;
-    }
-
-    public long getMemorySizeInBytes() {
-        return this.memorySize;
-    }
-
-    public ByteSizeValue getMemorySize() {
-        return new ByteSizeValue(memorySize);
-    }
-
-    public long getEvictions() {
-        return this.evictions;
-    }
-
-    public long getHitCount() {
-        return this.hitCount;
-    }
-
-    public long getMissCount() {
-        return this.missCount;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(memorySize);
-        out.writeInt64NoTag(evictions);
-        out.writeInt64NoTag(hitCount);
-        out.writeInt64NoTag(missCount);
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.REQUEST_CACHE_STATS);
-        builder.humanReadableField(Fields.MEMORY_SIZE_IN_BYTES, Fields.MEMORY_SIZE, getMemorySize());
-        builder.field(Fields.EVICTIONS, getEvictions());
-        builder.field(Fields.HIT_COUNT, getHitCount());
-        builder.field(Fields.MISS_COUNT, getMissCount());
-        builder.endObject();
-        return builder;
-    }
-
-    /**
-     * Fields used for parsing and toXContent
-    *
-    * @opensearch.internal
-    */
-    static final class Fields {
-        static final String REQUEST_CACHE_STATS = "request_cache";
-        static final String MEMORY_SIZE = "memory_size";
-        static final String MEMORY_SIZE_IN_BYTES = "memory_size_in_bytes";
-        static final String EVICTIONS = "evictions";
-        static final String HIT_COUNT = "hit_count";
-        static final String MISS_COUNT = "miss_count";
-    }
-}
diff --git a/server/src/main/java/org/opensearch/index/cache/request/ShardRequestCache.java b/server/src/main/java/org/opensearch/index/cache/request/ShardRequestCache.java
index 20724474e5fb5..c3c552b5f732d 100644
--- a/server/src/main/java/org/opensearch/index/cache/request/ShardRequestCache.java
+++ b/server/src/main/java/org/opensearch/index/cache/request/ShardRequestCache.java
@@ -52,10 +52,6 @@ public RequestCacheStats stats() {
         return new RequestCacheStats(totalMetric.count(), evictionsMetric.count(), hitCount.count(), missCount.count());
     }
 
-    public ProtobufRequestCacheStats protobufStats() {
-        return new ProtobufRequestCacheStats(totalMetric.count(), evictionsMetric.count(), hitCount.count(), missCount.count());
-    }
-
     public void onHit() {
         hitCount.inc();
     }
diff --git a/server/src/main/java/org/opensearch/index/engine/CommitStats.java b/server/src/main/java/org/opensearch/index/engine/CommitStats.java
index d52342742a442..2c78f675c5154 100644
--- a/server/src/main/java/org/opensearch/index/engine/CommitStats.java
+++ b/server/src/main/java/org/opensearch/index/engine/CommitStats.java
@@ -33,9 +33,6 @@
 
 import org.apache.lucene.index.SegmentInfos;
 import org.opensearch.common.collect.MapBuilder;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
@@ -43,9 +40,6 @@
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.util.Base64;
 import java.util.Map;
@@ -55,7 +49,7 @@
  *
  * @opensearch.internal
  */
-public final class CommitStats implements Writeable, ToXContentFragment, ProtobufWriteable {
+public final class CommitStats implements Writeable, ToXContentFragment {
 
     private final Map<String, String> userData;
     private final long generation;
@@ -82,27 +76,10 @@ public CommitStats(SegmentInfos segmentInfos) {
         numDocs = in.readInt();
     }
 
-    CommitStats(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        MapBuilder<String, String> builder = MapBuilder.newMapBuilder();
-        for (int i = in.readInt32(); i > 0; i--) {
-            builder.put(in.readString(), in.readString());
-        }
-        userData = builder.immutableMap();
-        generation = in.readInt64();
-        id = protobufStreamInput.readOptionalString();
-        numDocs = in.readInt32();
-    }
-
     public static CommitStats readOptionalCommitStatsFrom(StreamInput in) throws IOException {
         return in.readOptionalWriteable(CommitStats::new);
     }
 
-    public static CommitStats readOptionalCommitStatsFromProtobuf(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        return protobufStreamInput.readOptionalWriteable(CommitStats::new);
-    }
-
     public Map<String, String> getUserData() {
         return userData;
     }
@@ -135,19 +112,6 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeInt(numDocs);
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeInt32NoTag(userData.size());
-        for (Map.Entry<String, String> entry : userData.entrySet()) {
-            out.writeStringNoTag(entry.getKey());
-            out.writeStringNoTag(entry.getValue());
-        }
-        out.writeInt64NoTag(generation);
-        protobufStreamOutput.writeOptionalString(id);
-        out.writeInt32NoTag(numDocs);
-    }
-
     /**
      * Fields used for parsing and toXContent
      *
diff --git a/server/src/main/java/org/opensearch/index/engine/Engine.java b/server/src/main/java/org/opensearch/index/engine/Engine.java
index 1c878a4a78238..74c9c25dc4c1f 100644
--- a/server/src/main/java/org/opensearch/index/engine/Engine.java
+++ b/server/src/main/java/org/opensearch/index/engine/Engine.java
@@ -81,12 +81,10 @@
 import org.opensearch.index.mapper.ParsedDocument;
 import org.opensearch.index.mapper.SeqNoFieldMapper;
 import org.opensearch.index.merge.MergeStats;
-import org.opensearch.index.merge.ProtobufMergeStats;
 import org.opensearch.index.seqno.SeqNoStats;
 import org.opensearch.index.seqno.SequenceNumbers;
 import org.opensearch.index.shard.DocsStats;
 import org.opensearch.core.index.shard.ShardId;
-import org.opensearch.index.shard.ProtobufDocsStats;
 import org.opensearch.index.store.Store;
 import org.opensearch.index.translog.Translog;
 import org.opensearch.index.translog.TranslogManager;
@@ -207,10 +205,6 @@ public MergeStats getMergeStats() {
         return new MergeStats();
     }
 
-    public ProtobufMergeStats getProtobufMergeStats() {
-        return new ProtobufMergeStats();
-    }
-
     /** returns the history uuid for the engine */
     public abstract String getHistoryUUID();
 
@@ -268,41 +262,6 @@ protected final DocsStats docsStats(IndexReader indexReader) {
         return new DocsStats(numDocs, numDeletedDocs, sizeInBytes);
     }
 
-    /**
-     * Returns the {@link DocsStats} for this engine
-     */
-    public ProtobufDocsStats protobufDocsStats() {
-        // we calculate the doc stats based on the internal searcher that is more up-to-date and not subject
-        // to external refreshes. For instance we don't refresh an external searcher if we flush and indices with
-        // index.refresh_interval=-1 won't see any doc stats updates at all. This change will give more accurate statistics
-        // when indexing but not refreshing in general. Yet, if a refresh happens the internal searcher is refresh as well so we are
-        // safe here.
-        try (Searcher searcher = acquireSearcher("docStats", SearcherScope.INTERNAL)) {
-            return protobufDocsStats(searcher.getIndexReader());
-        }
-    }
-
-    protected final ProtobufDocsStats protobufDocsStats(IndexReader indexReader) {
-        long numDocs = 0;
-        long numDeletedDocs = 0;
-        long sizeInBytes = 0;
-        // we don't wait for a pending refreshes here since it's a stats call instead we mark it as accessed only which will cause
-        // the next scheduled refresh to go through and refresh the stats as well
-        for (LeafReaderContext readerContext : indexReader.leaves()) {
-            // we go on the segment level here to get accurate numbers
-            final SegmentReader segmentReader = Lucene.segmentReader(readerContext.reader());
-            SegmentCommitInfo info = segmentReader.getSegmentInfo();
-            numDocs += readerContext.reader().numDocs();
-            numDeletedDocs += readerContext.reader().numDeletedDocs();
-            try {
-                sizeInBytes += info.sizeInBytes();
-            } catch (IOException e) {
-                logger.trace(() -> new ParameterizedMessage("failed to get size for [{}]", info.info.name), e);
-            }
-        }
-        return new ProtobufDocsStats(numDocs, numDeletedDocs, sizeInBytes);
-    }
-
     /**
      * Performs the pre-closing checks on the {@link Engine}.
      *
@@ -967,34 +926,6 @@ public SegmentsStats segmentsStats(boolean includeSegmentFileSizes, boolean incl
         return stats;
     }
 
-    /**
-     * Global stats on segments.
-     */
-    public ProtobufSegmentsStats protobufSegmentsStats(boolean includeSegmentFileSizes, boolean includeUnloadedSegments) {
-        ensureOpen();
-        Set<String> segmentName = new HashSet<>();
-        ProtobufSegmentsStats stats = new ProtobufSegmentsStats();
-        try (Searcher searcher = acquireSearcher("segments_stats", SearcherScope.INTERNAL)) {
-            for (LeafReaderContext ctx : searcher.getIndexReader().getContext().leaves()) {
-                SegmentReader segmentReader = Lucene.segmentReader(ctx.reader());
-                protobufFillSegmentStats(segmentReader, includeSegmentFileSizes, stats);
-                segmentName.add(segmentReader.getSegmentName());
-            }
-        }
-
-        try (Searcher searcher = acquireSearcher("segments_stats", SearcherScope.EXTERNAL)) {
-            for (LeafReaderContext ctx : searcher.getIndexReader().getContext().leaves()) {
-                SegmentReader segmentReader = Lucene.segmentReader(ctx.reader());
-                if (segmentName.contains(segmentReader.getSegmentName()) == false) {
-                    protobufFillSegmentStats(segmentReader, includeSegmentFileSizes, stats);
-                }
-            }
-        }
-        stats.addVersionMapMemoryInBytes(0);
-        stats.addIndexWriterMemoryInBytes(0);
-        return stats;
-    }
-
     protected TranslogDeletionPolicy getTranslogDeletionPolicy(EngineConfig engineConfig) {
         TranslogDeletionPolicy customTranslogDeletionPolicy = null;
         if (engineConfig.getCustomTranslogDeletionPolicyFactory() != null) {
@@ -1019,14 +950,6 @@ protected void fillSegmentStats(SegmentReader segmentReader, boolean includeSegm
         }
     }
 
-    protected void protobufFillSegmentStats(SegmentReader segmentReader, boolean includeSegmentFileSizes, ProtobufSegmentsStats stats) {
-        stats.add(1);
-        if (includeSegmentFileSizes) {
-            // TODO: consider moving this to StoreStats
-            stats.addFileSizes(getSegmentFileSizes(segmentReader));
-        }
-    }
-
     private Map<String, Long> getSegmentFileSizes(SegmentReader segmentReader) {
         Directory directory = null;
         SegmentCommitInfo segmentCommitInfo = segmentReader.getSegmentInfo();
diff --git a/server/src/main/java/org/opensearch/index/engine/ProtobufSegmentsStats.java b/server/src/main/java/org/opensearch/index/engine/ProtobufSegmentsStats.java
deleted file mode 100644
index c5665107dd624..0000000000000
--- a/server/src/main/java/org/opensearch/index/engine/ProtobufSegmentsStats.java
+++ /dev/null
@@ -1,285 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.index.engine;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.Version;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Tracker for segment stats
-*
-* @opensearch.internal
-*/
-public class ProtobufSegmentsStats implements ProtobufWriteable, ToXContentFragment {
-
-    private long count;
-    private long indexWriterMemoryInBytes;
-    private long versionMapMemoryInBytes;
-    private long maxUnsafeAutoIdTimestamp = Long.MIN_VALUE;
-    private long bitsetMemoryInBytes;
-    private final Map<String, Long> fileSizes;
-
-    private static final ByteSizeValue ZERO_BYTE_SIZE_VALUE = new ByteSizeValue(0L);
-
-    /*
-    * A map to provide a best-effort approach describing Lucene index files.
-    *
-    * Ideally this should be in sync to what the current version of Lucene is using, but it's harmless to leave extensions out,
-    * they'll just miss a proper description in the stats
-    */
-    private static final Map<String, String> FILE_DESCRIPTIONS = Map.ofEntries(
-        Map.entry("si", "Segment Info"),
-        Map.entry("fnm", "Fields"),
-        Map.entry("fdx", "Field Index"),
-        Map.entry("fdt", "Field Data"),
-        Map.entry("tim", "Term Dictionary"),
-        Map.entry("tip", "Term Index"),
-        Map.entry("doc", "Frequencies"),
-        Map.entry("pos", "Positions"),
-        Map.entry("pay", "Payloads"),
-        Map.entry("nvd", "Norms"),
-        Map.entry("nvm", "Norms"),
-        Map.entry("dii", "Points"),
-        Map.entry("dim", "Points"),
-        Map.entry("dvd", "DocValues"),
-        Map.entry("dvm", "DocValues"),
-        Map.entry("tvx", "Term Vector Index"),
-        Map.entry("tvd", "Term Vector Documents"),
-        Map.entry("tvf", "Term Vector Fields"),
-        Map.entry("liv", "Live Documents")
-    );
-
-    public ProtobufSegmentsStats() {
-        fileSizes = new HashMap<>();
-    }
-
-    public ProtobufSegmentsStats(CodedInputStream in) throws IOException {
-        count = in.readInt64();
-        // the following was removed in Lucene 9 (https://issues.apache.org/jira/browse/LUCENE-9387)
-        // retain for bwc only (todo: remove in OpenSearch 3)
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        if (protobufStreamInput.getVersion().before(Version.V_2_0_0)) {
-            in.readInt64(); // estimated segment memory
-            in.readInt64(); // estimated terms memory
-            in.readInt64(); // estimated stored fields memory
-            in.readInt64(); // estimated term vector memory
-            in.readInt64(); // estimated norms memory
-            in.readInt64(); // estimated points memory
-            in.readInt64(); // estimated doc values memory
-        }
-        indexWriterMemoryInBytes = in.readInt64();
-        versionMapMemoryInBytes = in.readInt64();
-        bitsetMemoryInBytes = in.readInt64();
-        maxUnsafeAutoIdTimestamp = in.readInt64();
-        fileSizes = protobufStreamInput.readMap(CodedInputStream::readString, CodedInputStream::readInt64);
-    }
-
-    public void add(long count) {
-        this.count += count;
-    }
-
-    public void addIndexWriterMemoryInBytes(long indexWriterMemoryInBytes) {
-        this.indexWriterMemoryInBytes += indexWriterMemoryInBytes;
-    }
-
-    public void addVersionMapMemoryInBytes(long versionMapMemoryInBytes) {
-        this.versionMapMemoryInBytes += versionMapMemoryInBytes;
-    }
-
-    void updateMaxUnsafeAutoIdTimestamp(long maxUnsafeAutoIdTimestamp) {
-        this.maxUnsafeAutoIdTimestamp = Math.max(maxUnsafeAutoIdTimestamp, this.maxUnsafeAutoIdTimestamp);
-    }
-
-    public void addBitsetMemoryInBytes(long bitsetMemoryInBytes) {
-        this.bitsetMemoryInBytes += bitsetMemoryInBytes;
-    }
-
-    public void addFileSizes(final Map<String, Long> newFileSizes) {
-        newFileSizes.forEach((k, v) -> this.fileSizes.merge(k, v, (a, b) -> {
-            assert a != null;
-            assert b != null;
-            return Math.addExact(a, b);
-        }));
-    }
-
-    public void add(ProtobufSegmentsStats mergeStats) {
-        if (mergeStats == null) {
-            return;
-        }
-        updateMaxUnsafeAutoIdTimestamp(mergeStats.maxUnsafeAutoIdTimestamp);
-        add(mergeStats.count);
-        addIndexWriterMemoryInBytes(mergeStats.indexWriterMemoryInBytes);
-        addVersionMapMemoryInBytes(mergeStats.versionMapMemoryInBytes);
-        addBitsetMemoryInBytes(mergeStats.bitsetMemoryInBytes);
-        addFileSizes(mergeStats.fileSizes);
-    }
-
-    /**
-     * The number of segments.
-    */
-    public long getCount() {
-        return this.count;
-    }
-
-    /**
-     * Estimation of the memory usage by index writer
-    */
-    public long getIndexWriterMemoryInBytes() {
-        return this.indexWriterMemoryInBytes;
-    }
-
-    public ByteSizeValue getIndexWriterMemory() {
-        return new ByteSizeValue(indexWriterMemoryInBytes);
-    }
-
-    /**
-     * Estimation of the memory usage by version map
-    */
-    public long getVersionMapMemoryInBytes() {
-        return this.versionMapMemoryInBytes;
-    }
-
-    public ByteSizeValue getVersionMapMemory() {
-        return new ByteSizeValue(versionMapMemoryInBytes);
-    }
-
-    /**
-     * Estimation of how much the cached bit sets are taking. (which nested and p/c rely on)
-    */
-    public long getBitsetMemoryInBytes() {
-        return bitsetMemoryInBytes;
-    }
-
-    public ByteSizeValue getBitsetMemory() {
-        return new ByteSizeValue(bitsetMemoryInBytes);
-    }
-
-    /** Returns mapping of file names to their size (only used in tests) */
-    public Map<String, Long> getFileSizes() {
-        return Collections.unmodifiableMap(this.fileSizes);
-    }
-
-    /**
-     * Returns the max timestamp that is used to de-optimize documents with auto-generated IDs in the engine.
-    * This is used to ensure we don't add duplicate documents when we assume an append only case based on auto-generated IDs
-    */
-    public long getMaxUnsafeAutoIdTimestamp() {
-        return maxUnsafeAutoIdTimestamp;
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.SEGMENTS);
-        builder.field(Fields.COUNT, count);
-        builder.humanReadableField(Fields.MEMORY_IN_BYTES, Fields.MEMORY, ZERO_BYTE_SIZE_VALUE);
-        builder.humanReadableField(Fields.TERMS_MEMORY_IN_BYTES, Fields.TERMS_MEMORY, ZERO_BYTE_SIZE_VALUE);
-        builder.humanReadableField(Fields.STORED_FIELDS_MEMORY_IN_BYTES, Fields.STORED_FIELDS_MEMORY, ZERO_BYTE_SIZE_VALUE);
-        builder.humanReadableField(Fields.TERM_VECTORS_MEMORY_IN_BYTES, Fields.TERM_VECTORS_MEMORY, ZERO_BYTE_SIZE_VALUE);
-        builder.humanReadableField(Fields.NORMS_MEMORY_IN_BYTES, Fields.NORMS_MEMORY, ZERO_BYTE_SIZE_VALUE);
-        builder.humanReadableField(Fields.POINTS_MEMORY_IN_BYTES, Fields.POINTS_MEMORY, ZERO_BYTE_SIZE_VALUE);
-        builder.humanReadableField(Fields.DOC_VALUES_MEMORY_IN_BYTES, Fields.DOC_VALUES_MEMORY, ZERO_BYTE_SIZE_VALUE);
-        builder.humanReadableField(Fields.INDEX_WRITER_MEMORY_IN_BYTES, Fields.INDEX_WRITER_MEMORY, getIndexWriterMemory());
-        builder.humanReadableField(Fields.VERSION_MAP_MEMORY_IN_BYTES, Fields.VERSION_MAP_MEMORY, getVersionMapMemory());
-        builder.humanReadableField(Fields.FIXED_BIT_SET_MEMORY_IN_BYTES, Fields.FIXED_BIT_SET, getBitsetMemory());
-        builder.field(Fields.MAX_UNSAFE_AUTO_ID_TIMESTAMP, maxUnsafeAutoIdTimestamp);
-        builder.startObject(Fields.FILE_SIZES);
-        for (Map.Entry<String, Long> entry : fileSizes.entrySet()) {
-            builder.startObject(entry.getKey());
-            builder.humanReadableField(Fields.SIZE_IN_BYTES, Fields.SIZE, new ByteSizeValue(entry.getValue()));
-            builder.field(Fields.DESCRIPTION, FILE_DESCRIPTIONS.getOrDefault(entry.getKey(), "Others"));
-            builder.endObject();
-        }
-        builder.endObject();
-        builder.endObject();
-        return builder;
-    }
-
-    /**
-     * Fields for segment statistics
-    *
-    * @opensearch.internal
-    */
-    static final class Fields {
-        static final String SEGMENTS = "segments";
-        static final String COUNT = "count";
-        static final String MEMORY = "memory";
-        static final String MEMORY_IN_BYTES = "memory_in_bytes";
-        static final String TERMS_MEMORY = "terms_memory";
-        static final String TERMS_MEMORY_IN_BYTES = "terms_memory_in_bytes";
-        static final String STORED_FIELDS_MEMORY = "stored_fields_memory";
-        static final String STORED_FIELDS_MEMORY_IN_BYTES = "stored_fields_memory_in_bytes";
-        static final String TERM_VECTORS_MEMORY = "term_vectors_memory";
-        static final String TERM_VECTORS_MEMORY_IN_BYTES = "term_vectors_memory_in_bytes";
-        static final String NORMS_MEMORY = "norms_memory";
-        static final String NORMS_MEMORY_IN_BYTES = "norms_memory_in_bytes";
-        static final String POINTS_MEMORY = "points_memory";
-        static final String POINTS_MEMORY_IN_BYTES = "points_memory_in_bytes";
-        static final String DOC_VALUES_MEMORY = "doc_values_memory";
-        static final String DOC_VALUES_MEMORY_IN_BYTES = "doc_values_memory_in_bytes";
-        static final String INDEX_WRITER_MEMORY = "index_writer_memory";
-        static final String INDEX_WRITER_MEMORY_IN_BYTES = "index_writer_memory_in_bytes";
-        static final String VERSION_MAP_MEMORY = "version_map_memory";
-        static final String VERSION_MAP_MEMORY_IN_BYTES = "version_map_memory_in_bytes";
-        static final String MAX_UNSAFE_AUTO_ID_TIMESTAMP = "max_unsafe_auto_id_timestamp";
-        static final String FIXED_BIT_SET = "fixed_bit_set";
-        static final String FIXED_BIT_SET_MEMORY_IN_BYTES = "fixed_bit_set_memory_in_bytes";
-        static final String FILE_SIZES = "file_sizes";
-        static final String SIZE = "size";
-        static final String SIZE_IN_BYTES = "size_in_bytes";
-        static final String DESCRIPTION = "description";
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(count);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        if (protobufStreamOutput.getVersion().before(Version.V_2_0_0)) {
-            // the following was removed in Lucene 9 (https://issues.apache.org/jira/browse/LUCENE-9387)
-            // retain the following for bwc only (todo: remove in OpenSearch 3)
-            out.writeInt64NoTag(0L); // estimated memory
-            out.writeInt64NoTag(0L); // estimated terms memory
-            out.writeInt64NoTag(0L); // estimated stored fields memory
-            out.writeInt64NoTag(0L); // estimated term vector memory
-            out.writeInt64NoTag(0L); // estimated norms memory
-            out.writeInt64NoTag(0L); // estimated points memory
-            out.writeInt64NoTag(0L); // estimated doc values memory
-        }
-        out.writeInt64NoTag(indexWriterMemoryInBytes);
-        out.writeInt64NoTag(versionMapMemoryInBytes);
-        out.writeInt64NoTag(bitsetMemoryInBytes);
-        out.writeInt64NoTag(maxUnsafeAutoIdTimestamp);
-        protobufStreamOutput.writeMap(this.fileSizes, CodedOutputStream::writeStringNoTag, CodedOutputStream::writeInt64NoTag);
-    }
-
-    public void clearFileSizes() {
-        fileSizes.clear();
-    }
-
-    /**
-     * Used only for deprecating memory tracking in REST interface
-    * todo remove in OpenSearch 3.0
-    * @deprecated
-    */
-    @Deprecated
-    public ByteSizeValue getZeroMemory() {
-        return ZERO_BYTE_SIZE_VALUE;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/index/fielddata/ProtobufFieldDataStats.java b/server/src/main/java/org/opensearch/index/fielddata/ProtobufFieldDataStats.java
deleted file mode 100644
index cffac8b1c0d3f..0000000000000
--- a/server/src/main/java/org/opensearch/index/fielddata/ProtobufFieldDataStats.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.index.fielddata;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.ProtobufFieldMemoryStats;
-import org.opensearch.common.Nullable;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.util.Objects;
-
-/**
- * Encapsulates heap usage for field data
-*
-* @opensearch.internal
-*/
-public class ProtobufFieldDataStats implements ProtobufWriteable, ToXContentFragment {
-
-    private static final String FIELDDATA = "fielddata";
-    private static final String MEMORY_SIZE = "memory_size";
-    private static final String MEMORY_SIZE_IN_BYTES = "memory_size_in_bytes";
-    private static final String EVICTIONS = "evictions";
-    private static final String FIELDS = "fields";
-    private long memorySize;
-    private long evictions;
-    @Nullable
-    private ProtobufFieldMemoryStats fields;
-
-    public ProtobufFieldDataStats() {
-
-    }
-
-    public ProtobufFieldDataStats(CodedInputStream in) throws IOException {
-        memorySize = in.readInt64();
-        evictions = in.readInt64();
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        fields = protobufStreamInput.readOptionalWriteable(ProtobufFieldMemoryStats::new);
-    }
-
-    public ProtobufFieldDataStats(long memorySize, long evictions, @Nullable ProtobufFieldMemoryStats fields) {
-        this.memorySize = memorySize;
-        this.evictions = evictions;
-        this.fields = fields;
-    }
-
-    public void add(ProtobufFieldDataStats stats) {
-        this.memorySize += stats.memorySize;
-        this.evictions += stats.evictions;
-        if (stats.fields != null) {
-            if (fields == null) {
-                fields = stats.fields.copy();
-            } else {
-                fields.add(stats.fields);
-            }
-        }
-    }
-
-    public long getMemorySizeInBytes() {
-        return this.memorySize;
-    }
-
-    public ByteSizeValue getMemorySize() {
-        return new ByteSizeValue(memorySize);
-    }
-
-    public long getEvictions() {
-        return this.evictions;
-    }
-
-    @Nullable
-    public ProtobufFieldMemoryStats getFields() {
-        return fields;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(memorySize);
-        out.writeInt64NoTag(evictions);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeOptionalWriteable(fields);
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(FIELDDATA);
-        builder.humanReadableField(MEMORY_SIZE_IN_BYTES, MEMORY_SIZE, getMemorySize());
-        builder.field(EVICTIONS, getEvictions());
-        if (fields != null) {
-            fields.toXContent(builder, FIELDS, MEMORY_SIZE_IN_BYTES, MEMORY_SIZE);
-        }
-        builder.endObject();
-        return builder;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        ProtobufFieldDataStats that = (ProtobufFieldDataStats) o;
-        return memorySize == that.memorySize && evictions == that.evictions && Objects.equals(fields, that.fields);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(memorySize, evictions, fields);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/index/fielddata/ShardFieldData.java b/server/src/main/java/org/opensearch/index/fielddata/ShardFieldData.java
index b786e625228a6..138b417571784 100644
--- a/server/src/main/java/org/opensearch/index/fielddata/ShardFieldData.java
+++ b/server/src/main/java/org/opensearch/index/fielddata/ShardFieldData.java
@@ -34,7 +34,6 @@
 
 import org.apache.lucene.util.Accountable;
 import org.opensearch.common.FieldMemoryStats;
-import org.opensearch.common.ProtobufFieldMemoryStats;
 import org.opensearch.common.metrics.CounterMetric;
 import org.opensearch.common.regex.Regex;
 import org.opensearch.common.util.CollectionUtils;
@@ -73,23 +72,6 @@ public FieldDataStats stats(String... fields) {
         );
     }
 
-    public ProtobufFieldDataStats protobufStats(String... fields) {
-        ObjectLongHashMap<String> fieldTotals = null;
-        if (CollectionUtils.isEmpty(fields) == false) {
-            fieldTotals = new ObjectLongHashMap<>();
-            for (Map.Entry<String, CounterMetric> entry : perFieldTotals.entrySet()) {
-                if (Regex.simpleMatch(fields, entry.getKey())) {
-                    fieldTotals.put(entry.getKey(), entry.getValue().count());
-                }
-            }
-        }
-        return new ProtobufFieldDataStats(
-            totalMetric.count(),
-            evictionsMetric.count(),
-            fieldTotals == null ? null : new ProtobufFieldMemoryStats(fieldTotals)
-        );
-    }
-
     @Override
     public void onCache(ShardId shardId, String fieldName, Accountable ramUsage) {
         totalMetric.inc(ramUsage.ramBytesUsed());
diff --git a/server/src/main/java/org/opensearch/index/flush/ProtobufFlushStats.java b/server/src/main/java/org/opensearch/index/flush/ProtobufFlushStats.java
deleted file mode 100644
index 683389e339708..0000000000000
--- a/server/src/main/java/org/opensearch/index/flush/ProtobufFlushStats.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.index.flush;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-
-/**
- * Encapsulates statistics for flush
-*
-* @opensearch.internal
-*/
-public class ProtobufFlushStats implements ProtobufWriteable, ToXContentFragment {
-
-    private long total;
-    private long periodic;
-    private long totalTimeInMillis;
-
-    public ProtobufFlushStats() {
-
-    }
-
-    public ProtobufFlushStats(CodedInputStream in) throws IOException {
-        total = in.readInt64();
-        totalTimeInMillis = in.readInt64();
-        periodic = in.readInt64();
-    }
-
-    public ProtobufFlushStats(long total, long periodic, long totalTimeInMillis) {
-        this.total = total;
-        this.periodic = periodic;
-        this.totalTimeInMillis = totalTimeInMillis;
-    }
-
-    public void add(long total, long periodic, long totalTimeInMillis) {
-        this.total += total;
-        this.periodic += periodic;
-        this.totalTimeInMillis += totalTimeInMillis;
-    }
-
-    public void add(ProtobufFlushStats flushStats) {
-        addTotals(flushStats);
-    }
-
-    public void addTotals(ProtobufFlushStats flushStats) {
-        if (flushStats == null) {
-            return;
-        }
-        this.total += flushStats.total;
-        this.periodic += flushStats.periodic;
-        this.totalTimeInMillis += flushStats.totalTimeInMillis;
-    }
-
-    /**
-     * The total number of flush executed.
-    */
-    public long getTotal() {
-        return this.total;
-    }
-
-    /**
-     * The number of flushes that were periodically triggered when translog exceeded the flush threshold.
-    */
-    public long getPeriodic() {
-        return periodic;
-    }
-
-    /**
-     * The total time merges have been executed (in milliseconds).
-    */
-    public long getTotalTimeInMillis() {
-        return this.totalTimeInMillis;
-    }
-
-    /**
-     * The total time merges have been executed.
-    */
-    public TimeValue getTotalTime() {
-        return new TimeValue(totalTimeInMillis);
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.FLUSH);
-        builder.field(Fields.TOTAL, total);
-        builder.field(Fields.PERIODIC, periodic);
-        builder.humanReadableField(Fields.TOTAL_TIME_IN_MILLIS, Fields.TOTAL_TIME, getTotalTime());
-        builder.endObject();
-        return builder;
-    }
-
-    /**
-     * Fields for flush statistics
-    *
-    * @opensearch.internal
-    */
-    static final class Fields {
-        static final String FLUSH = "flush";
-        static final String TOTAL = "total";
-        static final String PERIODIC = "periodic";
-        static final String TOTAL_TIME = "total_time";
-        static final String TOTAL_TIME_IN_MILLIS = "total_time_in_millis";
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(total);
-        out.writeInt64NoTag(totalTimeInMillis);
-        out.writeInt64NoTag(periodic);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/index/get/ProtobufGetStats.java b/server/src/main/java/org/opensearch/index/get/ProtobufGetStats.java
deleted file mode 100644
index 751bcdd76b07e..0000000000000
--- a/server/src/main/java/org/opensearch/index/get/ProtobufGetStats.java
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.index.get;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-
-/**
- * Stats for a search get
-*
-* @opensearch.api
-*/
-public class ProtobufGetStats implements ProtobufWriteable, ToXContentFragment {
-
-    private long existsCount;
-    private long existsTimeInMillis;
-    private long missingCount;
-    private long missingTimeInMillis;
-    private long current;
-
-    public ProtobufGetStats() {}
-
-    public ProtobufGetStats(CodedInputStream in) throws IOException {
-        existsCount = in.readInt64();
-        existsTimeInMillis = in.readInt64();
-        missingCount = in.readInt64();
-        missingTimeInMillis = in.readInt64();
-        current = in.readInt64();
-    }
-
-    public ProtobufGetStats(long existsCount, long existsTimeInMillis, long missingCount, long missingTimeInMillis, long current) {
-        this.existsCount = existsCount;
-        this.existsTimeInMillis = existsTimeInMillis;
-        this.missingCount = missingCount;
-        this.missingTimeInMillis = missingTimeInMillis;
-        this.current = current;
-    }
-
-    public void add(ProtobufGetStats stats) {
-        if (stats == null) {
-            return;
-        }
-        current += stats.current;
-        addTotals(stats);
-    }
-
-    public void addTotals(ProtobufGetStats stats) {
-        if (stats == null) {
-            return;
-        }
-        existsCount += stats.existsCount;
-        existsTimeInMillis += stats.existsTimeInMillis;
-        missingCount += stats.missingCount;
-        missingTimeInMillis += stats.missingTimeInMillis;
-        current += stats.current;
-    }
-
-    public long getCount() {
-        return existsCount + missingCount;
-    }
-
-    public long getTimeInMillis() {
-        return existsTimeInMillis + missingTimeInMillis;
-    }
-
-    public TimeValue getTime() {
-        return new TimeValue(getTimeInMillis());
-    }
-
-    public long getExistsCount() {
-        return this.existsCount;
-    }
-
-    public long getExistsTimeInMillis() {
-        return this.existsTimeInMillis;
-    }
-
-    public TimeValue getExistsTime() {
-        return new TimeValue(existsTimeInMillis);
-    }
-
-    public long getMissingCount() {
-        return this.missingCount;
-    }
-
-    public long getMissingTimeInMillis() {
-        return this.missingTimeInMillis;
-    }
-
-    public TimeValue getMissingTime() {
-        return new TimeValue(missingTimeInMillis);
-    }
-
-    public long current() {
-        return this.current;
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.GET);
-        builder.field(Fields.TOTAL, getCount());
-        builder.humanReadableField(Fields.TIME_IN_MILLIS, Fields.TIME, getTime());
-        builder.field(Fields.EXISTS_TOTAL, existsCount);
-        builder.humanReadableField(Fields.EXISTS_TIME_IN_MILLIS, Fields.EXISTS_TIME, getExistsTime());
-        builder.field(Fields.MISSING_TOTAL, missingCount);
-        builder.humanReadableField(Fields.MISSING_TIME_IN_MILLIS, Fields.MISSING_TIME, getMissingTime());
-        builder.field(Fields.CURRENT, current);
-        builder.endObject();
-        return builder;
-    }
-
-    /**
-     * Fields for get statistics
-    *
-    * @opensearch.internal
-    */
-    static final class Fields {
-        static final String GET = "get";
-        static final String TOTAL = "total";
-        static final String TIME = "getTime";
-        static final String TIME_IN_MILLIS = "time_in_millis";
-        static final String EXISTS_TOTAL = "exists_total";
-        static final String EXISTS_TIME = "exists_time";
-        static final String EXISTS_TIME_IN_MILLIS = "exists_time_in_millis";
-        static final String MISSING_TOTAL = "missing_total";
-        static final String MISSING_TIME = "missing_time";
-        static final String MISSING_TIME_IN_MILLIS = "missing_time_in_millis";
-        static final String CURRENT = "current";
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(existsCount);
-        out.writeInt64NoTag(existsTimeInMillis);
-        out.writeInt64NoTag(missingCount);
-        out.writeInt64NoTag(missingTimeInMillis);
-        out.writeInt64NoTag(current);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/index/get/ShardGetService.java b/server/src/main/java/org/opensearch/index/get/ShardGetService.java
index 86df8a72ab18c..8f81e704ef2d4 100644
--- a/server/src/main/java/org/opensearch/index/get/ShardGetService.java
+++ b/server/src/main/java/org/opensearch/index/get/ShardGetService.java
@@ -113,16 +113,6 @@ public GetStats stats() {
         );
     }
 
-    public ProtobufGetStats protobufStats() {
-        return new ProtobufGetStats(
-            existsMetric.count(),
-            TimeUnit.NANOSECONDS.toMillis(existsMetric.sum()),
-            missingMetric.count(),
-            TimeUnit.NANOSECONDS.toMillis(missingMetric.sum()),
-            currentMetric.count()
-        );
-    }
-
     public GetResult get(
         String id,
         String[] gFields,
diff --git a/server/src/main/java/org/opensearch/index/merge/ProtobufMergeStats.java b/server/src/main/java/org/opensearch/index/merge/ProtobufMergeStats.java
deleted file mode 100644
index 3a2ab71e28c09..0000000000000
--- a/server/src/main/java/org/opensearch/index/merge/ProtobufMergeStats.java
+++ /dev/null
@@ -1,262 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.index.merge;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-
-/**
- * Stores stats about a merge process
-*
-* @opensearch.internal
-*/
-public class ProtobufMergeStats implements ProtobufWriteable, ToXContentFragment {
-
-    private long total;
-    private long totalTimeInMillis;
-    private long totalNumDocs;
-    private long totalSizeInBytes;
-    private long current;
-    private long currentNumDocs;
-    private long currentSizeInBytes;
-
-    /** Total millis that large merges were stopped so that smaller merges would finish. */
-    private long totalStoppedTimeInMillis;
-
-    /** Total millis that we slept during writes so merge IO is throttled. */
-    private long totalThrottledTimeInMillis;
-
-    private long totalBytesPerSecAutoThrottle;
-
-    public ProtobufMergeStats() {
-
-    }
-
-    public ProtobufMergeStats(CodedInputStream in) throws IOException {
-        total = in.readInt64();
-        totalTimeInMillis = in.readInt64();
-        totalNumDocs = in.readInt64();
-        totalSizeInBytes = in.readInt64();
-        current = in.readInt64();
-        currentNumDocs = in.readInt64();
-        currentSizeInBytes = in.readInt64();
-        // Added in 2.0:
-        totalStoppedTimeInMillis = in.readInt64();
-        totalThrottledTimeInMillis = in.readInt64();
-        totalBytesPerSecAutoThrottle = in.readInt64();
-    }
-
-    public void add(
-        long totalMerges,
-        long totalMergeTime,
-        long totalNumDocs,
-        long totalSizeInBytes,
-        long currentMerges,
-        long currentNumDocs,
-        long currentSizeInBytes,
-        long stoppedTimeMillis,
-        long throttledTimeMillis,
-        double mbPerSecAutoThrottle
-    ) {
-        this.total += totalMerges;
-        this.totalTimeInMillis += totalMergeTime;
-        this.totalNumDocs += totalNumDocs;
-        this.totalSizeInBytes += totalSizeInBytes;
-        this.current += currentMerges;
-        this.currentNumDocs += currentNumDocs;
-        this.currentSizeInBytes += currentSizeInBytes;
-        this.totalStoppedTimeInMillis += stoppedTimeMillis;
-        this.totalThrottledTimeInMillis += throttledTimeMillis;
-        long bytesPerSecAutoThrottle = (long) (mbPerSecAutoThrottle * 1024 * 1024);
-        if (this.totalBytesPerSecAutoThrottle == Long.MAX_VALUE || bytesPerSecAutoThrottle == Long.MAX_VALUE) {
-            this.totalBytesPerSecAutoThrottle = Long.MAX_VALUE;
-        } else {
-            this.totalBytesPerSecAutoThrottle += bytesPerSecAutoThrottle;
-        }
-    }
-
-    public void add(ProtobufMergeStats mergeStats) {
-        if (mergeStats == null) {
-            return;
-        }
-        this.current += mergeStats.current;
-        this.currentNumDocs += mergeStats.currentNumDocs;
-        this.currentSizeInBytes += mergeStats.currentSizeInBytes;
-
-        addTotals(mergeStats);
-    }
-
-    public void addTotals(ProtobufMergeStats mergeStats) {
-        if (mergeStats == null) {
-            return;
-        }
-        this.total += mergeStats.total;
-        this.totalTimeInMillis += mergeStats.totalTimeInMillis;
-        this.totalNumDocs += mergeStats.totalNumDocs;
-        this.totalSizeInBytes += mergeStats.totalSizeInBytes;
-        this.totalStoppedTimeInMillis += mergeStats.totalStoppedTimeInMillis;
-        this.totalThrottledTimeInMillis += mergeStats.totalThrottledTimeInMillis;
-        if (this.totalBytesPerSecAutoThrottle == Long.MAX_VALUE || mergeStats.totalBytesPerSecAutoThrottle == Long.MAX_VALUE) {
-            this.totalBytesPerSecAutoThrottle = Long.MAX_VALUE;
-        } else {
-            this.totalBytesPerSecAutoThrottle += mergeStats.totalBytesPerSecAutoThrottle;
-        }
-    }
-
-    /**
-     * The total number of merges executed.
-    */
-    public long getTotal() {
-        return this.total;
-    }
-
-    /**
-     * The total time merges have been executed (in milliseconds).
-    */
-    public long getTotalTimeInMillis() {
-        return this.totalTimeInMillis;
-    }
-
-    /**
-     * The total time large merges were stopped so smaller merges could finish.
-    */
-    public long getTotalStoppedTimeInMillis() {
-        return this.totalStoppedTimeInMillis;
-    }
-
-    /**
-     * The total time large merges were stopped so smaller merges could finish.
-    */
-    public TimeValue getTotalStoppedTime() {
-        return new TimeValue(totalStoppedTimeInMillis);
-    }
-
-    /**
-     * The total time merge IO writes were throttled.
-    */
-    public long getTotalThrottledTimeInMillis() {
-        return this.totalThrottledTimeInMillis;
-    }
-
-    /**
-     * The total time merge IO writes were throttled.
-    */
-    public TimeValue getTotalThrottledTime() {
-        return new TimeValue(totalThrottledTimeInMillis);
-    }
-
-    /**
-     * The total time merges have been executed.
-    */
-    public TimeValue getTotalTime() {
-        return new TimeValue(totalTimeInMillis);
-    }
-
-    public long getTotalNumDocs() {
-        return this.totalNumDocs;
-    }
-
-    public long getTotalSizeInBytes() {
-        return this.totalSizeInBytes;
-    }
-
-    public ByteSizeValue getTotalSize() {
-        return new ByteSizeValue(totalSizeInBytes);
-    }
-
-    public long getTotalBytesPerSecAutoThrottle() {
-        return totalBytesPerSecAutoThrottle;
-    }
-
-    /**
-     * The current number of merges executing.
-    */
-    public long getCurrent() {
-        return this.current;
-    }
-
-    public long getCurrentNumDocs() {
-        return this.currentNumDocs;
-    }
-
-    public long getCurrentSizeInBytes() {
-        return this.currentSizeInBytes;
-    }
-
-    public ByteSizeValue getCurrentSize() {
-        return new ByteSizeValue(currentSizeInBytes);
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.MERGES);
-        builder.field(Fields.CURRENT, current);
-        builder.field(Fields.CURRENT_DOCS, currentNumDocs);
-        builder.humanReadableField(Fields.CURRENT_SIZE_IN_BYTES, Fields.CURRENT_SIZE, getCurrentSize());
-        builder.field(Fields.TOTAL, total);
-        builder.humanReadableField(Fields.TOTAL_TIME_IN_MILLIS, Fields.TOTAL_TIME, getTotalTime());
-        builder.field(Fields.TOTAL_DOCS, totalNumDocs);
-        builder.humanReadableField(Fields.TOTAL_SIZE_IN_BYTES, Fields.TOTAL_SIZE, getTotalSize());
-        builder.humanReadableField(Fields.TOTAL_STOPPED_TIME_IN_MILLIS, Fields.TOTAL_STOPPED_TIME, getTotalStoppedTime());
-        builder.humanReadableField(Fields.TOTAL_THROTTLED_TIME_IN_MILLIS, Fields.TOTAL_THROTTLED_TIME, getTotalThrottledTime());
-        if (builder.humanReadable() && totalBytesPerSecAutoThrottle != -1) {
-            builder.field(Fields.TOTAL_THROTTLE_BYTES_PER_SEC).value(new ByteSizeValue(totalBytesPerSecAutoThrottle).toString());
-        }
-        builder.field(Fields.TOTAL_THROTTLE_BYTES_PER_SEC_IN_BYTES, totalBytesPerSecAutoThrottle);
-        builder.endObject();
-        return builder;
-    }
-
-    /**
-     * Fields used for merge statistics
-    *
-    * @opensearch.internal
-    */
-    static final class Fields {
-        static final String MERGES = "merges";
-        static final String CURRENT = "current";
-        static final String CURRENT_DOCS = "current_docs";
-        static final String CURRENT_SIZE = "current_size";
-        static final String CURRENT_SIZE_IN_BYTES = "current_size_in_bytes";
-        static final String TOTAL = "total";
-        static final String TOTAL_TIME = "total_time";
-        static final String TOTAL_TIME_IN_MILLIS = "total_time_in_millis";
-        static final String TOTAL_STOPPED_TIME = "total_stopped_time";
-        static final String TOTAL_STOPPED_TIME_IN_MILLIS = "total_stopped_time_in_millis";
-        static final String TOTAL_THROTTLED_TIME = "total_throttled_time";
-        static final String TOTAL_THROTTLED_TIME_IN_MILLIS = "total_throttled_time_in_millis";
-        static final String TOTAL_DOCS = "total_docs";
-        static final String TOTAL_SIZE = "total_size";
-        static final String TOTAL_SIZE_IN_BYTES = "total_size_in_bytes";
-        static final String TOTAL_THROTTLE_BYTES_PER_SEC_IN_BYTES = "total_auto_throttle_in_bytes";
-        static final String TOTAL_THROTTLE_BYTES_PER_SEC = "total_auto_throttle";
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(total);
-        out.writeInt64NoTag(totalTimeInMillis);
-        out.writeInt64NoTag(totalNumDocs);
-        out.writeInt64NoTag(totalSizeInBytes);
-        out.writeInt64NoTag(current);
-        out.writeInt64NoTag(currentNumDocs);
-        out.writeInt64NoTag(currentSizeInBytes);
-        // Added in 2.0:
-        out.writeInt64NoTag(totalStoppedTimeInMillis);
-        out.writeInt64NoTag(totalThrottledTimeInMillis);
-        out.writeInt64NoTag(totalBytesPerSecAutoThrottle);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/index/recovery/ProtobufRecoveryStats.java b/server/src/main/java/org/opensearch/index/recovery/ProtobufRecoveryStats.java
deleted file mode 100644
index a3521e794368c..0000000000000
--- a/server/src/main/java/org/opensearch/index/recovery/ProtobufRecoveryStats.java
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.index.recovery;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
-
-/**
- * Recovery related statistics, starting at the shard level and allowing aggregation to
-* indices and node level
-*
-* @opensearch.internal
-*/
-public class ProtobufRecoveryStats implements ToXContentFragment, ProtobufWriteable {
-
-    private final AtomicInteger currentAsSource = new AtomicInteger();
-    private final AtomicInteger currentAsTarget = new AtomicInteger();
-    private final AtomicLong throttleTimeInNanos = new AtomicLong();
-
-    public ProtobufRecoveryStats() {}
-
-    public ProtobufRecoveryStats(CodedInputStream in) throws IOException {
-        currentAsSource.set(in.readInt32());
-        currentAsTarget.set(in.readInt32());
-        throttleTimeInNanos.set(in.readInt64());
-    }
-
-    public void add(ProtobufRecoveryStats recoveryStats) {
-        if (recoveryStats != null) {
-            this.currentAsSource.addAndGet(recoveryStats.currentAsSource());
-            this.currentAsTarget.addAndGet(recoveryStats.currentAsTarget());
-        }
-        addTotals(recoveryStats);
-    }
-
-    public void addTotals(ProtobufRecoveryStats recoveryStats) {
-        if (recoveryStats != null) {
-            this.throttleTimeInNanos.addAndGet(recoveryStats.throttleTime().nanos());
-        }
-    }
-
-    /**
-     * Number of ongoing recoveries for which a shard serves as a source
-    */
-    public int currentAsSource() {
-        return currentAsSource.get();
-    }
-
-    /**
-     * Number of ongoing recoveries for which a shard serves as a target
-    */
-    public int currentAsTarget() {
-        return currentAsTarget.get();
-    }
-
-    /**
-     * Total time recoveries waited due to throttling
-    */
-    public TimeValue throttleTime() {
-        return TimeValue.timeValueNanos(throttleTimeInNanos.get());
-    }
-
-    public void incCurrentAsTarget() {
-        currentAsTarget.incrementAndGet();
-    }
-
-    public void decCurrentAsTarget() {
-        currentAsTarget.decrementAndGet();
-    }
-
-    public void incCurrentAsSource() {
-        currentAsSource.incrementAndGet();
-    }
-
-    public void decCurrentAsSource() {
-        currentAsSource.decrementAndGet();
-    }
-
-    public void addThrottleTime(long nanos) {
-        throttleTimeInNanos.addAndGet(nanos);
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.RECOVERY);
-        builder.field(Fields.CURRENT_AS_SOURCE, currentAsSource());
-        builder.field(Fields.CURRENT_AS_TARGET, currentAsTarget());
-        builder.humanReadableField(Fields.THROTTLE_TIME_IN_MILLIS, Fields.THROTTLE_TIME, throttleTime());
-        builder.endObject();
-        return builder;
-    }
-
-    /**
-     * Fields for recovery statistics
-    *
-    * @opensearch.internal
-    */
-    static final class Fields {
-        static final String RECOVERY = "recovery";
-        static final String CURRENT_AS_SOURCE = "current_as_source";
-        static final String CURRENT_AS_TARGET = "current_as_target";
-        static final String THROTTLE_TIME = "throttle_time";
-        static final String THROTTLE_TIME_IN_MILLIS = "throttle_time_in_millis";
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt32NoTag(currentAsSource.get());
-        out.writeInt32NoTag(currentAsTarget.get());
-        out.writeInt64NoTag(throttleTimeInNanos.get());
-    }
-
-    @Override
-    public String toString() {
-        return "recoveryStats, currentAsSource ["
-            + currentAsSource()
-            + "],currentAsTarget ["
-            + currentAsTarget()
-            + "], throttle ["
-            + throttleTime()
-            + "]";
-    }
-}
diff --git a/server/src/main/java/org/opensearch/index/refresh/ProtobufRefreshStats.java b/server/src/main/java/org/opensearch/index/refresh/ProtobufRefreshStats.java
deleted file mode 100644
index 8688f660782b2..0000000000000
--- a/server/src/main/java/org/opensearch/index/refresh/ProtobufRefreshStats.java
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.index.refresh;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.util.Objects;
-
-/**
- * Encapsulates stats for index refresh
-*
-* @opensearch.internal
-*/
-public class ProtobufRefreshStats implements ProtobufWriteable, ToXContentFragment {
-
-    private long total;
-
-    private long totalTimeInMillis;
-
-    private long externalTotal;
-
-    private long externalTotalTimeInMillis;
-
-    /**
-     * Number of waiting refresh listeners.
-    */
-    private int listeners;
-
-    public ProtobufRefreshStats() {}
-
-    public ProtobufRefreshStats(CodedInputStream in) throws IOException {
-        total = in.readInt64();
-        totalTimeInMillis = in.readInt64();
-        externalTotal = in.readInt64();
-        externalTotalTimeInMillis = in.readInt64();
-        listeners = in.readInt32();
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(total);
-        out.writeInt64NoTag(totalTimeInMillis);
-        out.writeInt64NoTag(externalTotal);
-        out.writeInt64NoTag(externalTotalTimeInMillis);
-        out.writeInt32NoTag(listeners);
-    }
-
-    public ProtobufRefreshStats(long total, long totalTimeInMillis, long externalTotal, long externalTotalTimeInMillis, int listeners) {
-        this.total = total;
-        this.totalTimeInMillis = totalTimeInMillis;
-        this.externalTotal = externalTotal;
-        this.externalTotalTimeInMillis = externalTotalTimeInMillis;
-        this.listeners = listeners;
-    }
-
-    public void add(ProtobufRefreshStats refreshStats) {
-        addTotals(refreshStats);
-    }
-
-    public void addTotals(ProtobufRefreshStats refreshStats) {
-        if (refreshStats == null) {
-            return;
-        }
-        this.total += refreshStats.total;
-        this.totalTimeInMillis += refreshStats.totalTimeInMillis;
-        this.externalTotal += refreshStats.externalTotal;
-        this.externalTotalTimeInMillis += refreshStats.externalTotalTimeInMillis;
-        this.listeners += refreshStats.listeners;
-    }
-
-    /**
-     * The total number of refresh executed.
-    */
-    public long getTotal() {
-        return this.total;
-    }
-
-    /*
-    * The total number of external refresh executed.
-    */
-    public long getExternalTotal() {
-        return this.externalTotal;
-    }
-
-    /**
-     * The total time spent executing refreshes (in milliseconds).
-    */
-    public long getTotalTimeInMillis() {
-        return this.totalTimeInMillis;
-    }
-
-    /**
-     * The total time spent executing external refreshes (in milliseconds).
-    */
-    public long getExternalTotalTimeInMillis() {
-        return this.externalTotalTimeInMillis;
-    }
-
-    /**
-     * The total time refreshes have been executed.
-    */
-    public TimeValue getTotalTime() {
-        return new TimeValue(totalTimeInMillis);
-    }
-
-    /**
-     * The total time external refreshes have been executed.
-    */
-    public TimeValue getExternalTotalTime() {
-        return new TimeValue(externalTotalTimeInMillis);
-    }
-
-    /**
-     * The number of waiting refresh listeners.
-    */
-    public int getListeners() {
-        return listeners;
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject("refresh");
-        builder.field("total", total);
-        builder.humanReadableField("total_time_in_millis", "total_time", getTotalTime());
-        builder.field("external_total", externalTotal);
-        builder.humanReadableField("external_total_time_in_millis", "external_total_time", getExternalTotalTime());
-        builder.field("listeners", listeners);
-        builder.endObject();
-        return builder;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (obj == null || obj.getClass() != ProtobufRefreshStats.class) {
-            return false;
-        }
-        ProtobufRefreshStats rhs = (ProtobufRefreshStats) obj;
-        return total == rhs.total
-            && totalTimeInMillis == rhs.totalTimeInMillis
-            && externalTotal == rhs.externalTotal
-            && externalTotalTimeInMillis == rhs.externalTotalTimeInMillis
-            && listeners == rhs.listeners;
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(total, totalTimeInMillis, externalTotal, externalTotalTimeInMillis, listeners);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/index/search/stats/ProtobufSearchStats.java b/server/src/main/java/org/opensearch/index/search/stats/ProtobufSearchStats.java
deleted file mode 100644
index 756e06b717f08..0000000000000
--- a/server/src/main/java/org/opensearch/index/search/stats/ProtobufSearchStats.java
+++ /dev/null
@@ -1,444 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.index.search.stats;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.Version;
-import org.opensearch.common.Nullable;
-import org.opensearch.common.Strings;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.common.xcontent.XContentType;
-import org.opensearch.core.xcontent.ToXContent;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Encapsulates stats for search time
-*
-* @opensearch.internal
-*/
-public class ProtobufSearchStats implements ProtobufWriteable, ToXContentFragment {
-
-    /**
-     * Statistics for search
-    *
-    * @opensearch.internal
-    */
-    public static class Stats implements ProtobufWriteable, ToXContentFragment {
-
-        private long queryCount;
-        private long queryTimeInMillis;
-        private long queryCurrent;
-
-        private long fetchCount;
-        private long fetchTimeInMillis;
-        private long fetchCurrent;
-
-        private long scrollCount;
-        private long scrollTimeInMillis;
-        private long scrollCurrent;
-
-        private long suggestCount;
-        private long suggestTimeInMillis;
-        private long suggestCurrent;
-
-        private long pitCount;
-        private long pitTimeInMillis;
-        private long pitCurrent;
-
-        private Stats() {
-            // for internal use, initializes all counts to 0
-        }
-
-        public Stats(
-            long queryCount,
-            long queryTimeInMillis,
-            long queryCurrent,
-            long fetchCount,
-            long fetchTimeInMillis,
-            long fetchCurrent,
-            long scrollCount,
-            long scrollTimeInMillis,
-            long scrollCurrent,
-            long pitCount,
-            long pitTimeInMillis,
-            long pitCurrent,
-            long suggestCount,
-            long suggestTimeInMillis,
-            long suggestCurrent
-        ) {
-            this.queryCount = queryCount;
-            this.queryTimeInMillis = queryTimeInMillis;
-            this.queryCurrent = queryCurrent;
-
-            this.fetchCount = fetchCount;
-            this.fetchTimeInMillis = fetchTimeInMillis;
-            this.fetchCurrent = fetchCurrent;
-
-            this.scrollCount = scrollCount;
-            this.scrollTimeInMillis = scrollTimeInMillis;
-            this.scrollCurrent = scrollCurrent;
-
-            this.suggestCount = suggestCount;
-            this.suggestTimeInMillis = suggestTimeInMillis;
-            this.suggestCurrent = suggestCurrent;
-
-            this.pitCount = pitCount;
-            this.pitTimeInMillis = pitTimeInMillis;
-            this.pitCurrent = pitCurrent;
-        }
-
-        private Stats(CodedInputStream in) throws IOException {
-            queryCount = in.readInt64();
-            queryTimeInMillis = in.readInt64();
-            queryCurrent = in.readInt64();
-
-            fetchCount = in.readInt64();
-            fetchTimeInMillis = in.readInt64();
-            fetchCurrent = in.readInt64();
-
-            scrollCount = in.readInt64();
-            scrollTimeInMillis = in.readInt64();
-            scrollCurrent = in.readInt64();
-
-            suggestCount = in.readInt64();
-            suggestTimeInMillis = in.readInt64();
-            suggestCurrent = in.readInt64();
-
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-            if (protobufStreamInput.getVersion().onOrAfter(Version.V_2_4_0)) {
-                pitCount = in.readInt64();
-                pitTimeInMillis = in.readInt64();
-                pitCurrent = in.readInt64();
-            }
-        }
-
-        public void add(Stats stats) {
-            queryCount += stats.queryCount;
-            queryTimeInMillis += stats.queryTimeInMillis;
-            queryCurrent += stats.queryCurrent;
-
-            fetchCount += stats.fetchCount;
-            fetchTimeInMillis += stats.fetchTimeInMillis;
-            fetchCurrent += stats.fetchCurrent;
-
-            scrollCount += stats.scrollCount;
-            scrollTimeInMillis += stats.scrollTimeInMillis;
-            scrollCurrent += stats.scrollCurrent;
-
-            suggestCount += stats.suggestCount;
-            suggestTimeInMillis += stats.suggestTimeInMillis;
-            suggestCurrent += stats.suggestCurrent;
-
-            pitCount += stats.pitCount;
-            pitTimeInMillis += stats.pitTimeInMillis;
-            pitCurrent += stats.pitCurrent;
-        }
-
-        public void addForClosingShard(Stats stats) {
-            queryCount += stats.queryCount;
-            queryTimeInMillis += stats.queryTimeInMillis;
-
-            fetchCount += stats.fetchCount;
-            fetchTimeInMillis += stats.fetchTimeInMillis;
-
-            scrollCount += stats.scrollCount;
-            scrollTimeInMillis += stats.scrollTimeInMillis;
-            // need consider the count of the shard's current scroll
-            scrollCount += stats.scrollCurrent;
-
-            suggestCount += stats.suggestCount;
-            suggestTimeInMillis += stats.suggestTimeInMillis;
-
-            pitCount += stats.pitCount;
-            pitTimeInMillis += stats.pitTimeInMillis;
-            pitCurrent += stats.pitCurrent;
-        }
-
-        public long getQueryCount() {
-            return queryCount;
-        }
-
-        public TimeValue getQueryTime() {
-            return new TimeValue(queryTimeInMillis);
-        }
-
-        public long getQueryTimeInMillis() {
-            return queryTimeInMillis;
-        }
-
-        public long getQueryCurrent() {
-            return queryCurrent;
-        }
-
-        public long getFetchCount() {
-            return fetchCount;
-        }
-
-        public TimeValue getFetchTime() {
-            return new TimeValue(fetchTimeInMillis);
-        }
-
-        public long getFetchTimeInMillis() {
-            return fetchTimeInMillis;
-        }
-
-        public long getFetchCurrent() {
-            return fetchCurrent;
-        }
-
-        public long getScrollCount() {
-            return scrollCount;
-        }
-
-        public TimeValue getScrollTime() {
-            return new TimeValue(scrollTimeInMillis);
-        }
-
-        public long getScrollTimeInMillis() {
-            return scrollTimeInMillis;
-        }
-
-        public long getScrollCurrent() {
-            return scrollCurrent;
-        }
-
-        public long getPitCount() {
-            return pitCount;
-        }
-
-        public TimeValue getPitTime() {
-            return new TimeValue(pitTimeInMillis);
-        }
-
-        public long getPitTimeInMillis() {
-            return pitTimeInMillis;
-        }
-
-        public long getPitCurrent() {
-            return pitCurrent;
-        }
-
-        public long getSuggestCount() {
-            return suggestCount;
-        }
-
-        public long getSuggestTimeInMillis() {
-            return suggestTimeInMillis;
-        }
-
-        public TimeValue getSuggestTime() {
-            return new TimeValue(suggestTimeInMillis);
-        }
-
-        public long getSuggestCurrent() {
-            return suggestCurrent;
-        }
-
-        public static Stats readStats(CodedInputStream in) throws IOException {
-            return new Stats(in);
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeInt64NoTag(queryCount);
-            out.writeInt64NoTag(queryTimeInMillis);
-            out.writeInt64NoTag(queryCurrent);
-
-            out.writeInt64NoTag(fetchCount);
-            out.writeInt64NoTag(fetchTimeInMillis);
-            out.writeInt64NoTag(fetchCurrent);
-
-            out.writeInt64NoTag(scrollCount);
-            out.writeInt64NoTag(scrollTimeInMillis);
-            out.writeInt64NoTag(scrollCurrent);
-
-            out.writeInt64NoTag(suggestCount);
-            out.writeInt64NoTag(suggestTimeInMillis);
-            out.writeInt64NoTag(suggestCurrent);
-
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            if (protobufStreamOutput.getVersion().onOrAfter(Version.V_2_4_0)) {
-                out.writeInt64NoTag(pitCount);
-                out.writeInt64NoTag(pitTimeInMillis);
-                out.writeInt64NoTag(pitCurrent);
-            }
-        }
-
-        @Override
-        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-            builder.field(Fields.QUERY_TOTAL, queryCount);
-            builder.humanReadableField(Fields.QUERY_TIME_IN_MILLIS, Fields.QUERY_TIME, getQueryTime());
-            builder.field(Fields.QUERY_CURRENT, queryCurrent);
-
-            builder.field(Fields.FETCH_TOTAL, fetchCount);
-            builder.humanReadableField(Fields.FETCH_TIME_IN_MILLIS, Fields.FETCH_TIME, getFetchTime());
-            builder.field(Fields.FETCH_CURRENT, fetchCurrent);
-
-            builder.field(Fields.SCROLL_TOTAL, scrollCount);
-            builder.humanReadableField(Fields.SCROLL_TIME_IN_MILLIS, Fields.SCROLL_TIME, getScrollTime());
-            builder.field(Fields.SCROLL_CURRENT, scrollCurrent);
-
-            builder.field(Fields.PIT_TOTAL, pitCount);
-            builder.humanReadableField(Fields.PIT_TIME_IN_MILLIS, Fields.PIT_TIME, getPitTime());
-            builder.field(Fields.PIT_CURRENT, pitCurrent);
-
-            builder.field(Fields.SUGGEST_TOTAL, suggestCount);
-            builder.humanReadableField(Fields.SUGGEST_TIME_IN_MILLIS, Fields.SUGGEST_TIME, getSuggestTime());
-            builder.field(Fields.SUGGEST_CURRENT, suggestCurrent);
-
-            return builder;
-        }
-    }
-
-    private final Stats totalStats;
-    private long openContexts;
-
-    @Nullable
-    private Map<String, Stats> groupStats;
-
-    public ProtobufSearchStats() {
-        totalStats = new Stats();
-    }
-
-    public ProtobufSearchStats(Stats totalStats, long openContexts, @Nullable Map<String, Stats> groupStats) {
-        this.totalStats = totalStats;
-        this.openContexts = openContexts;
-        this.groupStats = groupStats;
-    }
-
-    public ProtobufSearchStats(CodedInputStream in) throws IOException {
-        totalStats = Stats.readStats(in);
-        openContexts = in.readInt64();
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        if (protobufStreamInput.readBoolean()) {
-            groupStats = protobufStreamInput.readMap(CodedInputStream::readString, Stats::readStats);
-        }
-    }
-
-    public void add(ProtobufSearchStats searchStats) {
-        if (searchStats == null) {
-            return;
-        }
-        addTotals(searchStats);
-        openContexts += searchStats.openContexts;
-        if (searchStats.groupStats != null && !searchStats.groupStats.isEmpty()) {
-            if (groupStats == null) {
-                groupStats = new HashMap<>(searchStats.groupStats.size());
-            }
-            for (Map.Entry<String, Stats> entry : searchStats.groupStats.entrySet()) {
-                groupStats.putIfAbsent(entry.getKey(), new Stats());
-                groupStats.get(entry.getKey()).add(entry.getValue());
-            }
-        }
-    }
-
-    public void addTotals(ProtobufSearchStats searchStats) {
-        if (searchStats == null) {
-            return;
-        }
-        totalStats.add(searchStats.totalStats);
-    }
-
-    public void addTotalsForClosingShard(ProtobufSearchStats searchStats) {
-        if (searchStats == null) {
-            return;
-        }
-        totalStats.addForClosingShard(searchStats.totalStats);
-    }
-
-    public Stats getTotal() {
-        return this.totalStats;
-    }
-
-    public long getOpenContexts() {
-        return this.openContexts;
-    }
-
-    @Nullable
-    public Map<String, Stats> getGroupStats() {
-        return this.groupStats != null ? Collections.unmodifiableMap(this.groupStats) : null;
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params params) throws IOException {
-        builder.startObject(Fields.SEARCH);
-        builder.field(Fields.OPEN_CONTEXTS, openContexts);
-        totalStats.toXContent(builder, params);
-        if (groupStats != null && !groupStats.isEmpty()) {
-            builder.startObject(Fields.GROUPS);
-            for (Map.Entry<String, Stats> entry : groupStats.entrySet()) {
-                builder.startObject(entry.getKey());
-                entry.getValue().toXContent(builder, params);
-                builder.endObject();
-            }
-            builder.endObject();
-        }
-        builder.endObject();
-        return builder;
-    }
-
-    @Override
-    public String toString() {
-        return Strings.toString(XContentType.JSON, this, true, true);
-    }
-
-    /**
-     * Fields for search statistics
-    *
-    * @opensearch.internal
-    */
-    static final class Fields {
-        static final String SEARCH = "search";
-        static final String OPEN_CONTEXTS = "open_contexts";
-        static final String GROUPS = "groups";
-        static final String QUERY_TOTAL = "query_total";
-        static final String QUERY_TIME = "query_time";
-        static final String QUERY_TIME_IN_MILLIS = "query_time_in_millis";
-        static final String QUERY_CURRENT = "query_current";
-        static final String FETCH_TOTAL = "fetch_total";
-        static final String FETCH_TIME = "fetch_time";
-        static final String FETCH_TIME_IN_MILLIS = "fetch_time_in_millis";
-        static final String FETCH_CURRENT = "fetch_current";
-        static final String SCROLL_TOTAL = "scroll_total";
-        static final String SCROLL_TIME = "scroll_time";
-        static final String SCROLL_TIME_IN_MILLIS = "scroll_time_in_millis";
-        static final String SCROLL_CURRENT = "scroll_current";
-        static final String PIT_TOTAL = "point_in_time_total";
-        static final String PIT_TIME = "point_in_time_time";
-        static final String PIT_TIME_IN_MILLIS = "point_in_time_time_in_millis";
-        static final String PIT_CURRENT = "point_in_time_current";
-        static final String SUGGEST_TOTAL = "suggest_total";
-        static final String SUGGEST_TIME = "suggest_time";
-        static final String SUGGEST_TIME_IN_MILLIS = "suggest_time_in_millis";
-        static final String SUGGEST_CURRENT = "suggest_current";
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        totalStats.writeTo(out);
-        out.writeInt64NoTag(openContexts);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        if (groupStats == null || groupStats.isEmpty()) {
-            out.writeBoolNoTag(false);
-        } else {
-            out.writeBoolNoTag(true);
-            protobufStreamOutput.writeMap(groupStats, CodedOutputStream::writeStringNoTag, (stream, stats) -> stats.writeTo(stream));
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/index/search/stats/ShardSearchStats.java b/server/src/main/java/org/opensearch/index/search/stats/ShardSearchStats.java
index a1a96a367e4f2..6d0eb3a5949ca 100644
--- a/server/src/main/java/org/opensearch/index/search/stats/ShardSearchStats.java
+++ b/server/src/main/java/org/opensearch/index/search/stats/ShardSearchStats.java
@@ -84,31 +84,6 @@ public SearchStats stats(String... groups) {
         return new SearchStats(total, openContexts.count(), groupsSt);
     }
 
-    /**
-     * Returns the stats, including group specific stats. If the groups are null/0 length, then nothing
-     * is returned for them. If they are set, then only groups provided will be returned, or
-     * {@code _all} for all groups.
-     */
-    public ProtobufSearchStats protobufStats(String... groups) {
-        ProtobufSearchStats.Stats total = totalStats.protobufStats();
-        Map<String, ProtobufSearchStats.Stats> groupsSt = null;
-        if (CollectionUtils.isEmpty(groups) == false) {
-            groupsSt = new HashMap<>(groupsStats.size());
-            if (groups.length == 1 && groups[0].equals("_all")) {
-                for (Map.Entry<String, StatsHolder> entry : groupsStats.entrySet()) {
-                    groupsSt.put(entry.getKey(), entry.getValue().protobufStats());
-                }
-            } else {
-                for (Map.Entry<String, StatsHolder> entry : groupsStats.entrySet()) {
-                    if (Regex.simpleMatch(groups, entry.getKey())) {
-                        groupsSt.put(entry.getKey(), entry.getValue().protobufStats());
-                    }
-                }
-            }
-        }
-        return new ProtobufSearchStats(total, openContexts.count(), groupsSt);
-    }
-
     @Override
     public void onPreQueryPhase(SearchContext searchContext) {
         computeStats(searchContext, statsHolder -> {
@@ -267,25 +242,5 @@ SearchStats.Stats stats() {
                 suggestCurrent.count()
             );
         }
-
-        ProtobufSearchStats.Stats protobufStats() {
-            return new ProtobufSearchStats.Stats(
-                queryMetric.count(),
-                TimeUnit.NANOSECONDS.toMillis(queryMetric.sum()),
-                queryCurrent.count(),
-                fetchMetric.count(),
-                TimeUnit.NANOSECONDS.toMillis(fetchMetric.sum()),
-                fetchCurrent.count(),
-                scrollMetric.count(),
-                TimeUnit.MICROSECONDS.toMillis(scrollMetric.sum()),
-                scrollCurrent.count(),
-                pitMetric.count(),
-                TimeUnit.MICROSECONDS.toMillis(pitMetric.sum()),
-                pitCurrent.count(),
-                suggestMetric.count(),
-                TimeUnit.NANOSECONDS.toMillis(suggestMetric.sum()),
-                suggestCurrent.count()
-            );
-        }
     }
 }
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java
index 27e4aa2285e6e..dbc99b263bb56 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java
@@ -42,9 +42,6 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import org.opensearch.core.xcontent.XContent;
 
 import java.io.IOException;
@@ -58,7 +55,7 @@
  *
  * @opensearch.internal
  */
-public final class RetentionLease implements ToXContentObject, Writeable, ProtobufWriteable {
+public final class RetentionLease implements ToXContentObject, Writeable {
 
     private final String id;
 
@@ -161,33 +158,6 @@ public void writeTo(final StreamOutput out) throws IOException {
         out.writeString(source);
     }
 
-    /**
-     * Constructs a new retention lease from a stream. The retention lease should have been written.
-     *
-     * @param in the stream to construct the retention lease from
-     * @throws IOException if an I/O exception occurs reading from the stream
-     */
-    public RetentionLease(final CodedInputStream in) throws IOException {
-        id = in.readString();
-        retainingSequenceNumber = in.readInt64();
-        timestamp = in.readInt64();
-        source = in.readString();
-    }
-
-    /**
-     * Writes a retention lease to a stream in a manner suitable for later reconstruction.
-     *
-     * @param out the stream to write the retention lease to
-     * @throws IOException if an I/O exception occurs writing to the stream
-     */
-    @Override
-    public void writeTo(final CodedOutputStream out) throws IOException {
-        out.writeStringNoTag(id);
-        out.writeInt64NoTag(retainingSequenceNumber);
-        out.writeInt64NoTag(timestamp);
-        out.writeStringNoTag(source);
-    }
-
     private static final ParseField ID_FIELD = new ParseField("id");
     private static final ParseField RETAINING_SEQUENCE_NUMBER_FIELD = new ParseField("retaining_sequence_number");
     private static final ParseField TIMESTAMP_FIELD = new ParseField("timestamp");
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java
index e578155f75cd8..bb861caa3f62c 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java
@@ -60,7 +60,6 @@
 import org.opensearch.tasks.Task;
 import org.opensearch.tasks.TaskId;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
@@ -171,18 +170,6 @@ public void handleException(TransportException e) {
                         getLogger().warn(new ParameterizedMessage("{} retention lease background sync failed", shardId), e);
                     }
 
-                    @Override
-                    public ReplicationResponse read(CodedInputStream in) throws IOException {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'read'");
-                    }
-
-                    @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                    }
-
                     @Override
                     public ReplicationResponse read(byte[] in) throws IOException {
                         // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java
index 845900a86d31d..28963f10db64b 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java
@@ -39,9 +39,6 @@
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import org.opensearch.core.xcontent.XContent;
 
 import java.io.IOException;
@@ -52,7 +49,7 @@
  *
  * @opensearch.internal
  */
-public final class RetentionLeaseStats implements ToXContentFragment, Writeable, ProtobufWriteable {
+public final class RetentionLeaseStats implements ToXContentFragment, Writeable {
 
     private final RetentionLeases retentionLeases;
 
@@ -97,27 +94,6 @@ public void writeTo(final StreamOutput out) throws IOException {
         retentionLeases.writeTo(out);
     }
 
-    /**
-     * Constructs a new retention lease stats object from a stream. The retention lease stats should have been written.
-     *
-     * @param in the stream to construct the retention lease stats from
-     * @throws IOException if an I/O exception occurs reading from the stream
-     */
-    public RetentionLeaseStats(final CodedInputStream in) throws IOException {
-        retentionLeases = new RetentionLeases(in);
-    }
-
-    /**
-     * Writes a retention lease stats object to a stream in a manner suitable for later reconstruction.
-     *
-     * @param out the stream to write the retention lease stats to
-     * @throws IOException if an I/O exception occurs writing to the stream
-     */
-    @Override
-    public void writeTo(final CodedOutputStream out) throws IOException {
-        retentionLeases.writeTo(out);
-    }
-
     /**
      * Converts the retention lease stats to {@link XContent} using the specified builder and pararms.
      *
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java
index 4f877998d7634..0f89a1dfff1b7 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java
@@ -63,7 +63,6 @@
 import org.opensearch.tasks.Task;
 import org.opensearch.tasks.TaskId;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
@@ -179,18 +178,6 @@ public void handleException(TransportException e) {
                         listener.onFailure(e);
                     }
 
-                    @Override
-                    public ReplicationResponse read(CodedInputStream in) throws IOException {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'read'");
-                    }
-
-                    @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                    }
-
                     @Override
                     public ReplicationResponse read(byte[] in) throws IOException {
                         // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeases.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeases.java
index 753ab4eb81d2d..a764ca3e7a581 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeases.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeases.java
@@ -33,9 +33,6 @@
 package org.opensearch.index.seqno;
 
 import org.opensearch.core.ParseField;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
@@ -47,9 +44,6 @@
 import org.opensearch.core.xcontent.XContent;
 import org.opensearch.gateway.MetadataStateFormat;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.util.Collection;
 import java.util.Collections;
@@ -65,7 +59,7 @@
  *
  * @opensearch.internal
  */
-public class RetentionLeases implements ToXContentFragment, Writeable, ProtobufWriteable {
+public class RetentionLeases implements ToXContentFragment, Writeable {
 
     private final long primaryTerm;
 
@@ -199,33 +193,6 @@ public void writeTo(final StreamOutput out) throws IOException {
         out.writeCollection(leases.values());
     }
 
-    /**
-     * Constructs a new retention lease collection from a stream. The retention lease collection should have been written.
-     *
-     * @param in the stream to construct the retention lease collection from
-     * @throws IOException if an I/O exception occurs reading from the stream
-     */
-    public RetentionLeases(final CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        primaryTerm = in.readInt64();
-        version = in.readInt64();
-        leases = Collections.unmodifiableMap(toMap(protobufStreamInput.readList(RetentionLease::new)));
-    }
-
-    /**
-     * Writes a retention lease collection to a stream in a manner suitable for later reconstruction.
-     *
-     * @param out the stream to write the retention lease collection to
-     * @throws IOException if an I/O exception occurs writing to the stream
-     */
-    @Override
-    public void writeTo(final CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeInt64NoTag(primaryTerm);
-        out.writeInt64NoTag(version);
-        protobufStreamOutput.writeCollection(leases.values(), (o, v) -> v.writeTo(o));
-    }
-
     private static final ParseField PRIMARY_TERM_FIELD = new ParseField("primary_term");
     private static final ParseField VERSION_FIELD = new ParseField("version");
     private static final ParseField LEASES_FIELD = new ParseField("leases");
diff --git a/server/src/main/java/org/opensearch/index/seqno/SeqNoStats.java b/server/src/main/java/org/opensearch/index/seqno/SeqNoStats.java
index 01a05263851e7..be7888ada2801 100644
--- a/server/src/main/java/org/opensearch/index/seqno/SeqNoStats.java
+++ b/server/src/main/java/org/opensearch/index/seqno/SeqNoStats.java
@@ -32,16 +32,12 @@
 
 package org.opensearch.index.seqno;
 
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.util.Objects;
 
@@ -50,7 +46,7 @@
  *
  * @opensearch.internal
  */
-public class SeqNoStats implements ToXContentFragment, Writeable, ProtobufWriteable {
+public class SeqNoStats implements ToXContentFragment, Writeable {
 
     private static final String SEQ_NO = "seq_no";
     private static final String MAX_SEQ_NO = "max_seq_no";
@@ -74,10 +70,6 @@ public SeqNoStats(StreamInput in) throws IOException {
         this(in.readZLong(), in.readZLong(), in.readZLong());
     }
 
-    public SeqNoStats(CodedInputStream in) throws IOException {
-        this(in.readInt64(), in.readInt64(), in.readInt64());
-    }
-
     /** the maximum sequence number seen so far */
     public long getMaxSeqNo() {
         return maxSeqNo;
@@ -99,13 +91,6 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeZLong(globalCheckpoint);
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(maxSeqNo);
-        out.writeInt64NoTag(localCheckpoint);
-        out.writeInt64NoTag(globalCheckpoint);
-    }
-
     @Override
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
         builder.startObject(SEQ_NO);
diff --git a/server/src/main/java/org/opensearch/index/shard/IndexShard.java b/server/src/main/java/org/opensearch/index/shard/IndexShard.java
index 316f6c37d1cd3..2b85193275a13 100644
--- a/server/src/main/java/org/opensearch/index/shard/IndexShard.java
+++ b/server/src/main/java/org/opensearch/index/shard/IndexShard.java
@@ -123,19 +123,15 @@
 import org.opensearch.index.engine.EngineException;
 import org.opensearch.index.engine.EngineFactory;
 import org.opensearch.index.engine.NRTReplicationEngine;
-import org.opensearch.index.engine.ProtobufSegmentsStats;
 import org.opensearch.index.engine.ReadOnlyEngine;
 import org.opensearch.index.engine.RefreshFailedEngineException;
 import org.opensearch.index.engine.SafeCommitInfo;
 import org.opensearch.index.engine.Segment;
 import org.opensearch.index.engine.SegmentsStats;
 import org.opensearch.index.fielddata.FieldDataStats;
-import org.opensearch.index.fielddata.ProtobufFieldDataStats;
 import org.opensearch.index.fielddata.ShardFieldData;
 import org.opensearch.index.flush.FlushStats;
-import org.opensearch.index.flush.ProtobufFlushStats;
 import org.opensearch.index.get.GetStats;
-import org.opensearch.index.get.ProtobufGetStats;
 import org.opensearch.index.get.ShardGetService;
 import org.opensearch.index.mapper.DocumentMapper;
 import org.opensearch.index.mapper.DocumentMapperForType;
@@ -147,12 +143,8 @@
 import org.opensearch.index.mapper.SourceToParse;
 import org.opensearch.index.mapper.Uid;
 import org.opensearch.index.merge.MergeStats;
-import org.opensearch.index.merge.ProtobufMergeStats;
-import org.opensearch.index.recovery.ProtobufRecoveryStats;
 import org.opensearch.index.recovery.RecoveryStats;
-import org.opensearch.index.refresh.ProtobufRefreshStats;
 import org.opensearch.index.refresh.RefreshStats;
-import org.opensearch.index.search.stats.ProtobufSearchStats;
 import org.opensearch.index.remote.RemoteRefreshSegmentPressureService;
 import org.opensearch.index.search.stats.SearchStats;
 import org.opensearch.index.search.stats.ShardSearchStats;
@@ -165,7 +157,6 @@
 import org.opensearch.index.seqno.SequenceNumbers;
 import org.opensearch.index.shard.PrimaryReplicaSyncer.ResyncTask;
 import org.opensearch.index.similarity.SimilarityService;
-import org.opensearch.index.store.ProtobufStoreStats;
 import org.opensearch.index.store.RemoteSegmentStoreDirectory;
 import org.opensearch.index.store.Store;
 import org.opensearch.index.store.Store.MetadataSnapshot;
@@ -179,7 +170,6 @@
 import org.opensearch.index.translog.TranslogFactory;
 import org.opensearch.index.translog.TranslogRecoveryRunner;
 import org.opensearch.index.translog.TranslogStats;
-import org.opensearch.index.warmer.ProtobufWarmerStats;
 import org.opensearch.index.warmer.ShardIndexWarmerService;
 import org.opensearch.index.warmer.WarmerStats;
 import org.opensearch.indices.IndexingMemoryController;
@@ -300,7 +290,6 @@ Runnable getGlobalCheckpointSyncer() {
     private volatile RecoveryState recoveryState;
 
     private final RecoveryStats recoveryStats = new RecoveryStats();
-    private final ProtobufRecoveryStats protobufRecoveryStats = new ProtobufRecoveryStats();
     private final MeanMetric refreshMetric = new MeanMetric();
     private final MeanMetric externalRefreshMetric = new MeanMetric();
     private final MeanMetric flushMetric = new MeanMetric();
@@ -1303,35 +1292,15 @@ public RefreshStats refreshStats() {
         );
     }
 
-    public ProtobufRefreshStats protobufRefreshStats() {
-        int listeners = refreshListeners.pendingCount();
-        return new ProtobufRefreshStats(
-            refreshMetric.count(),
-            TimeUnit.NANOSECONDS.toMillis(refreshMetric.sum()),
-            externalRefreshMetric.count(),
-            TimeUnit.NANOSECONDS.toMillis(externalRefreshMetric.sum()),
-            listeners
-        );
-    }
-
     public FlushStats flushStats() {
         return new FlushStats(flushMetric.count(), periodicFlushMetric.count(), TimeUnit.NANOSECONDS.toMillis(flushMetric.sum()));
     }
 
-    public ProtobufFlushStats protobufFlushStats() {
-        return new ProtobufFlushStats(flushMetric.count(), periodicFlushMetric.count(), TimeUnit.NANOSECONDS.toMillis(flushMetric.sum()));
-    }
-
     public DocsStats docStats() {
         readAllowed();
         return getEngine().docStats();
     }
 
-    public ProtobufDocsStats protobufDocsStats() {
-        readAllowed();
-        return getEngine().protobufDocsStats();
-    }
-
     /**
      * @return {@link CommitStats}
      * @throws AlreadyClosedException if shard is closed
@@ -1362,36 +1331,14 @@ public IndexingStats indexingStats() {
         return internalIndexingStats.stats(throttled, throttleTimeInMillis);
     }
 
-    public ProtobufIndexingStats protobufIndexingStats() {
-        Engine engine = getEngineOrNull();
-        final boolean throttled;
-        final long throttleTimeInMillis;
-        if (engine == null) {
-            throttled = false;
-            throttleTimeInMillis = 0;
-        } else {
-            throttled = engine.isThrottled();
-            throttleTimeInMillis = engine.getIndexThrottleTimeInMillis();
-        }
-        return internalIndexingStats.protobufStats(throttled, throttleTimeInMillis);
-    }
-
     public SearchStats searchStats(String... groups) {
         return searchStats.stats(groups);
     }
 
-    public ProtobufSearchStats protobufSearchStats(String... groups) {
-        return searchStats.protobufStats(groups);
-    }
-
     public GetStats getStats() {
         return getService.stats();
     }
 
-    public ProtobufGetStats getProtobufStats() {
-        return getService.protobufStats();
-    }
-
     public StoreStats storeStats() {
         try {
             final RecoveryState recoveryState = this.recoveryState;
@@ -1403,17 +1350,6 @@ public StoreStats storeStats() {
         }
     }
 
-    public ProtobufStoreStats protobufStoreStats() {
-        try {
-            final RecoveryState recoveryState = this.recoveryState;
-            final long bytesStillToRecover = recoveryState == null ? -1L : recoveryState.getIndex().bytesStillToRecover();
-            return store.protobufStats(bytesStillToRecover == -1 ? StoreStats.UNKNOWN_RESERVED_BYTES : bytesStillToRecover);
-        } catch (IOException e) {
-            failShard("Failing shard because of exception during storeStats", e);
-            throw new OpenSearchException("io exception while building 'store stats'", e);
-        }
-    }
-
     public MergeStats mergeStats() {
         final Engine engine = getEngineOrNull();
         if (engine == null) {
@@ -1422,42 +1358,20 @@ public MergeStats mergeStats() {
         return engine.getMergeStats();
     }
 
-    public ProtobufMergeStats protobufMergeStats() {
-        final Engine engine = getEngineOrNull();
-        if (engine == null) {
-            return new ProtobufMergeStats();
-        }
-        return engine.getProtobufMergeStats();
-    }
-
     public SegmentsStats segmentStats(boolean includeSegmentFileSizes, boolean includeUnloadedSegments) {
         SegmentsStats segmentsStats = getEngine().segmentsStats(includeSegmentFileSizes, includeUnloadedSegments);
         segmentsStats.addBitsetMemoryInBytes(shardBitsetFilterCache.getMemorySizeInBytes());
         return segmentsStats;
     }
 
-    public ProtobufSegmentsStats protobufSegmentStats(boolean includeSegmentFileSizes, boolean includeUnloadedSegments) {
-        ProtobufSegmentsStats segmentsStats = getEngine().protobufSegmentsStats(includeSegmentFileSizes, includeUnloadedSegments);
-        segmentsStats.addBitsetMemoryInBytes(shardBitsetFilterCache.getMemorySizeInBytes());
-        return segmentsStats;
-    }
-
     public WarmerStats warmerStats() {
         return shardWarmerService.stats();
     }
 
-    public ProtobufWarmerStats protobufWarmerStats() {
-        return shardWarmerService.protobufStats();
-    }
-
     public FieldDataStats fieldDataStats(String... fields) {
         return shardFieldData.stats(fields);
     }
 
-    public ProtobufFieldDataStats protobufFieldDataStats(String... fields) {
-        return shardFieldData.protobufStats(fields);
-    }
-
     public TranslogStats translogStats() {
         return getEngine().translogManager().getTranslogStats();
     }
@@ -2499,13 +2413,6 @@ public RecoveryStats recoveryStats() {
         return recoveryStats;
     }
 
-    /**
-     * returns stats about ongoing recoveries, both source and target
-     */
-    public ProtobufRecoveryStats protobufRecoveryStats() {
-        return protobufRecoveryStats;
-    }
-
     /**
      * Returns the current {@link RecoveryState} if this shard is recovering or has been recovering.
      * Returns null if the recovery has not yet started or shard was not recovered (created via an API).
diff --git a/server/src/main/java/org/opensearch/index/shard/InternalIndexingStats.java b/server/src/main/java/org/opensearch/index/shard/InternalIndexingStats.java
index 19beb43ee5111..d7e15dd3e40f5 100644
--- a/server/src/main/java/org/opensearch/index/shard/InternalIndexingStats.java
+++ b/server/src/main/java/org/opensearch/index/shard/InternalIndexingStats.java
@@ -58,16 +58,6 @@ IndexingStats stats(boolean isThrottled, long currentThrottleInMillis) {
         return new IndexingStats(total);
     }
 
-    /**
-     * Returns the stats, including type specific stats. If the types are null/0 length, then nothing
-     * is returned for them. If they are set, then only types provided will be returned, or
-     * {@code _all} for all types.
-     */
-    ProtobufIndexingStats protobufStats(boolean isThrottled, long currentThrottleInMillis) {
-        ProtobufIndexingStats.Stats total = totalStats.protobufStats(isThrottled, currentThrottleInMillis);
-        return new ProtobufIndexingStats(total);
-    }
-
     @Override
     public Engine.Index preIndex(ShardId shardId, Engine.Index operation) {
         if (operation.origin().isRecovery() == false) {
@@ -167,20 +157,5 @@ IndexingStats.Stats stats(boolean isThrottled, long currentThrottleMillis) {
                 TimeUnit.MILLISECONDS.toMillis(currentThrottleMillis)
             );
         }
-
-        ProtobufIndexingStats.Stats protobufStats(boolean isThrottled, long currentThrottleMillis) {
-            return new ProtobufIndexingStats.Stats(
-                indexMetric.count(),
-                TimeUnit.NANOSECONDS.toMillis(indexMetric.sum()),
-                indexCurrent.count(),
-                indexFailed.count(),
-                deleteMetric.count(),
-                TimeUnit.NANOSECONDS.toMillis(deleteMetric.sum()),
-                deleteCurrent.count(),
-                noopUpdates.count(),
-                isThrottled,
-                TimeUnit.MILLISECONDS.toMillis(currentThrottleMillis)
-            );
-        }
     }
 }
diff --git a/server/src/main/java/org/opensearch/index/shard/ProtobufDocsStats.java b/server/src/main/java/org/opensearch/index/shard/ProtobufDocsStats.java
deleted file mode 100644
index 2ecfa368dec0f..0000000000000
--- a/server/src/main/java/org/opensearch/index/shard/ProtobufDocsStats.java
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.index.shard;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.index.store.StoreStats;
-
-import java.io.IOException;
-
-/**
- * Document statistics
-*
-* @opensearch.internal
-*/
-public class ProtobufDocsStats implements ProtobufWriteable, ToXContentFragment {
-
-    private long count = 0;
-    private long deleted = 0;
-    private long totalSizeInBytes = 0;
-
-    public ProtobufDocsStats() {
-
-    }
-
-    public ProtobufDocsStats(CodedInputStream in) throws IOException {
-        count = in.readInt64();
-        deleted = in.readInt64();
-        totalSizeInBytes = in.readInt64();
-    }
-
-    public ProtobufDocsStats(long count, long deleted, long totalSizeInBytes) {
-        this.count = count;
-        this.deleted = deleted;
-        this.totalSizeInBytes = totalSizeInBytes;
-    }
-
-    public void add(ProtobufDocsStats other) {
-        if (other == null) {
-            return;
-        }
-        if (this.totalSizeInBytes == -1) {
-            this.totalSizeInBytes = other.totalSizeInBytes;
-        } else if (other.totalSizeInBytes != -1) {
-            this.totalSizeInBytes += other.totalSizeInBytes;
-        }
-        this.count += other.count;
-        this.deleted += other.deleted;
-    }
-
-    public long getCount() {
-        return this.count;
-    }
-
-    public long getDeleted() {
-        return this.deleted;
-    }
-
-    /**
-     * Returns the total size in bytes of all documents in this stats.
-    * This value may be more reliable than {@link StoreStats#getSizeInBytes()} in estimating the index size.
-    */
-    public long getTotalSizeInBytes() {
-        return totalSizeInBytes;
-    }
-
-    /**
-     * Returns the average size in bytes of all documents in this stats.
-    */
-    public long getAverageSizeInBytes() {
-        long totalDocs = count + deleted;
-        return totalDocs == 0 ? 0 : totalSizeInBytes / totalDocs;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(count);
-        out.writeInt64NoTag(deleted);
-        out.writeInt64NoTag(totalSizeInBytes);
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.DOCS);
-        builder.field(Fields.COUNT, count);
-        builder.field(Fields.DELETED, deleted);
-        builder.endObject();
-        return builder;
-    }
-
-    /**
-     * Fields for document statistics
-    *
-    * @opensearch.internal
-    */
-    static final class Fields {
-        static final String DOCS = "docs";
-        static final String COUNT = "count";
-        static final String DELETED = "deleted";
-    }
-}
diff --git a/server/src/main/java/org/opensearch/index/shard/ProtobufIndexingStats.java b/server/src/main/java/org/opensearch/index/shard/ProtobufIndexingStats.java
deleted file mode 100644
index 04e851da6307e..0000000000000
--- a/server/src/main/java/org/opensearch/index/shard/ProtobufIndexingStats.java
+++ /dev/null
@@ -1,286 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.index.shard;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.Version;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.core.xcontent.ToXContent;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.index.mapper.MapperService;
-
-import java.io.IOException;
-import java.util.Map;
-
-/**
- * Tracks indexing statistics
-*
-* @opensearch.internal
-*/
-public class ProtobufIndexingStats implements ProtobufWriteable, ToXContentFragment {
-
-    /**
-     * Internal statistics for indexing
-    *
-    * @opensearch.internal
-    */
-    public static class Stats implements ProtobufWriteable, ToXContentFragment {
-
-        private long indexCount;
-        private long indexTimeInMillis;
-        private long indexCurrent;
-        private long indexFailedCount;
-        private long deleteCount;
-        private long deleteTimeInMillis;
-        private long deleteCurrent;
-        private long noopUpdateCount;
-        private long throttleTimeInMillis;
-        private boolean isThrottled;
-
-        Stats() {}
-
-        public Stats(CodedInputStream in) throws IOException {
-            indexCount = in.readInt64();
-            indexTimeInMillis = in.readInt64();
-            indexCurrent = in.readInt64();
-            indexFailedCount = in.readInt64();
-            deleteCount = in.readInt64();
-            deleteTimeInMillis = in.readInt64();
-            deleteCurrent = in.readInt64();
-            noopUpdateCount = in.readInt64();
-            isThrottled = in.readBool();
-            throttleTimeInMillis = in.readInt64();
-        }
-
-        public Stats(
-            long indexCount,
-            long indexTimeInMillis,
-            long indexCurrent,
-            long indexFailedCount,
-            long deleteCount,
-            long deleteTimeInMillis,
-            long deleteCurrent,
-            long noopUpdateCount,
-            boolean isThrottled,
-            long throttleTimeInMillis
-        ) {
-            this.indexCount = indexCount;
-            this.indexTimeInMillis = indexTimeInMillis;
-            this.indexCurrent = indexCurrent;
-            this.indexFailedCount = indexFailedCount;
-            this.deleteCount = deleteCount;
-            this.deleteTimeInMillis = deleteTimeInMillis;
-            this.deleteCurrent = deleteCurrent;
-            this.noopUpdateCount = noopUpdateCount;
-            this.isThrottled = isThrottled;
-            this.throttleTimeInMillis = throttleTimeInMillis;
-        }
-
-        public void add(Stats stats) {
-            indexCount += stats.indexCount;
-            indexTimeInMillis += stats.indexTimeInMillis;
-            indexCurrent += stats.indexCurrent;
-            indexFailedCount += stats.indexFailedCount;
-
-            deleteCount += stats.deleteCount;
-            deleteTimeInMillis += stats.deleteTimeInMillis;
-            deleteCurrent += stats.deleteCurrent;
-
-            noopUpdateCount += stats.noopUpdateCount;
-            throttleTimeInMillis += stats.throttleTimeInMillis;
-            if (isThrottled != stats.isThrottled) {
-                isThrottled = true; // When combining if one is throttled set result to throttled.
-            }
-        }
-
-        /**
-         * The total number of indexing operations
-        */
-        public long getIndexCount() {
-            return indexCount;
-        }
-
-        /**
-         * The number of failed indexing operations
-        */
-        public long getIndexFailedCount() {
-            return indexFailedCount;
-        }
-
-        /**
-         * The total amount of time spend on executing index operations.
-        */
-        public TimeValue getIndexTime() {
-            return new TimeValue(indexTimeInMillis);
-        }
-
-        /**
-         * Returns the currently in-flight indexing operations.
-        */
-        public long getIndexCurrent() {
-            return indexCurrent;
-        }
-
-        /**
-         * Returns the number of delete operation executed
-        */
-        public long getDeleteCount() {
-            return deleteCount;
-        }
-
-        /**
-         * Returns if the index is under merge throttling control
-        */
-        public boolean isThrottled() {
-            return isThrottled;
-        }
-
-        /**
-         * Gets the amount of time in a TimeValue that the index has been under merge throttling control
-        */
-        public TimeValue getThrottleTime() {
-            return new TimeValue(throttleTimeInMillis);
-        }
-
-        /**
-         * The total amount of time spend on executing delete operations.
-        */
-        public TimeValue getDeleteTime() {
-            return new TimeValue(deleteTimeInMillis);
-        }
-
-        /**
-         * Returns the currently in-flight delete operations
-        */
-        public long getDeleteCurrent() {
-            return deleteCurrent;
-        }
-
-        public long getNoopUpdateCount() {
-            return noopUpdateCount;
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeInt64NoTag(indexCount);
-            out.writeInt64NoTag(indexTimeInMillis);
-            out.writeInt64NoTag(indexCurrent);
-            out.writeInt64NoTag(indexFailedCount);
-            out.writeInt64NoTag(deleteCount);
-            out.writeInt64NoTag(deleteTimeInMillis);
-            out.writeInt64NoTag(deleteCurrent);
-            out.writeInt64NoTag(noopUpdateCount);
-            out.writeBoolNoTag(isThrottled);
-            out.writeInt64NoTag(throttleTimeInMillis);
-
-        }
-
-        @Override
-        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-            builder.field(Fields.INDEX_TOTAL, indexCount);
-            builder.humanReadableField(Fields.INDEX_TIME_IN_MILLIS, Fields.INDEX_TIME, getIndexTime());
-            builder.field(Fields.INDEX_CURRENT, indexCurrent);
-            builder.field(Fields.INDEX_FAILED, indexFailedCount);
-
-            builder.field(Fields.DELETE_TOTAL, deleteCount);
-            builder.humanReadableField(Fields.DELETE_TIME_IN_MILLIS, Fields.DELETE_TIME, getDeleteTime());
-            builder.field(Fields.DELETE_CURRENT, deleteCurrent);
-
-            builder.field(Fields.NOOP_UPDATE_TOTAL, noopUpdateCount);
-
-            builder.field(Fields.IS_THROTTLED, isThrottled);
-            builder.humanReadableField(Fields.THROTTLED_TIME_IN_MILLIS, Fields.THROTTLED_TIME, getThrottleTime());
-            return builder;
-        }
-    }
-
-    private final Stats totalStats;
-
-    public ProtobufIndexingStats() {
-        totalStats = new Stats();
-    }
-
-    public ProtobufIndexingStats(CodedInputStream in) throws IOException {
-        totalStats = new Stats(in);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        if (protobufStreamInput.getVersion().before(Version.V_2_0_0)) {
-            if (protobufStreamInput.readBoolean()) {
-                Map<String, Stats> typeStats = protobufStreamInput.readMap(CodedInputStream::readString, Stats::new);
-                assert typeStats.size() == 1;
-                assert typeStats.containsKey(MapperService.SINGLE_MAPPING_NAME);
-            }
-        }
-    }
-
-    public ProtobufIndexingStats(Stats totalStats) {
-        this.totalStats = totalStats;
-    }
-
-    public void add(ProtobufIndexingStats indexingStats) {
-        if (indexingStats == null) {
-            return;
-        }
-        addTotals(indexingStats);
-    }
-
-    public void addTotals(ProtobufIndexingStats indexingStats) {
-        if (indexingStats == null) {
-            return;
-        }
-        totalStats.add(indexingStats.totalStats);
-    }
-
-    public Stats getTotal() {
-        return this.totalStats;
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params params) throws IOException {
-        builder.startObject(Fields.INDEXING);
-        totalStats.toXContent(builder, params);
-        builder.endObject();
-        return builder;
-    }
-
-    /**
-     * Fields for indexing statistics
-    *
-    * @opensearch.internal
-    */
-    static final class Fields {
-        static final String INDEXING = "indexing";
-        static final String INDEX_TOTAL = "index_total";
-        static final String INDEX_TIME = "index_time";
-        static final String INDEX_TIME_IN_MILLIS = "index_time_in_millis";
-        static final String INDEX_CURRENT = "index_current";
-        static final String INDEX_FAILED = "index_failed";
-        static final String DELETE_TOTAL = "delete_total";
-        static final String DELETE_TIME = "delete_time";
-        static final String DELETE_TIME_IN_MILLIS = "delete_time_in_millis";
-        static final String DELETE_CURRENT = "delete_current";
-        static final String NOOP_UPDATE_TOTAL = "noop_update_total";
-        static final String IS_THROTTLED = "is_throttled";
-        static final String THROTTLED_TIME_IN_MILLIS = "throttle_time_in_millis";
-        static final String THROTTLED_TIME = "throttle_time";
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        totalStats.writeTo(out);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        if (protobufStreamOutput.getVersion().before(Version.V_2_0_0)) {
-            out.writeBoolNoTag(false);
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/index/store/ProtobufStoreStats.java b/server/src/main/java/org/opensearch/index/store/ProtobufStoreStats.java
deleted file mode 100644
index 58542143484b0..0000000000000
--- a/server/src/main/java/org/opensearch/index/store/ProtobufStoreStats.java
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.index.store;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-
-/**
- * Statistics about an OpenSearch Store
-*
-* @opensearch.internal
-*/
-public class ProtobufStoreStats implements ProtobufWriteable, ToXContentFragment {
-
-    /**
-     * Sentinel value for cases where the shard does not yet know its reserved size so we must fall back to an estimate, for instance
-    * prior to receiving the list of files in a peer recovery.
-    */
-    public static final long UNKNOWN_RESERVED_BYTES = -1L;
-    private long sizeInBytes;
-    private long reservedSize;
-
-    public ProtobufStoreStats() {
-
-    }
-
-    public ProtobufStoreStats(CodedInputStream in) throws IOException {
-        sizeInBytes = in.readInt64();
-        reservedSize = in.readInt64();
-    }
-
-    /**
-     * @param sizeInBytes the size of the store in bytes
-    * @param reservedSize a prediction of how much larger the store is expected to grow, or {@link ProtobufStoreStats#UNKNOWN_RESERVED_BYTES}.
-    */
-    public ProtobufStoreStats(long sizeInBytes, long reservedSize) {
-        assert reservedSize == UNKNOWN_RESERVED_BYTES || reservedSize >= 0 : reservedSize;
-        this.sizeInBytes = sizeInBytes;
-        this.reservedSize = reservedSize;
-    }
-
-    public void add(ProtobufStoreStats stats) {
-        if (stats == null) {
-            return;
-        }
-        sizeInBytes += stats.sizeInBytes;
-        reservedSize = ignoreIfUnknown(reservedSize) + ignoreIfUnknown(stats.reservedSize);
-    }
-
-    private static long ignoreIfUnknown(long reservedSize) {
-        return reservedSize == UNKNOWN_RESERVED_BYTES ? 0L : reservedSize;
-    }
-
-    public long sizeInBytes() {
-        return sizeInBytes;
-    }
-
-    public long getSizeInBytes() {
-        return sizeInBytes;
-    }
-
-    public ByteSizeValue size() {
-        return new ByteSizeValue(sizeInBytes);
-    }
-
-    public ByteSizeValue getSize() {
-        return size();
-    }
-
-    /**
-     * A prediction of how much larger this store will eventually grow. For instance, if we are currently doing a peer recovery or restoring
-    * a snapshot into this store then we can account for the rest of the recovery using this field. A value of {@code -1B} indicates that
-    * the reserved size is unknown.
-    */
-    public ByteSizeValue getReservedSize() {
-        return new ByteSizeValue(reservedSize);
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(sizeInBytes);
-        out.writeInt64NoTag(reservedSize);
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.STORE);
-        builder.humanReadableField(Fields.SIZE_IN_BYTES, Fields.SIZE, size());
-        builder.humanReadableField(Fields.RESERVED_IN_BYTES, Fields.RESERVED, getReservedSize());
-        builder.endObject();
-        return builder;
-    }
-
-    /**
-     * Fields for store statistics
-    *
-    * @opensearch.internal
-    */
-    static final class Fields {
-        static final String STORE = "store";
-        static final String SIZE = "size";
-        static final String SIZE_IN_BYTES = "size_in_bytes";
-        static final String RESERVED = "reserved";
-        static final String RESERVED_IN_BYTES = "reserved_in_bytes";
-    }
-}
diff --git a/server/src/main/java/org/opensearch/index/store/Store.java b/server/src/main/java/org/opensearch/index/store/Store.java
index e31b87348b4e9..921deae41946a 100644
--- a/server/src/main/java/org/opensearch/index/store/Store.java
+++ b/server/src/main/java/org/opensearch/index/store/Store.java
@@ -482,14 +482,6 @@ public StoreStats stats(long reservedBytes) throws IOException {
         return new StoreStats(directory.estimateSize(), reservedBytes);
     }
 
-    /**
-     * @param reservedBytes a prediction of how much larger the store is expected to grow, or {@link StoreStats#UNKNOWN_RESERVED_BYTES}.
-     */
-    public ProtobufStoreStats protobufStats(long reservedBytes) throws IOException {
-        ensureOpen();
-        return new ProtobufStoreStats(directory.estimateSize(), reservedBytes);
-    }
-
     /**
      * Increments the refCount of this Store instance.  RefCounts are used to determine when a
      * Store can be closed safely, i.e. as soon as there are no more references. Be sure to always call a
diff --git a/server/src/main/java/org/opensearch/index/translog/ProtobufTranslogStats.java b/server/src/main/java/org/opensearch/index/translog/ProtobufTranslogStats.java
deleted file mode 100644
index d45d6cb926edd..0000000000000
--- a/server/src/main/java/org/opensearch/index/translog/ProtobufTranslogStats.java
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.index.translog;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.Strings;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.common.xcontent.XContentType;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-
-/**
- * Translog statistics
-*
-* @opensearch.internal
-*/
-public class ProtobufTranslogStats implements ProtobufWriteable, ToXContentFragment {
-
-    private long translogSizeInBytes;
-    private int numberOfOperations;
-    private long uncommittedSizeInBytes;
-    private int uncommittedOperations;
-    private long earliestLastModifiedAge;
-
-    public ProtobufTranslogStats() {}
-
-    public ProtobufTranslogStats(CodedInputStream in) throws IOException {
-        numberOfOperations = in.readInt32();
-        translogSizeInBytes = in.readInt64();
-        uncommittedOperations = in.readInt32();
-        uncommittedSizeInBytes = in.readInt64();
-        earliestLastModifiedAge = in.readInt64();
-    }
-
-    public ProtobufTranslogStats(
-        int numberOfOperations,
-        long translogSizeInBytes,
-        int uncommittedOperations,
-        long uncommittedSizeInBytes,
-        long earliestLastModifiedAge
-    ) {
-        if (numberOfOperations < 0) {
-            throw new IllegalArgumentException("numberOfOperations must be >= 0");
-        }
-        if (translogSizeInBytes < 0) {
-            throw new IllegalArgumentException("translogSizeInBytes must be >= 0");
-        }
-        if (uncommittedOperations < 0) {
-            throw new IllegalArgumentException("uncommittedOperations must be >= 0");
-        }
-        if (uncommittedSizeInBytes < 0) {
-            throw new IllegalArgumentException("uncommittedSizeInBytes must be >= 0");
-        }
-        if (earliestLastModifiedAge < 0) {
-            throw new IllegalArgumentException("earliestLastModifiedAge must be >= 0");
-        }
-        this.numberOfOperations = numberOfOperations;
-        this.translogSizeInBytes = translogSizeInBytes;
-        this.uncommittedSizeInBytes = uncommittedSizeInBytes;
-        this.uncommittedOperations = uncommittedOperations;
-        this.earliestLastModifiedAge = earliestLastModifiedAge;
-    }
-
-    public void add(ProtobufTranslogStats translogStats) {
-        if (translogStats == null) {
-            return;
-        }
-
-        this.numberOfOperations += translogStats.numberOfOperations;
-        this.translogSizeInBytes += translogStats.translogSizeInBytes;
-        this.uncommittedOperations += translogStats.uncommittedOperations;
-        this.uncommittedSizeInBytes += translogStats.uncommittedSizeInBytes;
-        if (this.earliestLastModifiedAge == 0) {
-            this.earliestLastModifiedAge = translogStats.earliestLastModifiedAge;
-        } else {
-            this.earliestLastModifiedAge = Math.min(this.earliestLastModifiedAge, translogStats.earliestLastModifiedAge);
-        }
-    }
-
-    public long getTranslogSizeInBytes() {
-        return translogSizeInBytes;
-    }
-
-    public int estimatedNumberOfOperations() {
-        return numberOfOperations;
-    }
-
-    /** the size of the generations in the translog that weren't yet to committed to lucene */
-    public long getUncommittedSizeInBytes() {
-        return uncommittedSizeInBytes;
-    }
-
-    /** the number of operations in generations of the translog that weren't yet to committed to lucene */
-    public int getUncommittedOperations() {
-        return uncommittedOperations;
-    }
-
-    public long getEarliestLastModifiedAge() {
-        return earliestLastModifiedAge;
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject("translog");
-        builder.field("operations", numberOfOperations);
-        builder.humanReadableField("size_in_bytes", "size", new ByteSizeValue(translogSizeInBytes));
-        builder.field("uncommitted_operations", uncommittedOperations);
-        builder.humanReadableField("uncommitted_size_in_bytes", "uncommitted_size", new ByteSizeValue(uncommittedSizeInBytes));
-        builder.field("earliest_last_modified_age", earliestLastModifiedAge);
-        builder.endObject();
-        return builder;
-    }
-
-    @Override
-    public String toString() {
-        return Strings.toString(XContentType.JSON, this, true, true);
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt32NoTag(numberOfOperations);
-        out.writeInt64NoTag(translogSizeInBytes);
-        out.writeInt32NoTag(uncommittedOperations);
-        out.writeInt64NoTag(uncommittedSizeInBytes);
-        out.writeInt64NoTag(earliestLastModifiedAge);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/index/warmer/ProtobufWarmerStats.java b/server/src/main/java/org/opensearch/index/warmer/ProtobufWarmerStats.java
deleted file mode 100644
index db45b2b37ba0f..0000000000000
--- a/server/src/main/java/org/opensearch/index/warmer/ProtobufWarmerStats.java
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.index.warmer;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-
-/**
- * Stats collected about the warmer
-*
-* @opensearch.internal
-*/
-public class ProtobufWarmerStats implements ProtobufWriteable, ToXContentFragment {
-
-    private long current;
-
-    private long total;
-
-    private long totalTimeInMillis;
-
-    public ProtobufWarmerStats() {
-
-    }
-
-    public ProtobufWarmerStats(CodedInputStream in) throws IOException {
-        current = in.readInt64();
-        total = in.readInt64();
-        totalTimeInMillis = in.readInt64();
-    }
-
-    public ProtobufWarmerStats(long current, long total, long totalTimeInMillis) {
-        this.current = current;
-        this.total = total;
-        this.totalTimeInMillis = totalTimeInMillis;
-    }
-
-    public void add(long current, long total, long totalTimeInMillis) {
-        this.current += current;
-        this.total += total;
-        this.totalTimeInMillis += totalTimeInMillis;
-    }
-
-    public void add(ProtobufWarmerStats warmerStats) {
-        if (warmerStats == null) {
-            return;
-        }
-        this.current += warmerStats.current;
-        this.total += warmerStats.total;
-        this.totalTimeInMillis += warmerStats.totalTimeInMillis;
-    }
-
-    public long current() {
-        return this.current;
-    }
-
-    /**
-     * The total number of warmer executed.
-    */
-    public long total() {
-        return this.total;
-    }
-
-    /**
-     * The total time warmer have been executed (in milliseconds).
-    */
-    public long totalTimeInMillis() {
-        return this.totalTimeInMillis;
-    }
-
-    /**
-     * The total time warmer have been executed.
-    */
-    public TimeValue totalTime() {
-        return new TimeValue(totalTimeInMillis);
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.WARMER);
-        builder.field(Fields.CURRENT, current);
-        builder.field(Fields.TOTAL, total);
-        builder.humanReadableField(Fields.TOTAL_TIME_IN_MILLIS, Fields.TOTAL_TIME, totalTime());
-        builder.endObject();
-        return builder;
-    }
-
-    /**
-     * Fields for warmer statistics
-    *
-    * @opensearch.internal
-    */
-    static final class Fields {
-        static final String WARMER = "warmer";
-        static final String CURRENT = "current";
-        static final String TOTAL = "total";
-        static final String TOTAL_TIME = "total_time";
-        static final String TOTAL_TIME_IN_MILLIS = "total_time_in_millis";
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(current);
-        out.writeInt64NoTag(total);
-        out.writeInt64NoTag(totalTimeInMillis);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/index/warmer/ShardIndexWarmerService.java b/server/src/main/java/org/opensearch/index/warmer/ShardIndexWarmerService.java
index af842da0618f8..099b55dd52d03 100644
--- a/server/src/main/java/org/opensearch/index/warmer/ShardIndexWarmerService.java
+++ b/server/src/main/java/org/opensearch/index/warmer/ShardIndexWarmerService.java
@@ -72,7 +72,4 @@ public WarmerStats stats() {
         return new WarmerStats(current.count(), warmerMetric.count(), TimeUnit.NANOSECONDS.toMillis(warmerMetric.sum()));
     }
 
-    public ProtobufWarmerStats protobufStats() {
-        return new ProtobufWarmerStats(current.count(), warmerMetric.count(), TimeUnit.NANOSECONDS.toMillis(warmerMetric.sum()));
-    }
 }
diff --git a/server/src/main/java/org/opensearch/indices/IndicesQueryCache.java b/server/src/main/java/org/opensearch/indices/IndicesQueryCache.java
index 9015f1498ae5e..8f7df5157d673 100644
--- a/server/src/main/java/org/opensearch/indices/IndicesQueryCache.java
+++ b/server/src/main/java/org/opensearch/indices/IndicesQueryCache.java
@@ -49,7 +49,6 @@
 import org.opensearch.common.settings.Setting.Property;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.common.unit.ByteSizeValue;
-import org.opensearch.index.cache.query.ProtobufQueryCacheStats;
 import org.opensearch.index.cache.query.QueryCacheStats;
 import org.opensearch.core.index.shard.ShardId;
 
@@ -143,35 +142,6 @@ public QueryCacheStats getStats(ShardId shard) {
         return shardStats;
     }
 
-    /** Get usage statistics for the given shard. */
-    public ProtobufQueryCacheStats getProtobufStats(ShardId shard) {
-        final Map<ShardId, ProtobufQueryCacheStats> stats = new HashMap<>();
-        for (Map.Entry<ShardId, Stats> entry : shardStats.entrySet()) {
-            stats.put(entry.getKey(), entry.getValue().toProtobufQueryCacheStats());
-        }
-        ProtobufQueryCacheStats shardStats = new ProtobufQueryCacheStats();
-        ProtobufQueryCacheStats info = stats.get(shard);
-        if (info == null) {
-            info = new ProtobufQueryCacheStats();
-        }
-        shardStats.add(info);
-
-        // We also have some shared ram usage that we try to distribute to
-        // proportionally to their number of cache entries of each shard
-        if (stats.isEmpty()) {
-            shardStats.add(new ProtobufQueryCacheStats(sharedRamBytesUsed, 0, 0, 0, 0));
-        } else {
-            long totalSize = 0;
-            for (ProtobufQueryCacheStats s : stats.values()) {
-                totalSize += s.getCacheSize();
-            }
-            final double weight = totalSize == 0 ? 1d / stats.size() : ((double) shardStats.getCacheSize()) / totalSize;
-            final long additionalRamBytesUsed = Math.round(weight * sharedRamBytesUsed);
-            shardStats.add(new ProtobufQueryCacheStats(additionalRamBytesUsed, 0, 0, 0, 0));
-        }
-        return shardStats;
-    }
-
     @Override
     public Weight doCache(Weight weight, QueryCachingPolicy policy) {
         while (weight instanceof CachingWeightWrapper) {
@@ -272,10 +242,6 @@ QueryCacheStats toQueryCacheStats() {
             return new QueryCacheStats(ramBytesUsed, hitCount, missCount, cacheCount, cacheSize);
         }
 
-        ProtobufQueryCacheStats toProtobufQueryCacheStats() {
-            return new ProtobufQueryCacheStats(ramBytesUsed, hitCount, missCount, cacheCount, cacheSize);
-        }
-
         @Override
         public String toString() {
             return "{shardId="
diff --git a/server/src/main/java/org/opensearch/indices/IndicesService.java b/server/src/main/java/org/opensearch/indices/IndicesService.java
index 2b89024b6a46b..7be824d95b421 100644
--- a/server/src/main/java/org/opensearch/indices/IndicesService.java
+++ b/server/src/main/java/org/opensearch/indices/IndicesService.java
@@ -46,9 +46,6 @@
 import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
 import org.opensearch.action.admin.indices.stats.CommonStatsFlags.Flag;
 import org.opensearch.action.admin.indices.stats.IndexShardStats;
-import org.opensearch.action.admin.indices.stats.ProtobufCommonStats;
-import org.opensearch.action.admin.indices.stats.ProtobufIndexShardStats;
-import org.opensearch.action.admin.indices.stats.ProtobufShardStats;
 import org.opensearch.action.admin.indices.stats.ShardStats;
 import org.opensearch.action.search.SearchType;
 import org.opensearch.client.Client;
@@ -115,20 +112,14 @@
 import org.opensearch.index.engine.ReadOnlyEngine;
 import org.opensearch.index.fielddata.IndexFieldDataCache;
 import org.opensearch.index.flush.FlushStats;
-import org.opensearch.index.flush.ProtobufFlushStats;
 import org.opensearch.index.get.GetStats;
-import org.opensearch.index.get.ProtobufGetStats;
 import org.opensearch.index.mapper.IdFieldMapper;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.merge.MergeStats;
-import org.opensearch.index.merge.ProtobufMergeStats;
 import org.opensearch.index.query.QueryBuilder;
 import org.opensearch.index.query.QueryRewriteContext;
-import org.opensearch.index.recovery.ProtobufRecoveryStats;
 import org.opensearch.index.recovery.RecoveryStats;
-import org.opensearch.index.refresh.ProtobufRefreshStats;
 import org.opensearch.index.refresh.RefreshStats;
-import org.opensearch.index.search.stats.ProtobufSearchStats;
 import org.opensearch.index.remote.RemoteRefreshSegmentPressureService;
 import org.opensearch.index.search.stats.SearchStats;
 import org.opensearch.index.seqno.RetentionLeaseStats;
@@ -140,7 +131,6 @@
 import org.opensearch.index.shard.IndexShardState;
 import org.opensearch.index.shard.IndexingOperationListener;
 import org.opensearch.index.shard.IndexingStats;
-import org.opensearch.index.shard.ProtobufIndexingStats;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.store.remote.filecache.FileCacheCleaner;
 import org.opensearch.index.translog.InternalTranslogFactory;
@@ -306,7 +296,6 @@ public class IndicesService extends AbstractLifecycleComponent
     private final Map<Index, List<PendingDelete>> pendingDeletes = new HashMap<>();
     private final AtomicInteger numUncompletedDeletes = new AtomicInteger();
     private final OldShardsStats oldShardsStats = new OldShardsStats();
-    private final ProtobufOldShardsStats protobufOldShardsStats = new ProtobufOldShardsStats();
     private final MapperRegistry mapperRegistry;
     private final NamedWriteableRegistry namedWriteableRegistry;
     private final IndexingMemoryController indexingMemoryController;
@@ -553,38 +542,6 @@ public NodeIndicesStats stats(CommonStatsFlags flags) {
         return new NodeIndicesStats(commonStats, statsByShard(this, flags));
     }
 
-    public ProtobufNodeIndicesStats protobufStats(CommonStatsFlags flags) {
-        ProtobufCommonStats commonStats = new ProtobufCommonStats(flags);
-        // the cumulative statistics also account for shards that are no longer on this node, which is tracked by oldShardsStats
-        for (Flag flag : flags.getFlags()) {
-            switch (flag) {
-                case Get:
-                    commonStats.get.add(protobufOldShardsStats.getStats);
-                    break;
-                case Indexing:
-                    commonStats.indexing.add(protobufOldShardsStats.indexingStats);
-                    break;
-                case Search:
-                    commonStats.search.add(protobufOldShardsStats.searchStats);
-                    break;
-                case Merge:
-                    commonStats.merge.add(protobufOldShardsStats.mergeStats);
-                    break;
-                case Refresh:
-                    commonStats.refresh.add(protobufOldShardsStats.refreshStats);
-                    break;
-                case Recovery:
-                    commonStats.recoveryStats.add(protobufOldShardsStats.recoveryStats);
-                    break;
-                case Flush:
-                    commonStats.flush.add(protobufOldShardsStats.flushStats);
-                    break;
-            }
-        }
-
-        return new ProtobufNodeIndicesStats(commonStats, statsByShardProtobuf(this, flags));
-    }
-
     Map<Index, List<IndexShardStats>> statsByShard(final IndicesService indicesService, final CommonStatsFlags flags) {
         final Map<Index, List<IndexShardStats>> statsByShard = new HashMap<>();
 
@@ -612,37 +569,6 @@ Map<Index, List<IndexShardStats>> statsByShard(final IndicesService indicesServi
         return statsByShard;
     }
 
-    Map<Index, List<ProtobufIndexShardStats>> statsByShardProtobuf(final IndicesService indicesService, final CommonStatsFlags flags) {
-        final Map<Index, List<ProtobufIndexShardStats>> statsByShard = new HashMap<>();
-
-        for (final IndexService indexService : indicesService) {
-            for (final IndexShard indexShard : indexService) {
-                try {
-                    final ProtobufIndexShardStats indexShardStats = indicesService.indexShardStatsProtobuf(
-                        indicesService,
-                        indexShard,
-                        flags
-                    );
-
-                    if (indexShardStats == null) {
-                        continue;
-                    }
-
-                    if (statsByShard.containsKey(indexService.index()) == false) {
-                        statsByShard.put(indexService.index(), arrayAsArrayList(indexShardStats));
-                    } else {
-                        statsByShard.get(indexService.index()).add(indexShardStats);
-                    }
-                } catch (IllegalIndexShardStateException | AlreadyClosedException e) {
-                    // we can safely ignore illegal state on ones that are closing for example
-                    logger.trace(() -> new ParameterizedMessage("{} ignoring shard stats", indexShard.shardId()), e);
-                }
-            }
-        }
-
-        return statsByShard;
-    }
-
     IndexShardStats indexShardStats(final IndicesService indicesService, final IndexShard indexShard, final CommonStatsFlags flags) {
         if (indexShard.routingEntry() == null) {
             return null;
@@ -676,43 +602,6 @@ IndexShardStats indexShardStats(final IndicesService indicesService, final Index
         );
     }
 
-    ProtobufIndexShardStats indexShardStatsProtobuf(
-        final IndicesService indicesService,
-        final IndexShard indexShard,
-        final CommonStatsFlags flags
-    ) {
-        if (indexShard.routingEntry() == null) {
-            return null;
-        }
-
-        CommitStats commitStats;
-        SeqNoStats seqNoStats;
-        RetentionLeaseStats retentionLeaseStats;
-        try {
-            commitStats = indexShard.commitStats();
-            seqNoStats = indexShard.seqNoStats();
-            retentionLeaseStats = indexShard.getRetentionLeaseStats();
-        } catch (AlreadyClosedException e) {
-            // shard is closed - no stats is fine
-            commitStats = null;
-            seqNoStats = null;
-            retentionLeaseStats = null;
-        }
-
-        return new ProtobufIndexShardStats(
-            indexShard.shardId(),
-            new ProtobufShardStats[] {
-                new ProtobufShardStats(
-                    indexShard.routingEntry(),
-                    indexShard.shardPath(),
-                    new ProtobufCommonStats(indicesService.getIndicesQueryCache(), indexShard, flags),
-                    commitStats,
-                    seqNoStats,
-                    retentionLeaseStats
-                ) }
-        );
-    }
-
     /**
      * Checks if changes (adding / removing) indices, shards and so on are allowed.
      *
@@ -1143,36 +1032,6 @@ public synchronized void beforeIndexShardClosed(ShardId shardId, @Nullable Index
         }
     }
 
-    /**
-     * Statistics for old shards
-     *
-     * @opensearch.internal
-     */
-    static class ProtobufOldShardsStats implements IndexEventListener {
-
-        final ProtobufSearchStats searchStats = new ProtobufSearchStats();
-        final ProtobufGetStats getStats = new ProtobufGetStats();
-        final ProtobufIndexingStats indexingStats = new ProtobufIndexingStats();
-        final ProtobufMergeStats mergeStats = new ProtobufMergeStats();
-        final ProtobufRefreshStats refreshStats = new ProtobufRefreshStats();
-        final ProtobufFlushStats flushStats = new ProtobufFlushStats();
-        final ProtobufRecoveryStats recoveryStats = new ProtobufRecoveryStats();
-
-        @Override
-        public synchronized void beforeIndexShardClosed(ShardId shardId, @Nullable IndexShard indexShard, Settings indexSettings) {
-            if (indexShard != null) {
-                getStats.addTotals(indexShard.getProtobufStats());
-                indexingStats.addTotals(indexShard.protobufIndexingStats());
-                // if this index was closed or deleted, we should eliminate the effect of the current scroll for this shard
-                searchStats.addTotalsForClosingShard(indexShard.protobufSearchStats());
-                mergeStats.addTotals(indexShard.protobufMergeStats());
-                refreshStats.addTotals(indexShard.protobufRefreshStats());
-                flushStats.addTotals(indexShard.protobufFlushStats());
-                recoveryStats.addTotals(indexShard.protobufRecoveryStats());
-            }
-        }
-    }
-
     /**
      * Deletes an index that is not assigned to this node. This method cleans up all disk folders relating to the index
      * but does not deal with in-memory structures. For those call {@link #removeIndex(Index, IndexRemovalReason, String)}
diff --git a/server/src/main/java/org/opensearch/indices/ProtobufNodeIndicesStats.java b/server/src/main/java/org/opensearch/indices/ProtobufNodeIndicesStats.java
deleted file mode 100644
index 27269cb02626a..0000000000000
--- a/server/src/main/java/org/opensearch/indices/ProtobufNodeIndicesStats.java
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.indices;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
-import org.opensearch.action.admin.indices.stats.ProtobufIndexShardStats;
-import org.opensearch.action.admin.indices.stats.ProtobufCommonStats;
-import org.opensearch.action.admin.indices.stats.ProtobufShardStats;
-import org.opensearch.common.Nullable;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.index.Index;
-import org.opensearch.index.cache.query.ProtobufQueryCacheStats;
-import org.opensearch.index.cache.request.ProtobufRequestCacheStats;
-import org.opensearch.index.engine.ProtobufSegmentsStats;
-import org.opensearch.index.fielddata.ProtobufFieldDataStats;
-import org.opensearch.index.flush.ProtobufFlushStats;
-import org.opensearch.index.get.ProtobufGetStats;
-import org.opensearch.index.merge.ProtobufMergeStats;
-import org.opensearch.index.recovery.ProtobufRecoveryStats;
-import org.opensearch.index.refresh.ProtobufRefreshStats;
-import org.opensearch.index.search.stats.ProtobufSearchStats;
-import org.opensearch.index.shard.ProtobufDocsStats;
-import org.opensearch.index.shard.ProtobufIndexingStats;
-import org.opensearch.index.store.ProtobufStoreStats;
-import org.opensearch.index.translog.ProtobufTranslogStats;
-import org.opensearch.index.warmer.ProtobufWarmerStats;
-import org.opensearch.search.suggest.completion.ProtobufCompletionStats;
-
-import java.io.IOException;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Global information on indices stats running on a specific node.
-*
-* @opensearch.internal
-*/
-public class ProtobufNodeIndicesStats implements ProtobufWriteable, ToXContentFragment {
-
-    private ProtobufCommonStats stats;
-    private Map<Index, List<ProtobufIndexShardStats>> statsByShard;
-
-    public ProtobufNodeIndicesStats(CodedInputStream in) throws IOException {
-        stats = new ProtobufCommonStats(in);
-    }
-
-    public ProtobufNodeIndicesStats(ProtobufCommonStats oldStats, Map<Index, List<ProtobufIndexShardStats>> statsByShard) {
-        // this.stats = stats;
-        this.statsByShard = statsByShard;
-
-        // make a total common stats from old ones and current ones
-        this.stats = oldStats;
-        for (List<ProtobufIndexShardStats> shardStatsList : statsByShard.values()) {
-            for (ProtobufIndexShardStats indexShardStats : shardStatsList) {
-                for (ProtobufShardStats shardStats : indexShardStats.getShards()) {
-                    stats.add(shardStats.getStats());
-                }
-            }
-        }
-    }
-
-    @Nullable
-    public ProtobufStoreStats getStore() {
-        return stats.getStore();
-    }
-
-    @Nullable
-    public ProtobufDocsStats getDocs() {
-        return stats.getDocs();
-    }
-
-    @Nullable
-    public ProtobufIndexingStats getIndexing() {
-        return stats.getIndexing();
-    }
-
-    @Nullable
-    public ProtobufGetStats getGet() {
-        return stats.getGet();
-    }
-
-    @Nullable
-    public ProtobufSearchStats getSearch() {
-        return stats.getSearch();
-    }
-
-    @Nullable
-    public ProtobufMergeStats getMerge() {
-        return stats.getMerge();
-    }
-
-    @Nullable
-    public ProtobufRefreshStats getRefresh() {
-        return stats.getRefresh();
-    }
-
-    @Nullable
-    public ProtobufFlushStats getFlush() {
-        return stats.getFlush();
-    }
-
-    @Nullable
-    public ProtobufWarmerStats getWarmer() {
-        return stats.getWarmer();
-    }
-
-    @Nullable
-    public ProtobufFieldDataStats getFieldData() {
-        return stats.getFieldData();
-    }
-
-    @Nullable
-    public ProtobufQueryCacheStats getQueryCache() {
-        return stats.getQueryCache();
-    }
-
-    @Nullable
-    public ProtobufRequestCacheStats getRequestCache() {
-        return stats.getRequestCache();
-    }
-
-    @Nullable
-    public ProtobufCompletionStats getCompletion() {
-        return stats.getCompletion();
-    }
-
-    @Nullable
-    public ProtobufSegmentsStats getSegments() {
-        return stats.getSegments();
-    }
-
-    @Nullable
-    public ProtobufTranslogStats getTranslog() {
-        return stats.getTranslog();
-    }
-
-    @Nullable
-    public ProtobufRecoveryStats getRecoveryStats() {
-        return stats.getRecoveryStats();
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        stats.writeTo(out);
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        final String level = params.param("level", "node");
-        final boolean isLevelValid = "indices".equalsIgnoreCase(level)
-            || "node".equalsIgnoreCase(level)
-            || "shards".equalsIgnoreCase(level);
-        if (!isLevelValid) {
-            throw new IllegalArgumentException("level parameter must be one of [indices] or [node] or [shards] but was [" + level + "]");
-        }
-
-        // "node" level
-        builder.startObject(Fields.INDICES);
-        stats.toXContent(builder, params);
-        builder.endObject();
-        return builder;
-    }
-
-    /**
-     * Fields used for parsing and toXContent
-    *
-    * @opensearch.internal
-    */
-    static final class Fields {
-        static final String INDICES = "indices";
-    }
-}
diff --git a/server/src/main/java/org/opensearch/indices/breaker/HierarchyCircuitBreakerService.java b/server/src/main/java/org/opensearch/indices/breaker/HierarchyCircuitBreakerService.java
index b05832b61a405..34cadd2c828d0 100644
--- a/server/src/main/java/org/opensearch/indices/breaker/HierarchyCircuitBreakerService.java
+++ b/server/src/main/java/org/opensearch/indices/breaker/HierarchyCircuitBreakerService.java
@@ -344,39 +344,6 @@ public CircuitBreakerStats stats(String name) {
         );
     }
 
-    @Override
-    public ProtobufAllCircuitBreakerStats protobufStats() {
-        List<ProtobufCircuitBreakerStats> allStats = new ArrayList<>(this.breakers.size());
-        // Gather the "estimated" count for the parent breaker by adding the
-        // estimations for each individual breaker
-        for (CircuitBreaker breaker : this.breakers.values()) {
-            allStats.add(protobufStats(breaker.getName()));
-        }
-        // Manually add the parent breaker settings since they aren't part of the breaker map
-        allStats.add(
-            new ProtobufCircuitBreakerStats(
-                CircuitBreaker.PARENT,
-                parentSettings.getLimit(),
-                memoryUsed(0L).totalUsage,
-                1.0,
-                parentTripCount.get()
-            )
-        );
-        return new ProtobufAllCircuitBreakerStats(allStats.toArray(new ProtobufCircuitBreakerStats[0]));
-    }
-
-    @Override
-    public ProtobufCircuitBreakerStats protobufStats(String name) {
-        CircuitBreaker breaker = this.breakers.get(name);
-        return new ProtobufCircuitBreakerStats(
-            breaker.getName(),
-            breaker.getLimit(),
-            breaker.getUsed(),
-            breaker.getOverhead(),
-            breaker.getTrippedCount()
-        );
-    }
-
     /**
      * Tracks memory usage
      *
diff --git a/server/src/main/java/org/opensearch/indices/breaker/ProtobufAllCircuitBreakerStats.java b/server/src/main/java/org/opensearch/indices/breaker/ProtobufAllCircuitBreakerStats.java
deleted file mode 100644
index 220a7b5c37121..0000000000000
--- a/server/src/main/java/org/opensearch/indices/breaker/ProtobufAllCircuitBreakerStats.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.indices.breaker;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-
-/**
- * Stats class encapsulating all of the different circuit breaker stats
-*
-* @opensearch.internal
-*/
-public class ProtobufAllCircuitBreakerStats implements ProtobufWriteable, ToXContentFragment {
-
-    private final ProtobufCircuitBreakerStats[] allStats;
-
-    public ProtobufAllCircuitBreakerStats(ProtobufCircuitBreakerStats[] allStats) {
-        this.allStats = allStats;
-    }
-
-    public ProtobufAllCircuitBreakerStats(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        allStats = protobufStreamInput.readArray(ProtobufCircuitBreakerStats::new, ProtobufCircuitBreakerStats[]::new);
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeArray((o, v) -> v.writeTo(o), allStats);
-    }
-
-    public ProtobufCircuitBreakerStats[] getAllStats() {
-        return this.allStats;
-    }
-
-    public ProtobufCircuitBreakerStats getStats(String name) {
-        for (ProtobufCircuitBreakerStats stats : allStats) {
-            if (stats.getName().equals(name)) {
-                return stats;
-            }
-        }
-        return null;
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.BREAKERS);
-        for (ProtobufCircuitBreakerStats stats : allStats) {
-            if (stats != null) {
-                stats.toXContent(builder, params);
-            }
-        }
-        builder.endObject();
-        return builder;
-    }
-
-    /**
-     * Fields used for parsing and toXContent
-    *
-    * @opensearch.internal
-    */
-    static final class Fields {
-        static final String BREAKERS = "breakers";
-    }
-}
diff --git a/server/src/main/java/org/opensearch/indices/breaker/ProtobufCircuitBreakerStats.java b/server/src/main/java/org/opensearch/indices/breaker/ProtobufCircuitBreakerStats.java
deleted file mode 100644
index 75f914f232354..0000000000000
--- a/server/src/main/java/org/opensearch/indices/breaker/ProtobufCircuitBreakerStats.java
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.indices.breaker;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.core.xcontent.ToXContentObject;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.util.Locale;
-
-/**
- * Class encapsulating stats about the circuit breaker
-*
-* @opensearch.internal
-*/
-public class ProtobufCircuitBreakerStats implements ProtobufWriteable, ToXContentObject {
-
-    private final String name;
-    private final long limit;
-    private final long estimated;
-    private final long trippedCount;
-    private final double overhead;
-
-    public ProtobufCircuitBreakerStats(String name, long limit, long estimated, double overhead, long trippedCount) {
-        this.name = name;
-        this.limit = limit;
-        this.estimated = estimated;
-        this.trippedCount = trippedCount;
-        this.overhead = overhead;
-    }
-
-    public ProtobufCircuitBreakerStats(CodedInputStream in) throws IOException {
-        this.limit = in.readInt64();
-        this.estimated = in.readInt64();
-        this.overhead = in.readDouble();
-        this.trippedCount = in.readInt64();
-        this.name = in.readString();
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(limit);
-        out.writeInt64NoTag(estimated);
-        out.writeDoubleNoTag(overhead);
-        out.writeInt64NoTag(trippedCount);
-        out.writeStringNoTag(name);
-    }
-
-    public String getName() {
-        return this.name;
-    }
-
-    public long getLimit() {
-        return this.limit;
-    }
-
-    public long getEstimated() {
-        return this.estimated;
-    }
-
-    public long getTrippedCount() {
-        return this.trippedCount;
-    }
-
-    public double getOverhead() {
-        return this.overhead;
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(name.toLowerCase(Locale.ROOT));
-        builder.field(Fields.LIMIT, limit);
-        builder.field(Fields.LIMIT_HUMAN, new ByteSizeValue(limit));
-        builder.field(Fields.ESTIMATED, estimated);
-        builder.field(Fields.ESTIMATED_HUMAN, new ByteSizeValue(estimated));
-        builder.field(Fields.OVERHEAD, overhead);
-        builder.field(Fields.TRIPPED_COUNT, trippedCount);
-        builder.endObject();
-        return builder;
-    }
-
-    @Override
-    public String toString() {
-        return "["
-            + this.name
-            + ",limit="
-            + this.limit
-            + "/"
-            + new ByteSizeValue(this.limit)
-            + ",estimated="
-            + this.estimated
-            + "/"
-            + new ByteSizeValue(this.estimated)
-            + ",overhead="
-            + this.overhead
-            + ",tripped="
-            + this.trippedCount
-            + "]";
-    }
-
-    /**
-     * Fields used for statistics
-    *
-    * @opensearch.internal
-    */
-    static final class Fields {
-        static final String LIMIT = "limit_size_in_bytes";
-        static final String LIMIT_HUMAN = "limit_size";
-        static final String ESTIMATED = "estimated_size_in_bytes";
-        static final String ESTIMATED_HUMAN = "estimated_size";
-        static final String OVERHEAD = "overhead";
-        static final String TRIPPED_COUNT = "tripped";
-    }
-}
diff --git a/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java b/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
index c57e153d7e349..5f56341eb0901 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
@@ -70,7 +70,6 @@
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ConnectTransportException;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
@@ -752,18 +751,6 @@ public RecoveryResponse read(StreamInput in) throws IOException {
             return new RecoveryResponse(in);
         }
 
-        @Override
-        public RecoveryResponse read(CodedInputStream in) throws IOException {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'read'");
-        }
-
-        @Override
-        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-        }
-
         @Override
         public RecoveryResponse read(byte[] in) throws IOException {
             // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java b/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
index 2b5547e7f2256..41d5e557a043e 100644
--- a/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
+++ b/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
@@ -34,7 +34,6 @@
 import org.opensearch.node.NodeClosedException;
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
@@ -176,18 +175,6 @@ public void handleException(TransportException e) {
                         );
                     }
 
-                    @Override
-                    public ReplicationResponse read(CodedInputStream in) throws IOException {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'read'");
-                    }
-
-                    @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                    }
-
                     @Override
                     public ReplicationResponse read(byte[] in) throws IOException {
                         // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/indices/store/IndicesStore.java b/server/src/main/java/org/opensearch/indices/store/IndicesStore.java
index ce6557e160b83..60691a07f7158 100644
--- a/server/src/main/java/org/opensearch/indices/store/IndicesStore.java
+++ b/server/src/main/java/org/opensearch/indices/store/IndicesStore.java
@@ -65,7 +65,6 @@
 import org.opensearch.indices.IndicesService;
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
@@ -355,18 +354,6 @@ private void allNodesResponded() {
                 );
         }
 
-        @Override
-        public ShardActiveResponse read(CodedInputStream in) throws IOException {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'read'");
-        }
-
-        @Override
-        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-        }
-
         @Override
         public ShardActiveResponse read(byte[] in) throws IOException {
             // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/ingest/IngestService.java b/server/src/main/java/org/opensearch/ingest/IngestService.java
index 3d6446c72e90d..117bb0dd75bc6 100644
--- a/server/src/main/java/org/opensearch/ingest/IngestService.java
+++ b/server/src/main/java/org/opensearch/ingest/IngestService.java
@@ -99,7 +99,7 @@
  *
  * @opensearch.internal
  */
-public class IngestService implements ClusterStateApplier, ReportingService<IngestInfo>, ProtobufReportingService<ProtobufIngestInfo> {
+public class IngestService implements ClusterStateApplier, ReportingService<IngestInfo> {
 
     public static final String NOOP_PIPELINE_NAME = "_none";
 
@@ -434,16 +434,6 @@ public IngestInfo info() {
         return new IngestInfo(processorInfoList);
     }
 
-    @Override
-    public ProtobufIngestInfo protobufInfo() {
-        Map<String, Processor.Factory> processorFactories = getProcessorFactories();
-        List<ProtobufProcessorInfo> processorInfoList = new ArrayList<>(processorFactories.size());
-        for (Map.Entry<String, Processor.Factory> entry : processorFactories.entrySet()) {
-            processorInfoList.add(new ProtobufProcessorInfo(entry.getKey()));
-        }
-        return new ProtobufIngestInfo(processorInfoList);
-    }
-
     Map<String, PipelineHolder> pipelines() {
         return pipelines;
     }
@@ -703,24 +693,6 @@ public IngestStats stats() {
         return statsBuilder.build();
     }
 
-    public ProtobufIngestStats protobufStats() {
-        ProtobufIngestStats.Builder statsBuilder = new ProtobufIngestStats.Builder();
-        statsBuilder.addTotalMetrics(totalMetrics);
-        pipelines.forEach((id, holder) -> {
-            Pipeline pipeline = holder.pipeline;
-            CompoundProcessor rootProcessor = pipeline.getCompoundProcessor();
-            statsBuilder.addPipelineMetrics(id, pipeline.getMetrics());
-            List<Tuple<Processor, IngestMetric>> processorMetrics = new ArrayList<>();
-            getProcessorMetrics(rootProcessor, processorMetrics);
-            processorMetrics.forEach(t -> {
-                Processor processor = t.v1();
-                IngestMetric processorMetric = t.v2();
-                statsBuilder.addProcessorMetrics(id, getProcessorName(processor), processor.getType(), processorMetric);
-            });
-        });
-        return statsBuilder.build();
-    }
-
     /**
      * Adds a listener that gets invoked with the current cluster state before processor factories
      * get invoked.
diff --git a/server/src/main/java/org/opensearch/ingest/PipelineConfiguration.java b/server/src/main/java/org/opensearch/ingest/PipelineConfiguration.java
index 464c29e8a0c92..ff9c38c259d36 100644
--- a/server/src/main/java/org/opensearch/ingest/PipelineConfiguration.java
+++ b/server/src/main/java/org/opensearch/ingest/PipelineConfiguration.java
@@ -60,7 +60,7 @@
  *
  * @opensearch.internal
  */
-public final class PipelineConfiguration extends AbstractDiffable<PipelineConfiguration, PipelineConfiguration> implements ToXContentObject {
+public final class PipelineConfiguration extends AbstractDiffable<PipelineConfiguration> implements ToXContentObject {
 
     private static final ObjectParser<Builder, Void> PARSER = new ObjectParser<>("pipeline_config", true, Builder::new);
     static {
@@ -187,9 +187,4 @@ public int hashCode() {
         return result;
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
-    }
 }
diff --git a/server/src/main/java/org/opensearch/ingest/ProtobufIngestInfo.java b/server/src/main/java/org/opensearch/ingest/ProtobufIngestInfo.java
deleted file mode 100644
index 52d26218e61d5..0000000000000
--- a/server/src/main/java/org/opensearch/ingest/ProtobufIngestInfo.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.ingest;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.node.ProtobufReportingService;
-
-import java.io.IOException;
-import java.util.List;
-import java.util.Set;
-import java.util.TreeSet;
-
-/**
- * Information about an ingest event
-*
-* @opensearch.internal
-*/
-public class ProtobufIngestInfo implements ProtobufReportingService.ProtobufInfo {
-
-    private final Set<ProtobufProcessorInfo> processors;
-
-    public ProtobufIngestInfo(List<ProtobufProcessorInfo> processors) {
-        this.processors = new TreeSet<>(processors);  // we use a treeset here to have a test-able / predictable order
-    }
-
-    /**
-     * Read from a stream.
-    */
-    public ProtobufIngestInfo(CodedInputStream in) throws IOException {
-        processors = new TreeSet<>();
-        final int size = in.readInt32();
-        for (int i = 0; i < size; i++) {
-            processors.add(new ProtobufProcessorInfo(in));
-        }
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt32NoTag(processors.size());
-        for (ProtobufProcessorInfo info : processors) {
-            info.writeTo(out);
-        }
-    }
-
-    public Iterable<ProtobufProcessorInfo> getProcessors() {
-        return processors;
-    }
-
-    public boolean containsProcessor(String type) {
-        return processors.contains(new ProtobufProcessorInfo(type));
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject("ingest");
-        builder.startArray("processors");
-        for (ProtobufProcessorInfo info : processors) {
-            info.toXContent(builder, params);
-        }
-        builder.endArray();
-        builder.endObject();
-        return builder;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/ingest/ProtobufIngestStats.java b/server/src/main/java/org/opensearch/ingest/ProtobufIngestStats.java
deleted file mode 100644
index 174885a879af4..0000000000000
--- a/server/src/main/java/org/opensearch/ingest/ProtobufIngestStats.java
+++ /dev/null
@@ -1,351 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.ingest;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.concurrent.TimeUnit;
-
-/**
- * Stats for an ingest processor pipeline
-*
-* @opensearch.internal
-*/
-public class ProtobufIngestStats implements ProtobufWriteable, ToXContentFragment {
-    private final Stats totalStats;
-    private final List<PipelineStat> pipelineStats;
-    private final Map<String, List<ProcessorStat>> processorStats;
-
-    /**
-     * @param totalStats - The total stats for Ingest. This is the logically the sum of all pipeline stats,
-    *                   and pipeline stats are logically the sum of the processor stats.
-    * @param pipelineStats - The stats for a given ingest pipeline.
-    * @param processorStats - The per-processor stats for a given pipeline. A map keyed by the pipeline identifier.
-    */
-    public ProtobufIngestStats(Stats totalStats, List<PipelineStat> pipelineStats, Map<String, List<ProcessorStat>> processorStats) {
-        this.totalStats = totalStats;
-        this.pipelineStats = pipelineStats;
-        this.processorStats = processorStats;
-    }
-
-    /**
-     * Read from a stream.
-    */
-    public ProtobufIngestStats(CodedInputStream in) throws IOException {
-        this.totalStats = new Stats(in);
-        int size = in.readInt32();
-        this.pipelineStats = new ArrayList<>(size);
-        this.processorStats = new HashMap<>(size);
-        for (int i = 0; i < size; i++) {
-            String pipelineId = in.readString();
-            Stats pipelineStat = new Stats(in);
-            this.pipelineStats.add(new PipelineStat(pipelineId, pipelineStat));
-            int processorsSize = in.readInt32();
-            List<ProcessorStat> processorStatsPerPipeline = new ArrayList<>(processorsSize);
-            for (int j = 0; j < processorsSize; j++) {
-                String processorName = in.readString();
-                String processorType = "_NOT_AVAILABLE";
-                processorType = in.readString();
-                Stats processorStat = new Stats(in);
-                processorStatsPerPipeline.add(new ProcessorStat(processorName, processorType, processorStat));
-            }
-            this.processorStats.put(pipelineId, processorStatsPerPipeline);
-        }
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        totalStats.writeTo(out);
-        out.writeInt32NoTag(pipelineStats.size());
-        for (PipelineStat pipelineStat : pipelineStats) {
-            out.writeStringNoTag(pipelineStat.getPipelineId());
-            pipelineStat.getStats().writeTo(out);
-            List<ProcessorStat> processorStatsForPipeline = processorStats.get(pipelineStat.getPipelineId());
-            if (processorStatsForPipeline == null) {
-                out.writeInt32NoTag(0);
-            } else {
-                out.writeInt32NoTag(processorStatsForPipeline.size());
-                for (ProcessorStat processorStat : processorStatsForPipeline) {
-                    out.writeStringNoTag(processorStat.getName());
-                    out.writeStringNoTag(processorStat.getType());
-                    processorStat.getStats().writeTo(out);
-                }
-            }
-        }
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject("ingest");
-        builder.startObject("total");
-        totalStats.toXContent(builder, params);
-        builder.endObject();
-        builder.startObject("pipelines");
-        for (PipelineStat pipelineStat : pipelineStats) {
-            builder.startObject(pipelineStat.getPipelineId());
-            pipelineStat.getStats().toXContent(builder, params);
-            List<ProcessorStat> processorStatsForPipeline = processorStats.get(pipelineStat.getPipelineId());
-            builder.startArray("processors");
-            if (processorStatsForPipeline != null) {
-                for (ProcessorStat processorStat : processorStatsForPipeline) {
-                    builder.startObject();
-                    builder.startObject(processorStat.getName());
-                    builder.field("type", processorStat.getType());
-                    builder.startObject("stats");
-                    processorStat.getStats().toXContent(builder, params);
-                    builder.endObject();
-                    builder.endObject();
-                    builder.endObject();
-                }
-            }
-            builder.endArray();
-            builder.endObject();
-        }
-        builder.endObject();
-        builder.endObject();
-        return builder;
-    }
-
-    public Stats getTotalStats() {
-        return totalStats;
-    }
-
-    public List<PipelineStat> getPipelineStats() {
-        return pipelineStats;
-    }
-
-    public Map<String, List<ProcessorStat>> getProcessorStats() {
-        return processorStats;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        ProtobufIngestStats that = (ProtobufIngestStats) o;
-        return Objects.equals(totalStats, that.totalStats)
-            && Objects.equals(pipelineStats, that.pipelineStats)
-            && Objects.equals(processorStats, that.processorStats);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(totalStats, pipelineStats, processorStats);
-    }
-
-    /**
-     * The ingest statistics.
-    *
-    * @opensearch.internal
-    */
-    public static class Stats implements ProtobufWriteable, ToXContentFragment {
-
-        private final long ingestCount;
-        private final long ingestTimeInMillis;
-        private final long ingestCurrent;
-        private final long ingestFailedCount;
-
-        public Stats(long ingestCount, long ingestTimeInMillis, long ingestCurrent, long ingestFailedCount) {
-            this.ingestCount = ingestCount;
-            this.ingestTimeInMillis = ingestTimeInMillis;
-            this.ingestCurrent = ingestCurrent;
-            this.ingestFailedCount = ingestFailedCount;
-        }
-
-        /**
-         * Read from a stream.
-        */
-        public Stats(CodedInputStream in) throws IOException {
-            ingestCount = in.readInt64();
-            ingestTimeInMillis = in.readInt64();
-            ingestCurrent = in.readInt64();
-            ingestFailedCount = in.readInt64();
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeInt64NoTag(ingestCount);
-            out.writeInt64NoTag(ingestTimeInMillis);
-            out.writeInt64NoTag(ingestCurrent);
-            out.writeInt64NoTag(ingestFailedCount);
-        }
-
-        /**
-         * @return The total number of executed ingest preprocessing operations.
-        */
-        public long getIngestCount() {
-            return ingestCount;
-        }
-
-        /**
-         * @return The total time spent of ingest preprocessing in millis.
-        */
-        public long getIngestTimeInMillis() {
-            return ingestTimeInMillis;
-        }
-
-        /**
-         * @return The total number of ingest preprocessing operations currently executing.
-        */
-        public long getIngestCurrent() {
-            return ingestCurrent;
-        }
-
-        /**
-         * @return The total number of ingest preprocessing operations that have failed.
-        */
-        public long getIngestFailedCount() {
-            return ingestFailedCount;
-        }
-
-        @Override
-        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-            builder.field("count", ingestCount);
-            builder.humanReadableField("time_in_millis", "time", new TimeValue(ingestTimeInMillis, TimeUnit.MILLISECONDS));
-            builder.field("current", ingestCurrent);
-            builder.field("failed", ingestFailedCount);
-            return builder;
-        }
-
-        @Override
-        public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
-            ProtobufIngestStats.Stats that = (ProtobufIngestStats.Stats) o;
-            return Objects.equals(ingestCount, that.ingestCount)
-                && Objects.equals(ingestTimeInMillis, that.ingestTimeInMillis)
-                && Objects.equals(ingestFailedCount, that.ingestFailedCount)
-                && Objects.equals(ingestCurrent, that.ingestCurrent);
-        }
-
-        @Override
-        public int hashCode() {
-            return Objects.hash(ingestCount, ingestTimeInMillis, ingestFailedCount, ingestCurrent);
-        }
-    }
-
-    /**
-     * Easy conversion from scoped {@link IngestMetric} objects to a serializable Stats objects
-    */
-    static class Builder {
-        private Stats totalStats;
-        private List<PipelineStat> pipelineStats = new ArrayList<>();
-        private Map<String, List<ProcessorStat>> processorStats = new HashMap<>();
-
-        Builder addTotalMetrics(IngestMetric totalMetric) {
-            this.totalStats = totalMetric.createProtobufStats();
-            return this;
-        }
-
-        Builder addPipelineMetrics(String pipelineId, IngestMetric pipelineMetric) {
-            this.pipelineStats.add(new PipelineStat(pipelineId, pipelineMetric.createProtobufStats()));
-            return this;
-        }
-
-        Builder addProcessorMetrics(String pipelineId, String processorName, String processorType, IngestMetric metric) {
-            this.processorStats.computeIfAbsent(pipelineId, k -> new ArrayList<>())
-                .add(new ProcessorStat(processorName, processorType, metric.createProtobufStats()));
-            return this;
-        }
-
-        ProtobufIngestStats build() {
-            return new ProtobufIngestStats(
-                totalStats,
-                Collections.unmodifiableList(pipelineStats),
-                Collections.unmodifiableMap(processorStats)
-            );
-        }
-    }
-
-    /**
-     * Container for pipeline stats.
-    */
-    public static class PipelineStat {
-        private final String pipelineId;
-        private final Stats stats;
-
-        public PipelineStat(String pipelineId, Stats stats) {
-            this.pipelineId = pipelineId;
-            this.stats = stats;
-        }
-
-        public String getPipelineId() {
-            return pipelineId;
-        }
-
-        public Stats getStats() {
-            return stats;
-        }
-
-        @Override
-        public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
-            ProtobufIngestStats.PipelineStat that = (ProtobufIngestStats.PipelineStat) o;
-            return Objects.equals(pipelineId, that.pipelineId) && Objects.equals(stats, that.stats);
-        }
-
-        @Override
-        public int hashCode() {
-            return Objects.hash(pipelineId, stats);
-        }
-    }
-
-    /**
-     * Container for processor stats.
-    */
-    public static class ProcessorStat {
-        private final String name;
-        private final String type;
-        private final Stats stats;
-
-        public ProcessorStat(String name, String type, Stats stats) {
-            this.name = name;
-            this.type = type;
-            this.stats = stats;
-        }
-
-        public String getName() {
-            return name;
-        }
-
-        public String getType() {
-            return type;
-        }
-
-        public Stats getStats() {
-            return stats;
-        }
-
-        @Override
-        public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
-            ProtobufIngestStats.ProcessorStat that = (ProtobufIngestStats.ProcessorStat) o;
-            return Objects.equals(name, that.name) && Objects.equals(type, that.type) && Objects.equals(stats, that.stats);
-        }
-
-        @Override
-        public int hashCode() {
-            return Objects.hash(name, type, stats);
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/ingest/ProtobufProcessorInfo.java b/server/src/main/java/org/opensearch/ingest/ProtobufProcessorInfo.java
deleted file mode 100644
index 199f21aab12af..0000000000000
--- a/server/src/main/java/org/opensearch/ingest/ProtobufProcessorInfo.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.ingest;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.core.xcontent.ToXContent.Params;
-import org.opensearch.core.xcontent.ToXContentObject;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-
-/**
- * Information about an ingest processor
-*
-* @opensearch.internal
-*/
-public class ProtobufProcessorInfo implements ProtobufWriteable, ToXContentObject {
-
-    private final String type;
-
-    public ProtobufProcessorInfo(String type) {
-        this.type = type;
-    }
-
-    /**
-     * Read from a stream.
-    */
-    public ProtobufProcessorInfo(CodedInputStream input) throws IOException {
-        type = input.readString();
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeStringNoTag(this.type);
-    }
-
-    /**
-     * @return The unique processor type
-    */
-    public String getType() {
-        return type;
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject();
-        builder.field("type", type);
-        builder.endObject();
-        return null;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/monitor/ProtobufMonitorService.java b/server/src/main/java/org/opensearch/monitor/ProtobufMonitorService.java
deleted file mode 100644
index 067ef7c193d0d..0000000000000
--- a/server/src/main/java/org/opensearch/monitor/ProtobufMonitorService.java
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * 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.
- */
-
-package org.opensearch.monitor;
-
-import org.opensearch.common.component.AbstractLifecycleComponent;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.env.NodeEnvironment;
-import org.opensearch.index.store.remote.filecache.FileCache;
-import org.opensearch.monitor.fs.ProtobufFsService;
-import org.opensearch.monitor.jvm.JvmGcMonitorService;
-import org.opensearch.monitor.jvm.ProtobufJvmService;
-import org.opensearch.monitor.os.ProtobufOsService;
-import org.opensearch.monitor.process.ProtobufProcessService;
-import org.opensearch.threadpool.ThreadPool;
-
-import java.io.IOException;
-
-/**
- * The resource monitoring service
- *
- * @opensearch.internal
- */
-public class ProtobufMonitorService extends AbstractLifecycleComponent {
-
-    private final JvmGcMonitorService jvmGcMonitorService;
-    private final ProtobufOsService osService;
-    private final ProtobufProcessService processService;
-    private final ProtobufJvmService jvmService;
-    private final ProtobufFsService fsService;
-
-    public ProtobufMonitorService(Settings settings, NodeEnvironment nodeEnvironment, ThreadPool threadPool, FileCache fileCache)
-        throws IOException {
-        this.jvmGcMonitorService = new JvmGcMonitorService(settings, threadPool);
-        this.osService = new ProtobufOsService(settings);
-        this.processService = new ProtobufProcessService(settings);
-        this.jvmService = new ProtobufJvmService(settings);
-        this.fsService = new ProtobufFsService(settings, nodeEnvironment, fileCache);
-    }
-
-    public ProtobufOsService osService() {
-        return this.osService;
-    }
-
-    public ProtobufProcessService processService() {
-        return this.processService;
-    }
-
-    public ProtobufJvmService jvmService() {
-        return this.jvmService;
-    }
-
-    public ProtobufFsService fsService() {
-        return this.fsService;
-    }
-
-    @Override
-    protected void doStart() {
-        jvmGcMonitorService.start();
-    }
-
-    @Override
-    protected void doStop() {
-        jvmGcMonitorService.stop();
-    }
-
-    @Override
-    protected void doClose() {
-        jvmGcMonitorService.close();
-    }
-
-}
diff --git a/server/src/main/java/org/opensearch/monitor/fs/FsProbe.java b/server/src/main/java/org/opensearch/monitor/fs/FsProbe.java
index c2a31f8a4be8c..e20d84cd9763e 100644
--- a/server/src/main/java/org/opensearch/monitor/fs/FsProbe.java
+++ b/server/src/main/java/org/opensearch/monitor/fs/FsProbe.java
@@ -97,33 +97,6 @@ public FsInfo stats(FsInfo previous) throws IOException {
         return new FsInfo(System.currentTimeMillis(), ioStats, paths);
     }
 
-    public ProtobufFsInfo protobufStats(ProtobufFsInfo previous) throws IOException {
-        if (!nodeEnv.hasNodeFile()) {
-            return new ProtobufFsInfo(System.currentTimeMillis(), null, new ProtobufFsInfo.Path[0]);
-        }
-        NodePath[] dataLocations = nodeEnv.nodePaths();
-        ProtobufFsInfo.Path[] paths = new ProtobufFsInfo.Path[dataLocations.length];
-        for (int i = 0; i < dataLocations.length; i++) {
-            paths[i] = getProtobufFsInfo(dataLocations[i]);
-            if (fileCache != null && dataLocations[i].fileCacheReservedSize != ByteSizeValue.ZERO) {
-                paths[i].fileCacheReserved = adjustForHugeFilesystems(dataLocations[i].fileCacheReservedSize.getBytes());
-                paths[i].fileCacheUtilized = adjustForHugeFilesystems(fileCache.usage().usage());
-                paths[i].available -= (paths[i].fileCacheReserved - paths[i].fileCacheUtilized);
-            }
-        }
-        ProtobufFsInfo.IoStats ioStats = null;
-        if (Constants.LINUX) {
-            Set<Tuple<Integer, Integer>> devicesNumbers = new HashSet<>();
-            for (NodePath dataLocation : dataLocations) {
-                if (dataLocation.majorDeviceNumber != -1 && dataLocation.minorDeviceNumber != -1) {
-                    devicesNumbers.add(Tuple.tuple(dataLocation.majorDeviceNumber, dataLocation.minorDeviceNumber));
-                }
-            }
-            ioStats = protobufIoStats(devicesNumbers, previous);
-        }
-        return new ProtobufFsInfo(System.currentTimeMillis(), ioStats, paths);
-    }
-
     final FsInfo.IoStats ioStats(final Set<Tuple<Integer, Integer>> devicesNumbers, final FsInfo previous) {
         try {
             final Map<Tuple<Integer, Integer>, FsInfo.DeviceStats> deviceMap = new HashMap<>();
@@ -176,58 +149,6 @@ final FsInfo.IoStats ioStats(final Set<Tuple<Integer, Integer>> devicesNumbers,
         }
     }
 
-    final ProtobufFsInfo.IoStats protobufIoStats(final Set<Tuple<Integer, Integer>> devicesNumbers, final ProtobufFsInfo previous) {
-        try {
-            final Map<Tuple<Integer, Integer>, ProtobufFsInfo.DeviceStats> deviceMap = new HashMap<>();
-            if (previous != null && previous.getIoStats() != null && previous.getIoStats().devicesStats != null) {
-                for (int i = 0; i < previous.getIoStats().devicesStats.length; i++) {
-                    ProtobufFsInfo.DeviceStats deviceStats = previous.getIoStats().devicesStats[i];
-                    deviceMap.put(Tuple.tuple(deviceStats.majorDeviceNumber, deviceStats.minorDeviceNumber), deviceStats);
-                }
-            }
-
-            List<ProtobufFsInfo.DeviceStats> devicesStats = new ArrayList<>();
-
-            List<String> lines = readProcDiskStats();
-            if (!lines.isEmpty()) {
-                for (String line : lines) {
-                    String fields[] = line.trim().split("\\s+");
-                    final int majorDeviceNumber = Integer.parseInt(fields[0]);
-                    final int minorDeviceNumber = Integer.parseInt(fields[1]);
-                    if (!devicesNumbers.contains(Tuple.tuple(majorDeviceNumber, minorDeviceNumber))) {
-                        continue;
-                    }
-                    final String deviceName = fields[2];
-                    final long readsCompleted = Long.parseLong(fields[3]);
-                    final long sectorsRead = Long.parseLong(fields[5]);
-                    final long writesCompleted = Long.parseLong(fields[7]);
-                    final long sectorsWritten = Long.parseLong(fields[9]);
-                    final ProtobufFsInfo.DeviceStats deviceStats = new ProtobufFsInfo.DeviceStats(
-                        majorDeviceNumber,
-                        minorDeviceNumber,
-                        deviceName,
-                        readsCompleted,
-                        sectorsRead,
-                        writesCompleted,
-                        sectorsWritten,
-                        deviceMap.get(Tuple.tuple(majorDeviceNumber, minorDeviceNumber))
-                    );
-                    devicesStats.add(deviceStats);
-                }
-            }
-
-            return new ProtobufFsInfo.IoStats(devicesStats.toArray(new ProtobufFsInfo.DeviceStats[0]));
-        } catch (Exception e) {
-            // do not fail Elasticsearch if something unexpected
-            // happens here
-            logger.debug(
-                () -> new ParameterizedMessage("unexpected exception processing /proc/diskstats for devices {}", devicesNumbers),
-                e
-            );
-            return null;
-        }
-    }
-
     @SuppressForbidden(reason = "read /proc/diskstats")
     List<String> readProcDiskStats() throws IOException {
         return Files.readAllLines(PathUtils.get("/proc/diskstats"));
@@ -261,20 +182,4 @@ public static FsInfo.Path getFSInfo(NodePath nodePath) throws IOException {
         return fsPath;
     }
 
-    public static ProtobufFsInfo.Path getProtobufFsInfo(NodePath nodePath) throws IOException {
-        ProtobufFsInfo.Path fsPath = new ProtobufFsInfo.Path();
-        fsPath.path = nodePath.path.toString();
-
-        // NOTE: we use already cached (on node startup) FileStore and spins
-        // since recomputing these once per second (default) could be costly,
-        // and they should not change:
-        fsPath.total = adjustForHugeFilesystems(nodePath.fileStore.getTotalSpace());
-        fsPath.free = adjustForHugeFilesystems(nodePath.fileStore.getUnallocatedSpace());
-        fsPath.available = adjustForHugeFilesystems(nodePath.fileStore.getUsableSpace());
-        fsPath.fileCacheReserved = adjustForHugeFilesystems(nodePath.fileCacheReservedSize.getBytes());
-        fsPath.type = nodePath.fileStore.type();
-        fsPath.mount = nodePath.fileStore.toString();
-        return fsPath;
-    }
-
 }
diff --git a/server/src/main/java/org/opensearch/monitor/fs/ProtobufFsInfo.java b/server/src/main/java/org/opensearch/monitor/fs/ProtobufFsInfo.java
deleted file mode 100644
index 88fb93b8bc7da..0000000000000
--- a/server/src/main/java/org/opensearch/monitor/fs/ProtobufFsInfo.java
+++ /dev/null
@@ -1,554 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.monitor.fs;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.Version;
-import org.opensearch.common.Nullable;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.ToXContentObject;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Set;
-
-/**
- * FileSystem information
-*
-* @opensearch.internal
-*/
-public class ProtobufFsInfo implements Iterable<ProtobufFsInfo.Path>, ProtobufWriteable, ToXContentFragment {
-
-    /**
-     * Path for the file system
-    *
-    * @opensearch.internal
-    */
-    public static class Path implements ProtobufWriteable, ToXContentObject {
-
-        String path;
-        @Nullable
-        String mount;
-        /** File system type from {@code java.nio.file.FileStore type()}, if available. */
-        @Nullable
-        String type;
-        long total = -1;
-        long free = -1;
-        long available = -1;
-        long fileCacheReserved = -1;
-        long fileCacheUtilized = 0;
-
-        public Path() {}
-
-        public Path(String path, @Nullable String mount, long total, long free, long available) {
-            this.path = path;
-            this.mount = mount;
-            this.total = total;
-            this.free = free;
-            this.available = available;
-        }
-
-        /**
-         * Read from a stream.
-        */
-        public Path(CodedInputStream in) throws IOException {
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-            path = protobufStreamInput.readOptionalString();
-            mount = protobufStreamInput.readOptionalString();
-            type = protobufStreamInput.readOptionalString();
-            total = in.readInt64();
-            free = in.readInt64();
-            available = in.readInt64();
-            if (protobufStreamInput.getVersion().onOrAfter(Version.V_2_7_0)) {
-                fileCacheReserved = in.readInt64();
-                fileCacheUtilized = in.readInt64();
-            }
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            protobufStreamOutput.writeOptionalString(path); // total aggregates do not have a path
-            protobufStreamOutput.writeOptionalString(mount);
-            protobufStreamOutput.writeOptionalString(type);
-            out.writeInt64NoTag(total);
-            out.writeInt64NoTag(free);
-            out.writeInt64NoTag(available);
-            if (protobufStreamOutput.getVersion().onOrAfter(Version.V_2_7_0)) {
-                out.writeInt64NoTag(fileCacheReserved);
-                out.writeInt64NoTag(fileCacheUtilized);
-            }
-        }
-
-        public String getPath() {
-            return path;
-        }
-
-        public String getMount() {
-            return mount;
-        }
-
-        public String getType() {
-            return type;
-        }
-
-        public ByteSizeValue getTotal() {
-            return new ByteSizeValue(total);
-        }
-
-        public ByteSizeValue getFree() {
-            return new ByteSizeValue(free);
-        }
-
-        public ByteSizeValue getAvailable() {
-            return new ByteSizeValue(available);
-        }
-
-        public ByteSizeValue getFileCacheReserved() {
-            return new ByteSizeValue(fileCacheReserved);
-        }
-
-        public ByteSizeValue getFileCacheUtilized() {
-            return new ByteSizeValue(fileCacheUtilized);
-        }
-
-        private long addLong(long current, long other) {
-            if (current == -1 && other == -1) {
-                return 0;
-            }
-            if (other == -1) {
-                return current;
-            }
-            if (current == -1) {
-                return other;
-            }
-            return current + other;
-        }
-
-        public void add(Path path) {
-            total = FsProbe.adjustForHugeFilesystems(addLong(total, path.total));
-            free = FsProbe.adjustForHugeFilesystems(addLong(free, path.free));
-            fileCacheReserved = FsProbe.adjustForHugeFilesystems(addLong(fileCacheReserved, path.fileCacheReserved));
-            fileCacheUtilized = FsProbe.adjustForHugeFilesystems(addLong(fileCacheUtilized, path.fileCacheUtilized));
-            available = FsProbe.adjustForHugeFilesystems(addLong(available, path.available));
-        }
-
-        static final class Fields {
-            static final String PATH = "path";
-            static final String MOUNT = "mount";
-            static final String TYPE = "type";
-            static final String TOTAL = "total";
-            static final String TOTAL_IN_BYTES = "total_in_bytes";
-            static final String FREE = "free";
-            static final String FREE_IN_BYTES = "free_in_bytes";
-            static final String AVAILABLE = "available";
-            static final String AVAILABLE_IN_BYTES = "available_in_bytes";
-            static final String CACHE_RESERVED = "cache_reserved";
-            static final String CACHE_RESERVED_IN_BYTES = "cache_reserved_in_bytes";
-            static final String CACHE_UTILIZED = "cache_utilized";
-            static final String CACHE_UTILIZED_IN_BYTES = "cache_utilized_in_bytes";
-        }
-
-        @Override
-        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-            builder.startObject();
-            if (path != null) {
-                builder.field(Fields.PATH, path);
-            }
-            if (mount != null) {
-                builder.field(Fields.MOUNT, mount);
-            }
-            if (type != null) {
-                builder.field(Fields.TYPE, type);
-            }
-
-            if (total != -1) {
-                builder.humanReadableField(Fields.TOTAL_IN_BYTES, Fields.TOTAL, getTotal());
-            }
-            if (free != -1) {
-                builder.humanReadableField(Fields.FREE_IN_BYTES, Fields.FREE, getFree());
-            }
-            if (available != -1) {
-                builder.humanReadableField(Fields.AVAILABLE_IN_BYTES, Fields.AVAILABLE, getAvailable());
-            }
-            if (fileCacheReserved != -1) {
-                builder.humanReadableField(Fields.CACHE_RESERVED_IN_BYTES, Fields.CACHE_RESERVED, getFileCacheReserved());
-            }
-            if (fileCacheReserved != 0) {
-                builder.humanReadableField(Fields.CACHE_UTILIZED, Fields.CACHE_UTILIZED_IN_BYTES, getFileCacheUtilized());
-            }
-
-            builder.endObject();
-            return builder;
-        }
-    }
-
-    /**
-     * The device status.
-    *
-    * @opensearch.internal
-    */
-    public static class DeviceStats implements ProtobufWriteable, ToXContentFragment {
-
-        final int majorDeviceNumber;
-        final int minorDeviceNumber;
-        final String deviceName;
-        final long currentReadsCompleted;
-        final long previousReadsCompleted;
-        final long currentSectorsRead;
-        final long previousSectorsRead;
-        final long currentWritesCompleted;
-        final long previousWritesCompleted;
-        final long currentSectorsWritten;
-        final long previousSectorsWritten;
-
-        public DeviceStats(
-            final int majorDeviceNumber,
-            final int minorDeviceNumber,
-            final String deviceName,
-            final long currentReadsCompleted,
-            final long currentSectorsRead,
-            final long currentWritesCompleted,
-            final long currentSectorsWritten,
-            final DeviceStats previousDeviceStats
-        ) {
-            this(
-                majorDeviceNumber,
-                minorDeviceNumber,
-                deviceName,
-                currentReadsCompleted,
-                previousDeviceStats != null ? previousDeviceStats.currentReadsCompleted : -1,
-                currentSectorsWritten,
-                previousDeviceStats != null ? previousDeviceStats.currentSectorsWritten : -1,
-                currentSectorsRead,
-                previousDeviceStats != null ? previousDeviceStats.currentSectorsRead : -1,
-                currentWritesCompleted,
-                previousDeviceStats != null ? previousDeviceStats.currentWritesCompleted : -1
-            );
-        }
-
-        private DeviceStats(
-            final int majorDeviceNumber,
-            final int minorDeviceNumber,
-            final String deviceName,
-            final long currentReadsCompleted,
-            final long previousReadsCompleted,
-            final long currentSectorsWritten,
-            final long previousSectorsWritten,
-            final long currentSectorsRead,
-            final long previousSectorsRead,
-            final long currentWritesCompleted,
-            final long previousWritesCompleted
-        ) {
-            this.majorDeviceNumber = majorDeviceNumber;
-            this.minorDeviceNumber = minorDeviceNumber;
-            this.deviceName = deviceName;
-            this.currentReadsCompleted = currentReadsCompleted;
-            this.previousReadsCompleted = previousReadsCompleted;
-            this.currentWritesCompleted = currentWritesCompleted;
-            this.previousWritesCompleted = previousWritesCompleted;
-            this.currentSectorsRead = currentSectorsRead;
-            this.previousSectorsRead = previousSectorsRead;
-            this.currentSectorsWritten = currentSectorsWritten;
-            this.previousSectorsWritten = previousSectorsWritten;
-        }
-
-        public DeviceStats(CodedInputStream in) throws IOException {
-            majorDeviceNumber = in.readInt32();
-            minorDeviceNumber = in.readInt32();
-            deviceName = in.readString();
-            currentReadsCompleted = in.readInt64();
-            previousReadsCompleted = in.readInt64();
-            currentWritesCompleted = in.readInt64();
-            previousWritesCompleted = in.readInt64();
-            currentSectorsRead = in.readInt64();
-            previousSectorsRead = in.readInt64();
-            currentSectorsWritten = in.readInt64();
-            previousSectorsWritten = in.readInt64();
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeInt32NoTag(majorDeviceNumber);
-            out.writeInt32NoTag(minorDeviceNumber);
-            out.writeStringNoTag(deviceName);
-            out.writeInt64NoTag(currentReadsCompleted);
-            out.writeInt64NoTag(previousReadsCompleted);
-            out.writeInt64NoTag(currentWritesCompleted);
-            out.writeInt64NoTag(previousWritesCompleted);
-            out.writeInt64NoTag(currentSectorsRead);
-            out.writeInt64NoTag(previousSectorsRead);
-            out.writeInt64NoTag(currentSectorsWritten);
-            out.writeInt64NoTag(previousSectorsWritten);
-        }
-
-        public long operations() {
-            if (previousReadsCompleted == -1 || previousWritesCompleted == -1) return -1;
-
-            return (currentReadsCompleted - previousReadsCompleted) + (currentWritesCompleted - previousWritesCompleted);
-        }
-
-        public long readOperations() {
-            if (previousReadsCompleted == -1) return -1;
-
-            return (currentReadsCompleted - previousReadsCompleted);
-        }
-
-        public long writeOperations() {
-            if (previousWritesCompleted == -1) return -1;
-
-            return (currentWritesCompleted - previousWritesCompleted);
-        }
-
-        public long readKilobytes() {
-            if (previousSectorsRead == -1) return -1;
-
-            return (currentSectorsRead - previousSectorsRead) / 2;
-        }
-
-        public long writeKilobytes() {
-            if (previousSectorsWritten == -1) return -1;
-
-            return (currentSectorsWritten - previousSectorsWritten) / 2;
-        }
-
-        @Override
-        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-            builder.field("device_name", deviceName);
-            builder.field(IoStats.OPERATIONS, operations());
-            builder.field(IoStats.READ_OPERATIONS, readOperations());
-            builder.field(IoStats.WRITE_OPERATIONS, writeOperations());
-            builder.field(IoStats.READ_KILOBYTES, readKilobytes());
-            builder.field(IoStats.WRITE_KILOBYTES, writeKilobytes());
-            return builder;
-        }
-
-    }
-
-    /**
-     * The I/O statistics.
-    *
-    * @opensearch.internal
-    */
-    public static class IoStats implements ProtobufWriteable, ToXContentFragment {
-
-        private static final String OPERATIONS = "operations";
-        private static final String READ_OPERATIONS = "read_operations";
-        private static final String WRITE_OPERATIONS = "write_operations";
-        private static final String READ_KILOBYTES = "read_kilobytes";
-        private static final String WRITE_KILOBYTES = "write_kilobytes";
-
-        final DeviceStats[] devicesStats;
-        final long totalOperations;
-        final long totalReadOperations;
-        final long totalWriteOperations;
-        final long totalReadKilobytes;
-        final long totalWriteKilobytes;
-
-        public IoStats(final DeviceStats[] devicesStats) {
-            this.devicesStats = devicesStats;
-            long totalOperations = 0;
-            long totalReadOperations = 0;
-            long totalWriteOperations = 0;
-            long totalReadKilobytes = 0;
-            long totalWriteKilobytes = 0;
-            for (DeviceStats deviceStats : devicesStats) {
-                totalOperations += deviceStats.operations() != -1 ? deviceStats.operations() : 0;
-                totalReadOperations += deviceStats.readOperations() != -1 ? deviceStats.readOperations() : 0;
-                totalWriteOperations += deviceStats.writeOperations() != -1 ? deviceStats.writeOperations() : 0;
-                totalReadKilobytes += deviceStats.readKilobytes() != -1 ? deviceStats.readKilobytes() : 0;
-                totalWriteKilobytes += deviceStats.writeKilobytes() != -1 ? deviceStats.writeKilobytes() : 0;
-            }
-            this.totalOperations = totalOperations;
-            this.totalReadOperations = totalReadOperations;
-            this.totalWriteOperations = totalWriteOperations;
-            this.totalReadKilobytes = totalReadKilobytes;
-            this.totalWriteKilobytes = totalWriteKilobytes;
-        }
-
-        public IoStats(CodedInputStream in) throws IOException {
-            final int length = in.readInt32();
-            final DeviceStats[] devicesStats = new DeviceStats[length];
-            for (int i = 0; i < length; i++) {
-                devicesStats[i] = new DeviceStats(in);
-            }
-            this.devicesStats = devicesStats;
-            this.totalOperations = in.readInt64();
-            this.totalReadOperations = in.readInt64();
-            this.totalWriteOperations = in.readInt64();
-            this.totalReadKilobytes = in.readInt64();
-            this.totalWriteKilobytes = in.readInt64();
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeInt32NoTag(devicesStats.length);
-            for (int i = 0; i < devicesStats.length; i++) {
-                devicesStats[i].writeTo(out);
-            }
-            out.writeInt64NoTag(totalOperations);
-            out.writeInt64NoTag(totalReadOperations);
-            out.writeInt64NoTag(totalWriteOperations);
-            out.writeInt64NoTag(totalReadKilobytes);
-            out.writeInt64NoTag(totalWriteKilobytes);
-        }
-
-        public DeviceStats[] getDevicesStats() {
-            return devicesStats;
-        }
-
-        public long getTotalOperations() {
-            return totalOperations;
-        }
-
-        public long getTotalReadOperations() {
-            return totalReadOperations;
-        }
-
-        public long getTotalWriteOperations() {
-            return totalWriteOperations;
-        }
-
-        public long getTotalReadKilobytes() {
-            return totalReadKilobytes;
-        }
-
-        public long getTotalWriteKilobytes() {
-            return totalWriteKilobytes;
-        }
-
-        @Override
-        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-            if (devicesStats.length > 0) {
-                builder.startArray("devices");
-                for (DeviceStats deviceStats : devicesStats) {
-                    builder.startObject();
-                    deviceStats.toXContent(builder, params);
-                    builder.endObject();
-                }
-                builder.endArray();
-
-                builder.startObject("total");
-                builder.field(OPERATIONS, totalOperations);
-                builder.field(READ_OPERATIONS, totalReadOperations);
-                builder.field(WRITE_OPERATIONS, totalWriteOperations);
-                builder.field(READ_KILOBYTES, totalReadKilobytes);
-                builder.field(WRITE_KILOBYTES, totalWriteKilobytes);
-                builder.endObject();
-            }
-            return builder;
-        }
-
-    }
-
-    private final long timestamp;
-    private final Path[] paths;
-    private final IoStats ioStats;
-    private final Path total;
-
-    public ProtobufFsInfo(long timestamp, IoStats ioStats, Path[] paths) {
-        this.timestamp = timestamp;
-        this.ioStats = ioStats;
-        this.paths = paths;
-        this.total = total();
-    }
-
-    /**
-     * Read from a stream.
-    */
-    public ProtobufFsInfo(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        timestamp = in.readInt64();
-        ioStats = protobufStreamInput.readOptionalWriteable(IoStats::new);
-        paths = new Path[in.readInt32()];
-        for (int i = 0; i < paths.length; i++) {
-            paths[i] = new Path(in);
-        }
-        this.total = total();
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeInt64NoTag(timestamp);
-        protobufStreamOutput.writeOptionalWriteable(ioStats);
-        out.writeInt32NoTag(paths.length);
-        for (Path path : paths) {
-            path.writeTo(out);
-        }
-    }
-
-    public Path getTotal() {
-        return total;
-    }
-
-    private Path total() {
-        Path res = new Path();
-        Set<String> seenDevices = new HashSet<>(paths.length);
-        for (Path subPath : paths) {
-            if (subPath.path != null) {
-                if (!seenDevices.add(subPath.path)) {
-                    continue; // already added numbers for this device;
-                }
-            }
-            res.add(subPath);
-        }
-        return res;
-    }
-
-    public long getTimestamp() {
-        return timestamp;
-    }
-
-    public IoStats getIoStats() {
-        return ioStats;
-    }
-
-    @Override
-    public Iterator<Path> iterator() {
-        return Arrays.stream(paths).iterator();
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.FS);
-        builder.field(Fields.TIMESTAMP, timestamp);
-        builder.field(Fields.TOTAL);
-        total().toXContent(builder, params);
-
-        builder.startArray(Fields.DATA);
-        for (Path path : paths) {
-            path.toXContent(builder, params);
-        }
-        builder.endArray();
-        if (ioStats != null) {
-            builder.startObject(Fields.IO_STATS);
-            ioStats.toXContent(builder, params);
-            builder.endObject();
-        }
-        builder.endObject();
-        return builder;
-    }
-
-    static final class Fields {
-        static final String FS = "fs";
-        static final String TIMESTAMP = "timestamp";
-        static final String DATA = "data";
-        static final String TOTAL = "total";
-        static final String IO_STATS = "io_stats";
-    }
-}
diff --git a/server/src/main/java/org/opensearch/monitor/fs/ProtobufFsService.java b/server/src/main/java/org/opensearch/monitor/fs/ProtobufFsService.java
deleted file mode 100644
index e959d2a46293b..0000000000000
--- a/server/src/main/java/org/opensearch/monitor/fs/ProtobufFsService.java
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * 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.
- */
-
-package org.opensearch.monitor.fs;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.opensearch.common.settings.Setting;
-import org.opensearch.common.settings.Setting.Property;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.common.util.SingleObjectCache;
-import org.opensearch.env.NodeEnvironment;
-import org.opensearch.index.store.remote.filecache.FileCache;
-
-import java.io.IOException;
-import java.util.function.Supplier;
-
-/**
- * FileSystem service
- *
- * @opensearch.internal
- */
-public class ProtobufFsService {
-
-    private static final Logger logger = LogManager.getLogger(ProtobufFsService.class);
-
-    private final Supplier<ProtobufFsInfo> fsInfoSupplier;
-
-    public static final Setting<TimeValue> REFRESH_INTERVAL_SETTING = Setting.timeSetting(
-        "monitor.fs.refresh_interval",
-        TimeValue.timeValueSeconds(1),
-        TimeValue.timeValueSeconds(1),
-        Property.NodeScope
-    );
-
-    // permits tests to bypass the refresh interval on the cache; deliberately unregistered since it is only for use in tests
-    public static final Setting<Boolean> ALWAYS_REFRESH_SETTING = Setting.boolSetting(
-        "monitor.fs.always_refresh",
-        false,
-        Property.NodeScope
-    );
-
-    public ProtobufFsService(final Settings settings, final NodeEnvironment nodeEnvironment, FileCache fileCache) {
-        final FsProbe probe = new FsProbe(nodeEnvironment, fileCache);
-        final ProtobufFsInfo initialValue = stats(probe, null);
-        if (ALWAYS_REFRESH_SETTING.get(settings)) {
-            assert REFRESH_INTERVAL_SETTING.exists(settings) == false;
-            logger.debug("bypassing refresh_interval");
-            fsInfoSupplier = () -> stats(probe, initialValue);
-        } else {
-            final TimeValue refreshInterval = REFRESH_INTERVAL_SETTING.get(settings);
-            logger.debug("using refresh_interval [{}]", refreshInterval);
-            fsInfoSupplier = new FsInfoCache(refreshInterval, initialValue, probe)::getOrRefresh;
-        }
-    }
-
-    public ProtobufFsInfo stats() {
-        return fsInfoSupplier.get();
-    }
-
-    private static ProtobufFsInfo stats(FsProbe probe, ProtobufFsInfo initialValue) {
-        try {
-            return probe.protobufStats(initialValue);
-        } catch (IOException e) {
-            logger.debug("unexpected exception reading filesystem info", e);
-            return null;
-        }
-    }
-
-    private static class FsInfoCache extends SingleObjectCache<ProtobufFsInfo> {
-
-        private final ProtobufFsInfo initialValue;
-        private final FsProbe probe;
-
-        FsInfoCache(TimeValue interval, ProtobufFsInfo initialValue, FsProbe probe) {
-            super(interval, initialValue);
-            this.initialValue = initialValue;
-            this.probe = probe;
-        }
-
-        @Override
-        protected ProtobufFsInfo refresh() {
-            return stats(probe, initialValue);
-        }
-
-    }
-
-}
diff --git a/server/src/main/java/org/opensearch/monitor/jvm/JvmInfo.java b/server/src/main/java/org/opensearch/monitor/jvm/JvmInfo.java
index 5ca0ff8ed1809..747c96073c04a 100644
--- a/server/src/main/java/org/opensearch/monitor/jvm/JvmInfo.java
+++ b/server/src/main/java/org/opensearch/monitor/jvm/JvmInfo.java
@@ -36,8 +36,6 @@
 import org.opensearch.common.Booleans;
 import org.opensearch.common.SuppressForbidden;
 import org.opensearch.common.io.PathUtils;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
@@ -68,7 +66,7 @@
  *
  * @opensearch.internal
  */
-public class JvmInfo implements ReportingService.Info, ProtobufReportingService.ProtobufInfo {
+public class JvmInfo implements ReportingService.Info {
 
     private static JvmInfo INSTANCE;
 
@@ -363,65 +361,6 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeString(useCompressedOops);
     }
 
-    public JvmInfo(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        pid = in.readInt64();
-        version = in.readString();
-        vmName = in.readString();
-        vmVersion = in.readString();
-        vmVendor = in.readString();
-        bundledJdk = in.readBool();
-        usingBundledJdk = protobufStreamInput.readOptionalBoolean();
-        startTime = in.readInt64();
-        inputArguments = new String[in.readInt32()];
-        for (int i = 0; i < inputArguments.length; i++) {
-            inputArguments[i] = in.readString();
-        }
-        bootClassPath = in.readString();
-        classPath = in.readString();
-        systemProperties = protobufStreamInput.readMap(CodedInputStream::readString, CodedInputStream::readString);
-        mem = new Mem(in);
-        gcCollectors = protobufStreamInput.readStringArray();
-        memoryPools = protobufStreamInput.readStringArray();
-        useCompressedOops = in.readString();
-        // the following members are only used locally for bootstrap checks, never serialized nor printed out
-        this.configuredMaxHeapSize = -1;
-        this.configuredInitialHeapSize = -1;
-        this.onError = null;
-        this.onOutOfMemoryError = null;
-        this.useG1GC = "unknown";
-        this.useSerialGC = "unknown";
-        this.g1RegionSize = -1;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeInt64NoTag(pid);
-        out.writeStringNoTag(version);
-        out.writeStringNoTag(vmName);
-        out.writeStringNoTag(vmVersion);
-        out.writeStringNoTag(vmVendor);
-        out.writeBoolNoTag(bundledJdk);
-        protobufStreamOutput.writeOptionalBoolean(usingBundledJdk);
-        out.writeInt64NoTag(startTime);
-        out.writeInt32NoTag(inputArguments.length);
-        for (String inputArgument : inputArguments) {
-            out.writeStringNoTag(inputArgument);
-        }
-        out.writeStringNoTag(bootClassPath);
-        out.writeStringNoTag(classPath);
-        out.writeInt32NoTag(this.systemProperties.size());
-        for (Map.Entry<String, String> entry : systemProperties.entrySet()) {
-            out.writeStringNoTag(entry.getKey());
-            out.writeStringNoTag(entry.getValue());
-        }
-        mem.writeTo(out);
-        protobufStreamOutput.writeStringArray(gcCollectors);
-        protobufStreamOutput.writeStringArray(memoryPools);
-        out.writeStringNoTag(useCompressedOops);
-    }
-
     /**
      * The process id.
      */
@@ -663,7 +602,7 @@ static final class Fields {
      *
      * @opensearch.internal
      */
-    public static class Mem implements Writeable, ProtobufWriteable {
+    public static class Mem implements Writeable {
 
         private final long heapInit;
         private final long heapMax;
@@ -696,23 +635,6 @@ public void writeTo(StreamOutput out) throws IOException {
             out.writeVLong(directMemoryMax);
         }
 
-        public Mem(CodedInputStream in) throws IOException {
-            this.heapInit = in.readInt64();
-            this.heapMax = in.readInt64();
-            this.nonHeapInit = in.readInt64();
-            this.nonHeapMax = in.readInt64();
-            this.directMemoryMax = in.readInt64();
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeInt64NoTag(heapInit);
-            out.writeInt64NoTag(heapMax);
-            out.writeInt64NoTag(nonHeapInit);
-            out.writeInt64NoTag(nonHeapMax);
-            out.writeInt64NoTag(directMemoryMax);
-        }
-
         public ByteSizeValue getHeapInit() {
             return new ByteSizeValue(heapInit);
         }
diff --git a/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java b/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java
deleted file mode 100644
index 96b8320fc6c53..0000000000000
--- a/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmInfo.java
+++ /dev/null
@@ -1,684 +0,0 @@
-/*
- * 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.
- */
-
-package org.opensearch.monitor.jvm;
-
-import org.apache.lucene.util.Constants;
-import org.opensearch.common.Booleans;
-import org.opensearch.common.SuppressForbidden;
-import org.opensearch.common.io.PathUtils;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.io.stream.StreamInput;
-import org.opensearch.common.io.stream.StreamOutput;
-import org.opensearch.common.io.stream.Writeable;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.node.ProtobufReportingService;
-import org.opensearch.node.ReportingService;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
-import java.io.IOException;
-import java.lang.management.GarbageCollectorMXBean;
-import java.lang.management.ManagementFactory;
-import java.lang.management.ManagementPermission;
-import java.lang.management.MemoryMXBean;
-import java.lang.management.MemoryPoolMXBean;
-import java.lang.management.PlatformManagedObject;
-import java.lang.management.RuntimeMXBean;
-import java.lang.reflect.Method;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Holds information about the JVM
- *
- * @opensearch.internal
- */
-public class ProtobufJvmInfo implements ProtobufReportingService.ProtobufInfo {
-
-    private static ProtobufJvmInfo INSTANCE;
-
-    static {
-        RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
-        MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
-
-        long heapInit = memoryMXBean.getHeapMemoryUsage().getInit() < 0 ? 0 : memoryMXBean.getHeapMemoryUsage().getInit();
-        long heapMax = memoryMXBean.getHeapMemoryUsage().getMax() < 0 ? 0 : memoryMXBean.getHeapMemoryUsage().getMax();
-        long nonHeapInit = memoryMXBean.getNonHeapMemoryUsage().getInit() < 0 ? 0 : memoryMXBean.getNonHeapMemoryUsage().getInit();
-        long nonHeapMax = memoryMXBean.getNonHeapMemoryUsage().getMax() < 0 ? 0 : memoryMXBean.getNonHeapMemoryUsage().getMax();
-        long directMemoryMax = 0;
-        try {
-            Class<?> vmClass = Class.forName("sun.misc.VM");
-            directMemoryMax = (Long) vmClass.getMethod("maxDirectMemory").invoke(null);
-        } catch (Exception t) {
-            // ignore
-        }
-        String[] inputArguments = runtimeMXBean.getInputArguments().toArray(new String[0]);
-        Mem mem = new Mem(heapInit, heapMax, nonHeapInit, nonHeapMax, directMemoryMax);
-
-        String bootClassPath;
-        try {
-            bootClassPath = runtimeMXBean.getBootClassPath();
-        } catch (UnsupportedOperationException e) {
-            // oracle java 9
-            bootClassPath = System.getProperty("sun.boot.class.path");
-            if (bootClassPath == null) {
-                // something else
-                bootClassPath = "<unknown>";
-            }
-        }
-        String classPath = runtimeMXBean.getClassPath();
-        Map<String, String> systemProperties = Collections.unmodifiableMap(runtimeMXBean.getSystemProperties());
-
-        List<GarbageCollectorMXBean> gcMxBeans = ManagementFactory.getGarbageCollectorMXBeans();
-        String[] gcCollectors = new String[gcMxBeans.size()];
-        for (int i = 0; i < gcMxBeans.size(); i++) {
-            GarbageCollectorMXBean gcMxBean = gcMxBeans.get(i);
-            gcCollectors[i] = gcMxBean.getName();
-        }
-
-        List<MemoryPoolMXBean> memoryPoolMXBeans = ManagementFactory.getMemoryPoolMXBeans();
-        String[] memoryPools = new String[memoryPoolMXBeans.size()];
-        for (int i = 0; i < memoryPoolMXBeans.size(); i++) {
-            MemoryPoolMXBean memoryPoolMXBean = memoryPoolMXBeans.get(i);
-            memoryPools[i] = memoryPoolMXBean.getName();
-        }
-
-        String onError = null;
-        String onOutOfMemoryError = null;
-        String useCompressedOops = "unknown";
-        String useG1GC = "unknown";
-        long g1RegisionSize = -1;
-        String useSerialGC = "unknown";
-        long configuredInitialHeapSize = -1;
-        long configuredMaxHeapSize = -1;
-        try {
-            @SuppressWarnings("unchecked")
-            Class<? extends PlatformManagedObject> clazz = (Class<? extends PlatformManagedObject>) Class.forName(
-                "com.sun.management.HotSpotDiagnosticMXBean"
-            );
-            Class<?> vmOptionClazz = Class.forName("com.sun.management.VMOption");
-            PlatformManagedObject hotSpotDiagnosticMXBean = ManagementFactory.getPlatformMXBean(clazz);
-            Method vmOptionMethod = clazz.getMethod("getVMOption", String.class);
-            Method valueMethod = vmOptionClazz.getMethod("getValue");
-
-            try {
-                Object onErrorObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "OnError");
-                onError = (String) valueMethod.invoke(onErrorObject);
-            } catch (Exception ignored) {}
-
-            try {
-                Object onOutOfMemoryErrorObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "OnOutOfMemoryError");
-                onOutOfMemoryError = (String) valueMethod.invoke(onOutOfMemoryErrorObject);
-            } catch (Exception ignored) {}
-
-            try {
-                Object useCompressedOopsVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "UseCompressedOops");
-                useCompressedOops = (String) valueMethod.invoke(useCompressedOopsVmOptionObject);
-            } catch (Exception ignored) {}
-
-            try {
-                Object useG1GCVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "UseG1GC");
-                useG1GC = (String) valueMethod.invoke(useG1GCVmOptionObject);
-                Object regionSizeVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "G1HeapRegionSize");
-                g1RegisionSize = Long.parseLong((String) valueMethod.invoke(regionSizeVmOptionObject));
-            } catch (Exception ignored) {}
-
-            try {
-                Object initialHeapSizeVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "InitialHeapSize");
-                configuredInitialHeapSize = Long.parseLong((String) valueMethod.invoke(initialHeapSizeVmOptionObject));
-            } catch (Exception ignored) {}
-
-            try {
-                Object maxHeapSizeVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "MaxHeapSize");
-                configuredMaxHeapSize = Long.parseLong((String) valueMethod.invoke(maxHeapSizeVmOptionObject));
-            } catch (Exception ignored) {}
-
-            try {
-                Object useSerialGCVmOptionObject = vmOptionMethod.invoke(hotSpotDiagnosticMXBean, "UseSerialGC");
-                useSerialGC = (String) valueMethod.invoke(useSerialGCVmOptionObject);
-            } catch (Exception ignored) {}
-
-        } catch (Exception ignored) {
-
-        }
-
-        final boolean bundledJdk = Booleans.parseBoolean(System.getProperty("opensearch.bundled_jdk", Boolean.FALSE.toString()));
-        final Boolean usingBundledJdk = bundledJdk ? usingBundledJdk() : null;
-
-        INSTANCE = new ProtobufJvmInfo(
-            JvmPid.getPid(),
-            System.getProperty("java.version"),
-            runtimeMXBean.getVmName(),
-            runtimeMXBean.getVmVersion(),
-            runtimeMXBean.getVmVendor(),
-            bundledJdk,
-            usingBundledJdk,
-            runtimeMXBean.getStartTime(),
-            configuredInitialHeapSize,
-            configuredMaxHeapSize,
-            mem,
-            inputArguments,
-            bootClassPath,
-            classPath,
-            systemProperties,
-            gcCollectors,
-            memoryPools,
-            onError,
-            onOutOfMemoryError,
-            useCompressedOops,
-            useG1GC,
-            useSerialGC,
-            g1RegisionSize
-        );
-    }
-
-    @SuppressForbidden(reason = "PathUtils#get")
-    private static boolean usingBundledJdk() {
-        /*
-         * We are using the bundled JDK if java.home is the jdk sub-directory of our working directory. This is because we always set
-         * the working directory of Elasticsearch to home, and the bundled JDK is in the jdk sub-directory there.
-         */
-        final String javaHome = System.getProperty("java.home");
-        final String userDir = System.getProperty("user.dir");
-        if (Constants.MAC_OS_X) {
-            return PathUtils.get(javaHome).equals(PathUtils.get(userDir).resolve("jdk.app/Contents/Home").toAbsolutePath());
-        } else {
-            return PathUtils.get(javaHome).equals(PathUtils.get(userDir).resolve("jdk").toAbsolutePath());
-        }
-    }
-
-    public static ProtobufJvmInfo jvmInfo() {
-        SecurityManager sm = System.getSecurityManager();
-        if (sm != null) {
-            sm.checkPermission(new ManagementPermission("monitor"));
-            sm.checkPropertyAccess("*");
-        }
-        return INSTANCE;
-    }
-
-    private final long pid;
-    private final String version;
-    private final String vmName;
-    private final String vmVersion;
-    private final String vmVendor;
-    private final boolean bundledJdk;
-    private final Boolean usingBundledJdk;
-    private final long startTime;
-    private final long configuredInitialHeapSize;
-    private final long configuredMaxHeapSize;
-    private final Mem mem;
-    private final String[] inputArguments;
-    private final String bootClassPath;
-    private final String classPath;
-    private final Map<String, String> systemProperties;
-    private final String[] gcCollectors;
-    private final String[] memoryPools;
-    private final String onError;
-    private final String onOutOfMemoryError;
-    private final String useCompressedOops;
-    private final String useG1GC;
-    private final String useSerialGC;
-    private final long g1RegionSize;
-
-    private ProtobufJvmInfo(
-        long pid,
-        String version,
-        String vmName,
-        String vmVersion,
-        String vmVendor,
-        boolean bundledJdk,
-        Boolean usingBundledJdk,
-        long startTime,
-        long configuredInitialHeapSize,
-        long configuredMaxHeapSize,
-        Mem mem,
-        String[] inputArguments,
-        String bootClassPath,
-        String classPath,
-        Map<String, String> systemProperties,
-        String[] gcCollectors,
-        String[] memoryPools,
-        String onError,
-        String onOutOfMemoryError,
-        String useCompressedOops,
-        String useG1GC,
-        String useSerialGC,
-        long g1RegionSize
-    ) {
-        this.pid = pid;
-        this.version = version;
-        this.vmName = vmName;
-        this.vmVersion = vmVersion;
-        this.vmVendor = vmVendor;
-        this.bundledJdk = bundledJdk;
-        this.usingBundledJdk = usingBundledJdk;
-        this.startTime = startTime;
-        this.configuredInitialHeapSize = configuredInitialHeapSize;
-        this.configuredMaxHeapSize = configuredMaxHeapSize;
-        this.mem = mem;
-        this.inputArguments = inputArguments;
-        this.bootClassPath = bootClassPath;
-        this.classPath = classPath;
-        this.systemProperties = systemProperties;
-        this.gcCollectors = gcCollectors;
-        this.memoryPools = memoryPools;
-        this.onError = onError;
-        this.onOutOfMemoryError = onOutOfMemoryError;
-        this.useCompressedOops = useCompressedOops;
-        this.useG1GC = useG1GC;
-        this.useSerialGC = useSerialGC;
-        this.g1RegionSize = g1RegionSize;
-    }
-
-    public ProtobufJvmInfo(StreamInput in) throws IOException {
-        pid = in.readLong();
-        version = in.readString();
-        vmName = in.readString();
-        vmVersion = in.readString();
-        vmVendor = in.readString();
-        bundledJdk = in.readBoolean();
-        usingBundledJdk = in.readOptionalBoolean();
-        startTime = in.readLong();
-        inputArguments = new String[in.readInt()];
-        for (int i = 0; i < inputArguments.length; i++) {
-            inputArguments[i] = in.readString();
-        }
-        bootClassPath = in.readString();
-        classPath = in.readString();
-        systemProperties = in.readMap(StreamInput::readString, StreamInput::readString);
-        mem = new Mem(in);
-        gcCollectors = in.readStringArray();
-        memoryPools = in.readStringArray();
-        useCompressedOops = in.readString();
-        // the following members are only used locally for bootstrap checks, never serialized nor printed out
-        this.configuredMaxHeapSize = -1;
-        this.configuredInitialHeapSize = -1;
-        this.onError = null;
-        this.onOutOfMemoryError = null;
-        this.useG1GC = "unknown";
-        this.useSerialGC = "unknown";
-        this.g1RegionSize = -1;
-    }
-
-    public ProtobufJvmInfo(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        pid = in.readInt64();
-        version = in.readString();
-        vmName = in.readString();
-        vmVersion = in.readString();
-        vmVendor = in.readString();
-        bundledJdk = in.readBool();
-        usingBundledJdk = protobufStreamInput.readOptionalBoolean();
-        startTime = in.readInt64();
-        inputArguments = new String[in.readInt32()];
-        for (int i = 0; i < inputArguments.length; i++) {
-            inputArguments[i] = in.readString();
-        }
-        bootClassPath = in.readString();
-        classPath = in.readString();
-        systemProperties = protobufStreamInput.readMap(CodedInputStream::readString, CodedInputStream::readString);
-        mem = new Mem(in);
-        gcCollectors = protobufStreamInput.readStringArray();
-        memoryPools = protobufStreamInput.readStringArray();
-        useCompressedOops = in.readString();
-        // the following members are only used locally for bootstrap checks, never serialized nor printed out
-        this.configuredMaxHeapSize = -1;
-        this.configuredInitialHeapSize = -1;
-        this.onError = null;
-        this.onOutOfMemoryError = null;
-        this.useG1GC = "unknown";
-        this.useSerialGC = "unknown";
-        this.g1RegionSize = -1;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeInt64NoTag(pid);
-        out.writeStringNoTag(version);
-        out.writeStringNoTag(vmName);
-        out.writeStringNoTag(vmVersion);
-        out.writeStringNoTag(vmVendor);
-        out.writeBoolNoTag(bundledJdk);
-        protobufStreamOutput.writeOptionalBoolean(usingBundledJdk);
-        out.writeInt64NoTag(startTime);
-        out.writeInt32NoTag(inputArguments.length);
-        for (String inputArgument : inputArguments) {
-            out.writeStringNoTag(inputArgument);
-        }
-        out.writeStringNoTag(bootClassPath);
-        out.writeStringNoTag(classPath);
-        out.writeInt32NoTag(this.systemProperties.size());
-        for (Map.Entry<String, String> entry : systemProperties.entrySet()) {
-            out.writeStringNoTag(entry.getKey());
-            out.writeStringNoTag(entry.getValue());
-        }
-        mem.writeTo(out);
-        protobufStreamOutput.writeStringArray(gcCollectors);
-        protobufStreamOutput.writeStringArray(memoryPools);
-        out.writeStringNoTag(useCompressedOops);
-    }
-
-    /**
-     * The process id.
-     */
-    public long pid() {
-        return this.pid;
-    }
-
-    /**
-     * The process id.
-     */
-    public long getPid() {
-        return pid;
-    }
-
-    public String version() {
-        return this.version;
-    }
-
-    public String getVersion() {
-        return this.version;
-    }
-
-    public int versionAsInteger() {
-        try {
-            int i = 0;
-            StringBuilder sVersion = new StringBuilder();
-            for (; i < version.length(); i++) {
-                if (!Character.isDigit(version.charAt(i)) && version.charAt(i) != '.') {
-                    break;
-                }
-                if (version.charAt(i) != '.') {
-                    sVersion.append(version.charAt(i));
-                }
-            }
-            if (i == 0) {
-                return -1;
-            }
-            return Integer.parseInt(sVersion.toString());
-        } catch (Exception e) {
-            return -1;
-        }
-    }
-
-    public int versionUpdatePack() {
-        try {
-            int i = 0;
-            StringBuilder sVersion = new StringBuilder();
-            for (; i < version.length(); i++) {
-                if (!Character.isDigit(version.charAt(i)) && version.charAt(i) != '.') {
-                    break;
-                }
-                if (version.charAt(i) != '.') {
-                    sVersion.append(version.charAt(i));
-                }
-            }
-            if (i == 0) {
-                return -1;
-            }
-            Integer.parseInt(sVersion.toString());
-            int from;
-            if (version.charAt(i) == '_') {
-                // 1.7.0_4
-                from = ++i;
-            } else if (version.charAt(i) == '-' && version.charAt(i + 1) == 'u') {
-                // 1.7.0-u2-b21
-                i = i + 2;
-                from = i;
-            } else {
-                return -1;
-            }
-            for (; i < version.length(); i++) {
-                if (!Character.isDigit(version.charAt(i)) && version.charAt(i) != '.') {
-                    break;
-                }
-            }
-            if (from == i) {
-                return -1;
-            }
-            return Integer.parseInt(version.substring(from, i));
-        } catch (Exception e) {
-            return -1;
-        }
-    }
-
-    public String getVmName() {
-        return this.vmName;
-    }
-
-    public String getVmVersion() {
-        return this.vmVersion;
-    }
-
-    public String getVmVendor() {
-        return this.vmVendor;
-    }
-
-    public boolean getBundledJdk() {
-        return bundledJdk;
-    }
-
-    public Boolean getUsingBundledJdk() {
-        return usingBundledJdk;
-    }
-
-    public long getStartTime() {
-        return this.startTime;
-    }
-
-    public Mem getMem() {
-        return this.mem;
-    }
-
-    public String[] getInputArguments() {
-        return this.inputArguments;
-    }
-
-    public String getBootClassPath() {
-        return this.bootClassPath;
-    }
-
-    public String getClassPath() {
-        return this.classPath;
-    }
-
-    public Map<String, String> getSystemProperties() {
-        return this.systemProperties;
-    }
-
-    public long getConfiguredInitialHeapSize() {
-        return configuredInitialHeapSize;
-    }
-
-    public long getConfiguredMaxHeapSize() {
-        return configuredMaxHeapSize;
-    }
-
-    public String onError() {
-        return onError;
-    }
-
-    public String onOutOfMemoryError() {
-        return onOutOfMemoryError;
-    }
-
-    /**
-     * The value of the JVM flag UseCompressedOops, if available otherwise
-     * "unknown". The value "unknown" indicates that an attempt was
-     * made to obtain the value of the flag on this JVM and the attempt
-     * failed.
-     *
-     * @return the value of the JVM flag UseCompressedOops or "unknown"
-     */
-    public String useCompressedOops() {
-        return this.useCompressedOops;
-    }
-
-    public String useG1GC() {
-        return this.useG1GC;
-    }
-
-    public String useSerialGC() {
-        return this.useSerialGC;
-    }
-
-    public long getG1RegionSize() {
-        return g1RegionSize;
-    }
-
-    public String[] getGcCollectors() {
-        return gcCollectors;
-    }
-
-    public String[] getMemoryPools() {
-        return memoryPools;
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.JVM);
-        builder.field(Fields.PID, pid);
-        builder.field(Fields.VERSION, version);
-        builder.field(Fields.VM_NAME, vmName);
-        builder.field(Fields.VM_VERSION, vmVersion);
-        builder.field(Fields.VM_VENDOR, vmVendor);
-        builder.field(Fields.BUNDLED_JDK, bundledJdk);
-        builder.field(Fields.USING_BUNDLED_JDK, usingBundledJdk);
-        builder.timeField(Fields.START_TIME_IN_MILLIS, Fields.START_TIME, startTime);
-
-        builder.startObject(Fields.MEM);
-        builder.humanReadableField(Fields.HEAP_INIT_IN_BYTES, Fields.HEAP_INIT, new ByteSizeValue(mem.heapInit));
-        builder.humanReadableField(Fields.HEAP_MAX_IN_BYTES, Fields.HEAP_MAX, new ByteSizeValue(mem.heapMax));
-        builder.humanReadableField(Fields.NON_HEAP_INIT_IN_BYTES, Fields.NON_HEAP_INIT, new ByteSizeValue(mem.nonHeapInit));
-        builder.humanReadableField(Fields.NON_HEAP_MAX_IN_BYTES, Fields.NON_HEAP_MAX, new ByteSizeValue(mem.nonHeapMax));
-        builder.humanReadableField(Fields.DIRECT_MAX_IN_BYTES, Fields.DIRECT_MAX, new ByteSizeValue(mem.directMemoryMax));
-        builder.endObject();
-
-        builder.array(Fields.GC_COLLECTORS, gcCollectors);
-        builder.array(Fields.MEMORY_POOLS, memoryPools);
-
-        builder.field(Fields.USING_COMPRESSED_OOPS, useCompressedOops);
-
-        builder.field(Fields.INPUT_ARGUMENTS, inputArguments);
-
-        builder.endObject();
-        return builder;
-    }
-
-    static final class Fields {
-        static final String JVM = "jvm";
-        static final String PID = "pid";
-        static final String VERSION = "version";
-        static final String VM_NAME = "vm_name";
-        static final String VM_VERSION = "vm_version";
-        static final String VM_VENDOR = "vm_vendor";
-        static final String BUNDLED_JDK = "bundled_jdk";
-        static final String USING_BUNDLED_JDK = "using_bundled_jdk";
-        static final String START_TIME = "start_time";
-        static final String START_TIME_IN_MILLIS = "start_time_in_millis";
-
-        static final String MEM = "mem";
-        static final String HEAP_INIT = "heap_init";
-        static final String HEAP_INIT_IN_BYTES = "heap_init_in_bytes";
-        static final String HEAP_MAX = "heap_max";
-        static final String HEAP_MAX_IN_BYTES = "heap_max_in_bytes";
-        static final String NON_HEAP_INIT = "non_heap_init";
-        static final String NON_HEAP_INIT_IN_BYTES = "non_heap_init_in_bytes";
-        static final String NON_HEAP_MAX = "non_heap_max";
-        static final String NON_HEAP_MAX_IN_BYTES = "non_heap_max_in_bytes";
-        static final String DIRECT_MAX = "direct_max";
-        static final String DIRECT_MAX_IN_BYTES = "direct_max_in_bytes";
-        static final String GC_COLLECTORS = "gc_collectors";
-        static final String MEMORY_POOLS = "memory_pools";
-        static final String USING_COMPRESSED_OOPS = "using_compressed_ordinary_object_pointers";
-        static final String INPUT_ARGUMENTS = "input_arguments";
-    }
-
-    /**
-     * Memory information.
-     *
-     * @opensearch.internal
-     */
-    public static class Mem implements Writeable, ProtobufWriteable {
-
-        private final long heapInit;
-        private final long heapMax;
-        private final long nonHeapInit;
-        private final long nonHeapMax;
-        private final long directMemoryMax;
-
-        public Mem(long heapInit, long heapMax, long nonHeapInit, long nonHeapMax, long directMemoryMax) {
-            this.heapInit = heapInit;
-            this.heapMax = heapMax;
-            this.nonHeapInit = nonHeapInit;
-            this.nonHeapMax = nonHeapMax;
-            this.directMemoryMax = directMemoryMax;
-        }
-
-        public Mem(StreamInput in) throws IOException {
-            this.heapInit = in.readVLong();
-            this.heapMax = in.readVLong();
-            this.nonHeapInit = in.readVLong();
-            this.nonHeapMax = in.readVLong();
-            this.directMemoryMax = in.readVLong();
-        }
-
-        @Override
-        public void writeTo(StreamOutput out) throws IOException {
-            out.writeVLong(heapInit);
-            out.writeVLong(heapMax);
-            out.writeVLong(nonHeapInit);
-            out.writeVLong(nonHeapMax);
-            out.writeVLong(directMemoryMax);
-        }
-
-        public Mem(CodedInputStream in) throws IOException {
-            this.heapInit = in.readInt64();
-            this.heapMax = in.readInt64();
-            this.nonHeapInit = in.readInt64();
-            this.nonHeapMax = in.readInt64();
-            this.directMemoryMax = in.readInt64();
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeInt64NoTag(heapInit);
-            out.writeInt64NoTag(heapMax);
-            out.writeInt64NoTag(nonHeapInit);
-            out.writeInt64NoTag(nonHeapMax);
-            out.writeInt64NoTag(directMemoryMax);
-        }
-
-        public ByteSizeValue getHeapInit() {
-            return new ByteSizeValue(heapInit);
-        }
-
-        public ByteSizeValue getHeapMax() {
-            return new ByteSizeValue(heapMax);
-        }
-
-        public ByteSizeValue getNonHeapInit() {
-            return new ByteSizeValue(nonHeapInit);
-        }
-
-        public ByteSizeValue getNonHeapMax() {
-            return new ByteSizeValue(nonHeapMax);
-        }
-
-        public ByteSizeValue getDirectMemoryMax() {
-            return new ByteSizeValue(directMemoryMax);
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmService.java b/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmService.java
deleted file mode 100644
index 63d3428086621..0000000000000
--- a/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmService.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * 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.
- */
-
-package org.opensearch.monitor.jvm;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.opensearch.common.settings.Setting;
-import org.opensearch.common.settings.Setting.Property;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.node.ProtobufReportingService;
-
-/**
- * Service for monitoring the JVM
- *
- * @opensearch.internal
- */
-public class ProtobufJvmService implements ProtobufReportingService<JvmInfo> {
-
-    private static final Logger logger = LogManager.getLogger(ProtobufJvmService.class);
-
-    private final JvmInfo jvmInfo;
-
-    private final TimeValue refreshInterval;
-
-    private ProtobufJvmStats jvmStats;
-
-    public static final Setting<TimeValue> REFRESH_INTERVAL_SETTING = Setting.timeSetting(
-        "monitor.jvm.refresh_interval",
-        TimeValue.timeValueSeconds(1),
-        TimeValue.timeValueSeconds(1),
-        Property.NodeScope
-    );
-
-    public ProtobufJvmService(Settings settings) {
-        this.jvmInfo = JvmInfo.jvmInfo();
-        this.jvmStats = ProtobufJvmStats.jvmStats();
-
-        this.refreshInterval = REFRESH_INTERVAL_SETTING.get(settings);
-
-        logger.debug("using refresh_interval [{}]", refreshInterval);
-    }
-
-    @Override
-    public JvmInfo protobufInfo() {
-        return this.jvmInfo;
-    }
-
-    public synchronized ProtobufJvmStats stats() {
-        if ((System.currentTimeMillis() - jvmStats.getTimestamp()) > refreshInterval.millis()) {
-            jvmStats = ProtobufJvmStats.jvmStats();
-        }
-        return jvmStats;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmStats.java b/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmStats.java
deleted file mode 100644
index 7327840db296e..0000000000000
--- a/server/src/main/java/org/opensearch/monitor/jvm/ProtobufJvmStats.java
+++ /dev/null
@@ -1,755 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.monitor.jvm;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.lang.management.BufferPoolMXBean;
-import java.lang.management.ClassLoadingMXBean;
-import java.lang.management.GarbageCollectorMXBean;
-import java.lang.management.ManagementFactory;
-import java.lang.management.MemoryMXBean;
-import java.lang.management.MemoryPoolMXBean;
-import java.lang.management.MemoryUsage;
-import java.lang.management.RuntimeMXBean;
-import java.lang.management.ThreadMXBean;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-import java.util.concurrent.TimeUnit;
-
-/**
- * Holds JVM statistics
-*
-* @opensearch.internal
-*/
-public class ProtobufJvmStats implements ProtobufWriteable, ToXContentFragment {
-
-    private static final RuntimeMXBean runtimeMXBean;
-    private static final MemoryMXBean memoryMXBean;
-    private static final ThreadMXBean threadMXBean;
-    private static final ClassLoadingMXBean classLoadingMXBean;
-
-    static {
-        runtimeMXBean = ManagementFactory.getRuntimeMXBean();
-        memoryMXBean = ManagementFactory.getMemoryMXBean();
-        threadMXBean = ManagementFactory.getThreadMXBean();
-        classLoadingMXBean = ManagementFactory.getClassLoadingMXBean();
-    }
-
-    public static ProtobufJvmStats jvmStats() {
-        MemoryUsage memUsage = memoryMXBean.getHeapMemoryUsage();
-        long heapUsed = memUsage.getUsed() < 0 ? 0 : memUsage.getUsed();
-        long heapCommitted = memUsage.getCommitted() < 0 ? 0 : memUsage.getCommitted();
-        long heapMax = memUsage.getMax() < 0 ? 0 : memUsage.getMax();
-        memUsage = memoryMXBean.getNonHeapMemoryUsage();
-        long nonHeapUsed = memUsage.getUsed() < 0 ? 0 : memUsage.getUsed();
-        long nonHeapCommitted = memUsage.getCommitted() < 0 ? 0 : memUsage.getCommitted();
-        List<MemoryPoolMXBean> memoryPoolMXBeans = ManagementFactory.getMemoryPoolMXBeans();
-        List<MemoryPool> pools = new ArrayList<>();
-        for (MemoryPoolMXBean memoryPoolMXBean : memoryPoolMXBeans) {
-            try {
-                MemoryUsage usage = memoryPoolMXBean.getUsage();
-                MemoryUsage peakUsage = memoryPoolMXBean.getPeakUsage();
-                MemoryUsage collectionUsage = memoryPoolMXBean.getCollectionUsage();
-                // For some pools, the collection usage may not be supported and the method returns null.
-                if (collectionUsage == null) {
-                    collectionUsage = new MemoryUsage(0, 0, 0, 0);
-                }
-                String name = GcNames.getByMemoryPoolName(memoryPoolMXBean.getName(), null);
-                if (name == null) { // if we can't resolve it, its not interesting.... (Per Gen, Code Cache)
-                    continue;
-                }
-                pools.add(
-                    new MemoryPool(
-                        name,
-                        usage.getUsed() < 0 ? 0 : usage.getUsed(),
-                        usage.getMax() < 0 ? 0 : usage.getMax(),
-                        peakUsage.getUsed() < 0 ? 0 : peakUsage.getUsed(),
-                        peakUsage.getMax() < 0 ? 0 : peakUsage.getMax(),
-                        new MemoryPoolGcStats(
-                            collectionUsage.getUsed() < 0 ? 0 : collectionUsage.getUsed(),
-                            collectionUsage.getMax() < 0 ? 0 : collectionUsage.getMax()
-                        )
-                    )
-                );
-
-            } catch (final Exception ignored) {
-
-            }
-        }
-        Mem mem = new Mem(heapCommitted, heapUsed, heapMax, nonHeapCommitted, nonHeapUsed, Collections.unmodifiableList(pools));
-        Threads threads = new Threads(threadMXBean.getThreadCount(), threadMXBean.getPeakThreadCount());
-
-        List<GarbageCollectorMXBean> gcMxBeans = ManagementFactory.getGarbageCollectorMXBeans();
-        GarbageCollector[] collectors = new GarbageCollector[gcMxBeans.size()];
-        for (int i = 0; i < collectors.length; i++) {
-            GarbageCollectorMXBean gcMxBean = gcMxBeans.get(i);
-            collectors[i] = new GarbageCollector(
-                GcNames.getByGcName(gcMxBean.getName(), gcMxBean.getName()),
-                gcMxBean.getCollectionCount(),
-                gcMxBean.getCollectionTime()
-            );
-        }
-        GarbageCollectors garbageCollectors = new GarbageCollectors(collectors);
-        List<BufferPool> bufferPoolsList = Collections.emptyList();
-        try {
-            List<BufferPoolMXBean> bufferPools = ManagementFactory.getPlatformMXBeans(BufferPoolMXBean.class);
-            bufferPoolsList = new ArrayList<>(bufferPools.size());
-            for (BufferPoolMXBean bufferPool : bufferPools) {
-                bufferPoolsList.add(
-                    new BufferPool(bufferPool.getName(), bufferPool.getCount(), bufferPool.getTotalCapacity(), bufferPool.getMemoryUsed())
-                );
-            }
-        } catch (Exception e) {
-            // buffer pools are not available
-        }
-
-        Classes classes = new Classes(
-            classLoadingMXBean.getLoadedClassCount(),
-            classLoadingMXBean.getTotalLoadedClassCount(),
-            classLoadingMXBean.getUnloadedClassCount()
-        );
-
-        return new ProtobufJvmStats(
-            System.currentTimeMillis(),
-            runtimeMXBean.getUptime(),
-            mem,
-            threads,
-            garbageCollectors,
-            bufferPoolsList,
-            classes
-        );
-    }
-
-    private final long timestamp;
-    private final long uptime;
-    private final Mem mem;
-    private final Threads threads;
-    private final GarbageCollectors gc;
-    private final List<BufferPool> bufferPools;
-    private final Classes classes;
-
-    public ProtobufJvmStats(
-        long timestamp,
-        long uptime,
-        Mem mem,
-        Threads threads,
-        GarbageCollectors gc,
-        List<BufferPool> bufferPools,
-        Classes classes
-    ) {
-        this.timestamp = timestamp;
-        this.uptime = uptime;
-        this.mem = mem;
-        this.threads = threads;
-        this.gc = gc;
-        this.bufferPools = bufferPools;
-        this.classes = classes;
-    }
-
-    public ProtobufJvmStats(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        timestamp = in.readInt64();
-        uptime = in.readInt64();
-        mem = new Mem(in);
-        threads = new Threads(in);
-        gc = new GarbageCollectors(in);
-        bufferPools = protobufStreamInput.readList(BufferPool::new);
-        classes = new Classes(in);
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeInt64NoTag(timestamp);
-        out.writeInt64NoTag(uptime);
-        mem.writeTo(out);
-        threads.writeTo(out);
-        gc.writeTo(out);
-        protobufStreamOutput.writeCollection(bufferPools, (o, v) -> v.writeTo(o));
-        classes.writeTo(out);
-    }
-
-    public long getTimestamp() {
-        return timestamp;
-    }
-
-    public TimeValue getUptime() {
-        return new TimeValue(uptime);
-    }
-
-    public Mem getMem() {
-        return this.mem;
-    }
-
-    public Threads getThreads() {
-        return threads;
-    }
-
-    public GarbageCollectors getGc() {
-        return gc;
-    }
-
-    public List<BufferPool> getBufferPools() {
-        return bufferPools;
-    }
-
-    public Classes getClasses() {
-        return classes;
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.JVM);
-        builder.field(Fields.TIMESTAMP, timestamp);
-        builder.humanReadableField(Fields.UPTIME_IN_MILLIS, Fields.UPTIME, new TimeValue(uptime));
-
-        builder.startObject(Fields.MEM);
-
-        builder.humanReadableField(Fields.HEAP_USED_IN_BYTES, Fields.HEAP_USED, new ByteSizeValue(mem.heapUsed));
-        if (mem.getHeapUsedPercent() >= 0) {
-            builder.field(Fields.HEAP_USED_PERCENT, mem.getHeapUsedPercent());
-        }
-        builder.humanReadableField(Fields.HEAP_COMMITTED_IN_BYTES, Fields.HEAP_COMMITTED, new ByteSizeValue(mem.heapCommitted));
-        builder.humanReadableField(Fields.HEAP_MAX_IN_BYTES, Fields.HEAP_MAX, new ByteSizeValue(mem.heapMax));
-        builder.humanReadableField(Fields.NON_HEAP_USED_IN_BYTES, Fields.NON_HEAP_USED, new ByteSizeValue(mem.nonHeapUsed));
-        builder.humanReadableField(Fields.NON_HEAP_COMMITTED_IN_BYTES, Fields.NON_HEAP_COMMITTED, new ByteSizeValue(mem.nonHeapCommitted));
-
-        builder.startObject(Fields.POOLS);
-        for (MemoryPool pool : mem) {
-            builder.startObject(pool.getName());
-            builder.humanReadableField(Fields.USED_IN_BYTES, Fields.USED, new ByteSizeValue(pool.used));
-            builder.humanReadableField(Fields.MAX_IN_BYTES, Fields.MAX, new ByteSizeValue(pool.max));
-
-            builder.humanReadableField(Fields.PEAK_USED_IN_BYTES, Fields.PEAK_USED, new ByteSizeValue(pool.peakUsed));
-            builder.humanReadableField(Fields.PEAK_MAX_IN_BYTES, Fields.PEAK_MAX, new ByteSizeValue(pool.peakMax));
-
-            builder.startObject(Fields.LAST_GC_STATS);
-            builder.humanReadableField(Fields.USED_IN_BYTES, Fields.USED, new ByteSizeValue(pool.getLastGcStats().used));
-            builder.humanReadableField(Fields.MAX_IN_BYTES, Fields.MAX, new ByteSizeValue(pool.getLastGcStats().max));
-            builder.field(Fields.USAGE_PERCENT, pool.getLastGcStats().getUsagePercent());
-            builder.endObject();
-
-            builder.endObject();
-        }
-        builder.endObject();
-
-        builder.endObject();
-
-        builder.startObject(Fields.THREADS);
-        builder.field(Fields.COUNT, threads.getCount());
-        builder.field(Fields.PEAK_COUNT, threads.getPeakCount());
-        builder.endObject();
-
-        builder.startObject(Fields.GC);
-
-        builder.startObject(Fields.COLLECTORS);
-        for (GarbageCollector collector : gc) {
-            builder.startObject(collector.getName());
-            builder.field(Fields.COLLECTION_COUNT, collector.getCollectionCount());
-            builder.humanReadableField(Fields.COLLECTION_TIME_IN_MILLIS, Fields.COLLECTION_TIME, new TimeValue(collector.collectionTime));
-            builder.endObject();
-        }
-        builder.endObject();
-
-        builder.endObject();
-
-        if (bufferPools != null) {
-            builder.startObject(Fields.BUFFER_POOLS);
-            for (BufferPool bufferPool : bufferPools) {
-                builder.startObject(bufferPool.getName());
-                builder.field(Fields.COUNT, bufferPool.getCount());
-                builder.humanReadableField(Fields.USED_IN_BYTES, Fields.USED, new ByteSizeValue(bufferPool.used));
-                builder.humanReadableField(
-                    Fields.TOTAL_CAPACITY_IN_BYTES,
-                    Fields.TOTAL_CAPACITY,
-                    new ByteSizeValue(bufferPool.totalCapacity)
-                );
-                builder.endObject();
-            }
-            builder.endObject();
-        }
-
-        builder.startObject(Fields.CLASSES);
-        builder.field(Fields.CURRENT_LOADED_COUNT, classes.getLoadedClassCount());
-        builder.field(Fields.TOTAL_LOADED_COUNT, classes.getTotalLoadedClassCount());
-        builder.field(Fields.TOTAL_UNLOADED_COUNT, classes.getUnloadedClassCount());
-        builder.endObject();
-
-        builder.endObject();
-        return builder;
-    }
-
-    static final class Fields {
-        static final String JVM = "jvm";
-        static final String TIMESTAMP = "timestamp";
-        static final String UPTIME = "uptime";
-        static final String UPTIME_IN_MILLIS = "uptime_in_millis";
-
-        static final String MEM = "mem";
-        static final String HEAP_USED = "heap_used";
-        static final String HEAP_USED_IN_BYTES = "heap_used_in_bytes";
-        static final String HEAP_USED_PERCENT = "heap_used_percent";
-        static final String HEAP_MAX = "heap_max";
-        static final String HEAP_MAX_IN_BYTES = "heap_max_in_bytes";
-        static final String HEAP_COMMITTED = "heap_committed";
-        static final String HEAP_COMMITTED_IN_BYTES = "heap_committed_in_bytes";
-
-        static final String NON_HEAP_USED = "non_heap_used";
-        static final String NON_HEAP_USED_IN_BYTES = "non_heap_used_in_bytes";
-        static final String NON_HEAP_COMMITTED = "non_heap_committed";
-        static final String NON_HEAP_COMMITTED_IN_BYTES = "non_heap_committed_in_bytes";
-
-        static final String POOLS = "pools";
-        static final String USED = "used";
-        static final String USED_IN_BYTES = "used_in_bytes";
-        static final String MAX = "max";
-        static final String MAX_IN_BYTES = "max_in_bytes";
-        static final String PEAK_USED = "peak_used";
-        static final String PEAK_USED_IN_BYTES = "peak_used_in_bytes";
-        static final String PEAK_MAX = "peak_max";
-        static final String PEAK_MAX_IN_BYTES = "peak_max_in_bytes";
-        static final String USAGE_PERCENT = "usage_percent";
-        static final String LAST_GC_STATS = "last_gc_stats";
-
-        static final String THREADS = "threads";
-        static final String COUNT = "count";
-        static final String PEAK_COUNT = "peak_count";
-
-        static final String GC = "gc";
-        static final String COLLECTORS = "collectors";
-        static final String COLLECTION_COUNT = "collection_count";
-        static final String COLLECTION_TIME = "collection_time";
-        static final String COLLECTION_TIME_IN_MILLIS = "collection_time_in_millis";
-
-        static final String BUFFER_POOLS = "buffer_pools";
-        static final String TOTAL_CAPACITY = "total_capacity";
-        static final String TOTAL_CAPACITY_IN_BYTES = "total_capacity_in_bytes";
-
-        static final String CLASSES = "classes";
-        static final String CURRENT_LOADED_COUNT = "current_loaded_count";
-        static final String TOTAL_LOADED_COUNT = "total_loaded_count";
-        static final String TOTAL_UNLOADED_COUNT = "total_unloaded_count";
-    }
-
-    /**
-     * Garbage collector references.
-    *
-    * @opensearch.internal
-    */
-    public static class GarbageCollectors implements ProtobufWriteable, Iterable<GarbageCollector> {
-
-        private final GarbageCollector[] collectors;
-
-        public GarbageCollectors(GarbageCollector[] collectors) {
-            this.collectors = collectors;
-        }
-
-        public GarbageCollectors(CodedInputStream in) throws IOException {
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-            collectors = protobufStreamInput.readArray(GarbageCollector::new, GarbageCollector[]::new);
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            protobufStreamOutput.writeArray((o, v) -> v.writeTo(o), collectors);
-        }
-
-        public GarbageCollector[] getCollectors() {
-            return this.collectors;
-        }
-
-        @Override
-        public Iterator<GarbageCollector> iterator() {
-            return Arrays.stream(collectors).iterator();
-        }
-    }
-
-    /**
-     * The garbage collector.
-    *
-    * @opensearch.internal
-    */
-    public static class GarbageCollector implements ProtobufWriteable {
-
-        private final String name;
-        private final long collectionCount;
-        private final long collectionTime;
-
-        public GarbageCollector(String name, long collectionCount, long collectionTime) {
-            this.name = name;
-            this.collectionCount = collectionCount;
-            this.collectionTime = collectionTime;
-        }
-
-        public GarbageCollector(CodedInputStream in) throws IOException {
-            name = in.readString();
-            collectionCount = in.readInt64();
-            collectionTime = in.readInt64();
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeStringNoTag(name);
-            out.writeInt64NoTag(collectionCount);
-            out.writeInt64NoTag(collectionTime);
-        }
-
-        public String getName() {
-            return this.name;
-        }
-
-        public long getCollectionCount() {
-            return this.collectionCount;
-        }
-
-        public TimeValue getCollectionTime() {
-            return new TimeValue(collectionTime, TimeUnit.MILLISECONDS);
-        }
-    }
-
-    /**
-     * Thread information.
-    *
-    * @opensearch.internal
-    */
-    public static class Threads implements ProtobufWriteable {
-
-        private final int count;
-        private final int peakCount;
-
-        public Threads(int count, int peakCount) {
-            this.count = count;
-            this.peakCount = peakCount;
-        }
-
-        public Threads(CodedInputStream in) throws IOException {
-            count = in.readInt32();
-            peakCount = in.readInt32();
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeInt32NoTag(count);
-            out.writeInt32NoTag(peakCount);
-        }
-
-        public int getCount() {
-            return count;
-        }
-
-        public int getPeakCount() {
-            return peakCount;
-        }
-    }
-
-    /**
-     * Stores the memory usage after the Java virtual machine
-    * most recently expended effort in recycling unused objects
-    * in particular memory pool.
-    *
-    * @opensearch.internal
-    */
-    public static class MemoryPoolGcStats implements ProtobufWriteable {
-
-        private final long used;
-        private final long max;
-
-        public MemoryPoolGcStats(long used, long max) {
-            this.used = used;
-            this.max = max;
-        }
-
-        public MemoryPoolGcStats(CodedInputStream in) throws IOException {
-            used = in.readInt64();
-            max = in.readInt64();
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeInt64NoTag(used);
-            out.writeInt64NoTag(max);
-        }
-
-        public ByteSizeValue getUsed() {
-            return new ByteSizeValue(used);
-        }
-
-        public ByteSizeValue getMax() {
-            return new ByteSizeValue(max);
-        }
-
-        public short getUsagePercent() {
-            if (max == 0) {
-                return -1;
-            }
-            return (short) (used * 100 / max);
-        }
-    }
-
-    /**
-     * A memory pool.
-    *
-    * @opensearch.internal
-    */
-    public static class MemoryPool implements ProtobufWriteable {
-
-        private final String name;
-        private final long used;
-        private final long max;
-        private final long peakUsed;
-        private final long peakMax;
-        private final MemoryPoolGcStats lastGcStats;
-
-        public MemoryPool(String name, long used, long max, long peakUsed, long peakMax, MemoryPoolGcStats lastGcStats) {
-            this.name = name;
-            this.used = used;
-            this.max = max;
-            this.peakUsed = peakUsed;
-            this.peakMax = peakMax;
-            this.lastGcStats = lastGcStats;
-        }
-
-        public MemoryPool(CodedInputStream in) throws IOException {
-            name = in.readString();
-            used = in.readInt64();
-            max = in.readInt64();
-            peakUsed = in.readInt64();
-            peakMax = in.readInt64();
-            lastGcStats = new MemoryPoolGcStats(in);
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeStringNoTag(name);
-            out.writeInt64NoTag(used);
-            out.writeInt64NoTag(max);
-            out.writeInt64NoTag(peakUsed);
-            out.writeInt64NoTag(peakMax);
-            lastGcStats.writeTo(out);
-        }
-
-        public String getName() {
-            return this.name;
-        }
-
-        public ByteSizeValue getUsed() {
-            return new ByteSizeValue(used);
-        }
-
-        public ByteSizeValue getMax() {
-            return new ByteSizeValue(max);
-        }
-
-        public ByteSizeValue getPeakUsed() {
-            return new ByteSizeValue(peakUsed);
-        }
-
-        public ByteSizeValue getPeakMax() {
-            return new ByteSizeValue(peakMax);
-        }
-
-        /**
-         * Returns the heap usage after last garbage collection cycle
-        */
-        public MemoryPoolGcStats getLastGcStats() {
-            return lastGcStats;
-        }
-    }
-
-    /**
-     * Memory data.
-    *
-    * @opensearch.internal
-    */
-    public static class Mem implements ProtobufWriteable, Iterable<MemoryPool> {
-
-        private final long heapCommitted;
-        private final long heapUsed;
-        private final long heapMax;
-        private final long nonHeapCommitted;
-        private final long nonHeapUsed;
-        private final List<MemoryPool> pools;
-
-        public Mem(long heapCommitted, long heapUsed, long heapMax, long nonHeapCommitted, long nonHeapUsed, List<MemoryPool> pools) {
-            this.heapCommitted = heapCommitted;
-            this.heapUsed = heapUsed;
-            this.heapMax = heapMax;
-            this.nonHeapCommitted = nonHeapCommitted;
-            this.nonHeapUsed = nonHeapUsed;
-            this.pools = pools;
-        }
-
-        public Mem(CodedInputStream in) throws IOException {
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-            heapCommitted = in.readInt64();
-            heapUsed = in.readInt64();
-            nonHeapCommitted = in.readInt64();
-            nonHeapUsed = in.readInt64();
-            heapMax = in.readInt64();
-            pools = protobufStreamInput.readList(MemoryPool::new);
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            out.writeInt64NoTag(heapCommitted);
-            out.writeInt64NoTag(heapUsed);
-            out.writeInt64NoTag(nonHeapCommitted);
-            out.writeInt64NoTag(nonHeapUsed);
-            out.writeInt64NoTag(heapMax);
-            protobufStreamOutput.writeCollection(pools, (o, v) -> v.writeTo(o));
-        }
-
-        @Override
-        public Iterator<MemoryPool> iterator() {
-            return pools.iterator();
-        }
-
-        public ByteSizeValue getHeapCommitted() {
-            return new ByteSizeValue(heapCommitted);
-        }
-
-        public ByteSizeValue getHeapUsed() {
-            return new ByteSizeValue(heapUsed);
-        }
-
-        /**
-         * returns the maximum heap size. 0 bytes signals unknown.
-        */
-        public ByteSizeValue getHeapMax() {
-            return new ByteSizeValue(heapMax);
-        }
-
-        /**
-         * returns the heap usage in percent. -1 signals unknown.
-        */
-        public short getHeapUsedPercent() {
-            if (heapMax == 0) {
-                return -1;
-            }
-            return (short) (heapUsed * 100 / heapMax);
-        }
-
-        public ByteSizeValue getNonHeapCommitted() {
-            return new ByteSizeValue(nonHeapCommitted);
-        }
-
-        public ByteSizeValue getNonHeapUsed() {
-            return new ByteSizeValue(nonHeapUsed);
-        }
-    }
-
-    /**
-     * A buffer pool.
-    *
-    * @opensearch.internal
-    */
-    public static class BufferPool implements ProtobufWriteable {
-
-        private final String name;
-        private final long count;
-        private final long totalCapacity;
-        private final long used;
-
-        public BufferPool(String name, long count, long totalCapacity, long used) {
-            this.name = name;
-            this.count = count;
-            this.totalCapacity = totalCapacity;
-            this.used = used;
-        }
-
-        public BufferPool(CodedInputStream in) throws IOException {
-            name = in.readString();
-            count = in.readInt64();
-            totalCapacity = in.readInt64();
-            used = in.readInt64();
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeStringNoTag(name);
-            out.writeInt64NoTag(count);
-            out.writeInt64NoTag(totalCapacity);
-            out.writeInt64NoTag(used);
-        }
-
-        public String getName() {
-            return this.name;
-        }
-
-        public long getCount() {
-            return this.count;
-        }
-
-        public ByteSizeValue getTotalCapacity() {
-            return new ByteSizeValue(totalCapacity);
-        }
-
-        public ByteSizeValue getUsed() {
-            return new ByteSizeValue(used);
-        }
-    }
-
-    /**
-     * Class information.
-    *
-    * @opensearch.internal
-    */
-    public static class Classes implements ProtobufWriteable {
-
-        private final long loadedClassCount;
-        private final long totalLoadedClassCount;
-        private final long unloadedClassCount;
-
-        public Classes(long loadedClassCount, long totalLoadedClassCount, long unloadedClassCount) {
-            this.loadedClassCount = loadedClassCount;
-            this.totalLoadedClassCount = totalLoadedClassCount;
-            this.unloadedClassCount = unloadedClassCount;
-        }
-
-        public Classes(CodedInputStream in) throws IOException {
-            loadedClassCount = in.readInt64();
-            totalLoadedClassCount = in.readInt64();
-            unloadedClassCount = in.readInt64();
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeInt64NoTag(loadedClassCount);
-            out.writeInt64NoTag(totalLoadedClassCount);
-            out.writeInt64NoTag(unloadedClassCount);
-        }
-
-        public long getLoadedClassCount() {
-            return loadedClassCount;
-        }
-
-        public long getTotalLoadedClassCount() {
-            return totalLoadedClassCount;
-        }
-
-        public long getUnloadedClassCount() {
-            return unloadedClassCount;
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/monitor/os/OsProbe.java b/server/src/main/java/org/opensearch/monitor/os/OsProbe.java
index b2393a346db2e..98229941252ba 100644
--- a/server/src/main/java/org/opensearch/monitor/os/OsProbe.java
+++ b/server/src/main/java/org/opensearch/monitor/os/OsProbe.java
@@ -433,40 +433,6 @@ private OsStats.Cgroup.CpuStat getCgroupCpuAcctCpuStat(final String controlGroup
         return new OsStats.Cgroup.CpuStat(numberOfPeriods, numberOfTimesThrottled, timeThrottledNanos);
     }
 
-    private ProtobufOsStats.Cgroup.CpuStat getProtobufCgroupCpuAcctCpuStat(final String controlGroup) throws IOException {
-        final List<String> lines = readSysFsCgroupCpuAcctCpuStat(controlGroup);
-        long numberOfPeriods = -1;
-        long numberOfTimesThrottled = -1;
-        long timeThrottledNanos = -1;
-
-        for (final String line : lines) {
-            final String[] fields = line.split("\\s+");
-            switch (fields[0]) {
-                case "nr_periods":
-                    numberOfPeriods = Long.parseLong(fields[1]);
-                    break;
-                case "nr_throttled":
-                    numberOfTimesThrottled = Long.parseLong(fields[1]);
-                    break;
-                case "throttled_time":
-                    timeThrottledNanos = Long.parseLong(fields[1]);
-                    break;
-            }
-        }
-        if (isCpuStatWarningsLogged.getAndSet(true) == false) {
-            if (numberOfPeriods == -1) {
-                logger.warn("Expected to see nr_periods filed but found nothing");
-            }
-            if (numberOfTimesThrottled == -1) {
-                logger.warn("Expected to see nr_throttled filed but found nothing");
-            }
-            if (timeThrottledNanos == -1) {
-                logger.warn("Expected to see throttled_time filed but found nothing");
-            }
-        }
-        return new ProtobufOsStats.Cgroup.CpuStat(numberOfPeriods, numberOfTimesThrottled, timeThrottledNanos);
-    }
-
     /**
      * Returns the lines from {@code cpu.stat} for the control group to which the OpenSearch process belongs for the {@code cpu}
      * subsystem. These lines represent the CPU time statistics and have the form
@@ -626,61 +592,6 @@ private OsStats.Cgroup getCgroup() {
         }
     }
 
-    /**
-     * Basic cgroup stats.
-     *
-     * @return basic cgroup stats, or {@code null} if an I/O exception occurred reading the cgroup stats
-     */
-    private ProtobufOsStats.Cgroup getProtobufCgroup() {
-        try {
-            if (!areCgroupStatsAvailable()) {
-                return null;
-            } else {
-                final Map<String, String> controllerMap = getControlGroups();
-                assert !controllerMap.isEmpty();
-
-                final String cpuAcctControlGroup = controllerMap.get("cpuacct");
-                if (cpuAcctControlGroup == null) {
-                    logger.debug("no [cpuacct] data found in cgroup stats");
-                    return null;
-                }
-                final long cgroupCpuAcctUsageNanos = getCgroupCpuAcctUsageNanos(cpuAcctControlGroup);
-
-                final String cpuControlGroup = controllerMap.get("cpu");
-                if (cpuControlGroup == null) {
-                    logger.debug("no [cpu] data found in cgroup stats");
-                    return null;
-                }
-                final long cgroupCpuAcctCpuCfsPeriodMicros = getCgroupCpuAcctCpuCfsPeriodMicros(cpuControlGroup);
-                final long cgroupCpuAcctCpuCfsQuotaMicros = getCgroupCpuAcctCpuCfsQuotaMicros(cpuControlGroup);
-                final ProtobufOsStats.Cgroup.CpuStat cpuStat = getProtobufCgroupCpuAcctCpuStat(cpuControlGroup);
-
-                final String memoryControlGroup = controllerMap.get("memory");
-                if (memoryControlGroup == null) {
-                    logger.debug("no [memory] data found in cgroup stats");
-                    return null;
-                }
-                final String cgroupMemoryLimitInBytes = getCgroupMemoryLimitInBytes(memoryControlGroup);
-                final String cgroupMemoryUsageInBytes = getCgroupMemoryUsageInBytes(memoryControlGroup);
-
-                return new ProtobufOsStats.Cgroup(
-                    cpuAcctControlGroup,
-                    cgroupCpuAcctUsageNanos,
-                    cpuControlGroup,
-                    cgroupCpuAcctCpuCfsPeriodMicros,
-                    cgroupCpuAcctCpuCfsQuotaMicros,
-                    cpuStat,
-                    memoryControlGroup,
-                    cgroupMemoryLimitInBytes,
-                    cgroupMemoryUsageInBytes
-                );
-            }
-        } catch (final IOException e) {
-            logger.debug("error reading control group stats", e);
-            return null;
-        }
-    }
-
     private static class OsProbeHolder {
         private static final OsProbe INSTANCE = new OsProbe();
     }
@@ -714,18 +625,6 @@ OsInfo osInfo(long refreshInterval, int allocatedProcessors) throws IOException
         );
     }
 
-    ProtobufOsInfo protobufOsInfo(long refreshInterval, int allocatedProcessors) throws IOException {
-        return new ProtobufOsInfo(
-            refreshInterval,
-            Runtime.getRuntime().availableProcessors(),
-            allocatedProcessors,
-            Constants.OS_NAME,
-            getPrettyName(),
-            Constants.OS_ARCH,
-            Constants.OS_VERSION
-        );
-    }
-
     private String getPrettyName() throws IOException {
         // TODO: return a prettier name on non-Linux OS
         if (Constants.LINUX) {
@@ -797,14 +696,6 @@ public OsStats osStats() {
         return new OsStats(System.currentTimeMillis(), cpu, mem, swap, cgroup);
     }
 
-    public ProtobufOsStats protobufOsStats() {
-        final ProtobufOsStats.Cpu cpu = new ProtobufOsStats.Cpu(getSystemCpuPercent(), getSystemLoadAverage());
-        final ProtobufOsStats.Mem mem = new ProtobufOsStats.Mem(getTotalPhysicalMemorySize(), getFreePhysicalMemorySize());
-        final ProtobufOsStats.Swap swap = new ProtobufOsStats.Swap(getTotalSwapSpaceSize(), getFreeSwapSpaceSize());
-        final ProtobufOsStats.Cgroup cgroup = Constants.LINUX ? getProtobufCgroup() : null;
-        return new ProtobufOsStats(System.currentTimeMillis(), cpu, mem, swap, cgroup);
-    }
-
     /**
      * Returns a given method of the OperatingSystemMXBean, or null if the method is not found or unavailable.
      */
diff --git a/server/src/main/java/org/opensearch/monitor/os/ProtobufOsInfo.java b/server/src/main/java/org/opensearch/monitor/os/ProtobufOsInfo.java
deleted file mode 100644
index ff029fe223cc7..0000000000000
--- a/server/src/main/java/org/opensearch/monitor/os/ProtobufOsInfo.java
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.monitor.os;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.core.xcontent.ToXContent.Params;
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.node.ProtobufReportingService;
-
-import java.io.IOException;
-
-/**
- * Holds Operating System Information
-*
-* @opensearch.internal
-*/
-public class ProtobufOsInfo implements ProtobufReportingService.ProtobufInfo {
-
-    private final long refreshInterval;
-    private final int availableProcessors;
-    private final int allocatedProcessors;
-    private final String name;
-    private final String prettyName;
-    private final String arch;
-    private final String version;
-
-    public ProtobufOsInfo(
-        final long refreshInterval,
-        final int availableProcessors,
-        final int allocatedProcessors,
-        final String name,
-        final String prettyName,
-        final String arch,
-        final String version
-    ) {
-        this.refreshInterval = refreshInterval;
-        this.availableProcessors = availableProcessors;
-        this.allocatedProcessors = allocatedProcessors;
-        this.name = name;
-        this.prettyName = prettyName;
-        this.arch = arch;
-        this.version = version;
-    }
-
-    public ProtobufOsInfo(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        this.refreshInterval = in.readInt64();
-        this.availableProcessors = in.readInt32();
-        this.allocatedProcessors = in.readInt32();
-        this.name = protobufStreamInput.readOptionalString();
-        this.prettyName = protobufStreamInput.readOptionalString();
-        this.arch = protobufStreamInput.readOptionalString();
-        this.version = protobufStreamInput.readOptionalString();
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeInt64NoTag(refreshInterval);
-        out.writeInt32NoTag(availableProcessors);
-        out.writeInt32NoTag(allocatedProcessors);
-        protobufStreamOutput.writeOptionalString(name);
-        protobufStreamOutput.writeOptionalString(prettyName);
-        protobufStreamOutput.writeOptionalString(arch);
-        protobufStreamOutput.writeOptionalString(version);
-    }
-
-    public long getRefreshInterval() {
-        return this.refreshInterval;
-    }
-
-    public int getAvailableProcessors() {
-        return this.availableProcessors;
-    }
-
-    public int getAllocatedProcessors() {
-        return this.allocatedProcessors;
-    }
-
-    public String getName() {
-        return name;
-    }
-
-    public String getPrettyName() {
-        return prettyName;
-    }
-
-    public String getArch() {
-        return arch;
-    }
-
-    public String getVersion() {
-        return version;
-    }
-
-    static final class Fields {
-        static final String OS = "os";
-        static final String NAME = "name";
-        static final String PRETTY_NAME = "pretty_name";
-        static final String ARCH = "arch";
-        static final String VERSION = "version";
-        static final String REFRESH_INTERVAL = "refresh_interval";
-        static final String REFRESH_INTERVAL_IN_MILLIS = "refresh_interval_in_millis";
-        static final String AVAILABLE_PROCESSORS = "available_processors";
-        static final String ALLOCATED_PROCESSORS = "allocated_processors";
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.OS);
-        builder.humanReadableField(Fields.REFRESH_INTERVAL_IN_MILLIS, Fields.REFRESH_INTERVAL, new TimeValue(refreshInterval));
-        if (name != null) {
-            builder.field(Fields.NAME, name);
-        }
-        if (prettyName != null) {
-            builder.field(Fields.PRETTY_NAME, prettyName);
-        }
-        if (arch != null) {
-            builder.field(Fields.ARCH, arch);
-        }
-        if (version != null) {
-            builder.field(Fields.VERSION, version);
-        }
-        builder.field(Fields.AVAILABLE_PROCESSORS, availableProcessors);
-        builder.field(Fields.ALLOCATED_PROCESSORS, allocatedProcessors);
-        builder.endObject();
-        return builder;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/monitor/os/ProtobufOsService.java b/server/src/main/java/org/opensearch/monitor/os/ProtobufOsService.java
deleted file mode 100644
index 37ecaf2b5269f..0000000000000
--- a/server/src/main/java/org/opensearch/monitor/os/ProtobufOsService.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * 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.
- */
-
-package org.opensearch.monitor.os;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.opensearch.common.settings.Setting;
-import org.opensearch.common.settings.Setting.Property;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.common.util.SingleObjectCache;
-import org.opensearch.common.util.concurrent.OpenSearchExecutors;
-import org.opensearch.node.ProtobufReportingService;
-
-import java.io.IOException;
-
-/**
- * Service for the Operating System
- *
- * @opensearch.internal
- */
-public class ProtobufOsService implements ProtobufReportingService<ProtobufOsInfo> {
-
-    private static final Logger logger = LogManager.getLogger(ProtobufOsService.class);
-
-    private final OsProbe probe;
-    private final ProtobufOsInfo info;
-    private final SingleObjectCache<ProtobufOsStats> osStatsCache;
-
-    public static final Setting<TimeValue> REFRESH_INTERVAL_SETTING = Setting.timeSetting(
-        "monitor.os.refresh_interval",
-        TimeValue.timeValueSeconds(1),
-        TimeValue.timeValueSeconds(1),
-        Property.NodeScope
-    );
-
-    public ProtobufOsService(Settings settings) throws IOException {
-        this.probe = OsProbe.getInstance();
-        TimeValue refreshInterval = REFRESH_INTERVAL_SETTING.get(settings);
-        this.info = probe.protobufOsInfo(refreshInterval.millis(), OpenSearchExecutors.allocatedProcessors(settings));
-        this.osStatsCache = new OsStatsCache(refreshInterval, probe.protobufOsStats());
-        logger.debug("using refresh_interval [{}]", refreshInterval);
-    }
-
-    @Override
-    public ProtobufOsInfo protobufInfo() {
-        return this.info;
-    }
-
-    public synchronized ProtobufOsStats stats() {
-        return osStatsCache.getOrRefresh();
-    }
-
-    private class OsStatsCache extends SingleObjectCache<ProtobufOsStats> {
-        OsStatsCache(TimeValue interval, ProtobufOsStats initValue) {
-            super(interval, initValue);
-        }
-
-        @Override
-        protected ProtobufOsStats refresh() {
-            return probe.protobufOsStats();
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/monitor/os/ProtobufOsStats.java b/server/src/main/java/org/opensearch/monitor/os/ProtobufOsStats.java
deleted file mode 100644
index c822711ea273c..0000000000000
--- a/server/src/main/java/org/opensearch/monitor/os/ProtobufOsStats.java
+++ /dev/null
@@ -1,610 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.monitor.os;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.Objects;
-
-/**
- * Holds stats for the Operating System
-*
-* @opensearch.internal
-*/
-public class ProtobufOsStats implements ProtobufWriteable, ToXContentFragment {
-
-    private final long timestamp;
-    private final Cpu cpu;
-    private final Mem mem;
-    private final Swap swap;
-    private final Cgroup cgroup;
-
-    public ProtobufOsStats(final long timestamp, final Cpu cpu, final Mem mem, final Swap swap, final Cgroup cgroup) {
-        this.timestamp = timestamp;
-        this.cpu = Objects.requireNonNull(cpu);
-        this.mem = Objects.requireNonNull(mem);
-        this.swap = Objects.requireNonNull(swap);
-        this.cgroup = cgroup;
-    }
-
-    public ProtobufOsStats(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        this.timestamp = in.readInt64();
-        this.cpu = new Cpu(in);
-        this.mem = new Mem(in);
-        this.swap = new Swap(in);
-        this.cgroup = protobufStreamInput.readOptionalWriteable(Cgroup::new);
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeInt64NoTag(timestamp);
-        cpu.writeTo(out);
-        mem.writeTo(out);
-        swap.writeTo(out);
-        protobufStreamOutput.writeOptionalWriteable(cgroup);
-    }
-
-    public long getTimestamp() {
-        return timestamp;
-    }
-
-    public Cpu getCpu() {
-        return cpu;
-    }
-
-    public Mem getMem() {
-        return mem;
-    }
-
-    public Swap getSwap() {
-        return swap;
-    }
-
-    public Cgroup getCgroup() {
-        return cgroup;
-    }
-
-    static final class Fields {
-        static final String OS = "os";
-        static final String TIMESTAMP = "timestamp";
-        static final String CPU = "cpu";
-        static final String PERCENT = "percent";
-        static final String LOAD_AVERAGE = "load_average";
-        static final String LOAD_AVERAGE_1M = "1m";
-        static final String LOAD_AVERAGE_5M = "5m";
-        static final String LOAD_AVERAGE_15M = "15m";
-
-        static final String MEM = "mem";
-        static final String SWAP = "swap";
-        static final String FREE = "free";
-        static final String FREE_IN_BYTES = "free_in_bytes";
-        static final String USED = "used";
-        static final String USED_IN_BYTES = "used_in_bytes";
-        static final String TOTAL = "total";
-        static final String TOTAL_IN_BYTES = "total_in_bytes";
-
-        static final String FREE_PERCENT = "free_percent";
-        static final String USED_PERCENT = "used_percent";
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.OS);
-        builder.field(Fields.TIMESTAMP, getTimestamp());
-        cpu.toXContent(builder, params);
-        mem.toXContent(builder, params);
-        swap.toXContent(builder, params);
-        if (cgroup != null) {
-            cgroup.toXContent(builder, params);
-        }
-        builder.endObject();
-        return builder;
-    }
-
-    /**
-     * CPU Information.
-    *
-    * @opensearch.internal
-    */
-    public static class Cpu implements ProtobufWriteable, ToXContentFragment {
-
-        private final short percent;
-        private final double[] loadAverage;
-
-        public Cpu(short systemCpuPercent, double[] systemLoadAverage) {
-            this.percent = systemCpuPercent;
-            this.loadAverage = systemLoadAverage;
-        }
-
-        public Cpu(CodedInputStream in) throws IOException {
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-            this.percent = protobufStreamInput.readShort();
-            if (in.readBool()) {
-                this.loadAverage = protobufStreamInput.readDoubleArray();
-            } else {
-                this.loadAverage = null;
-            }
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            protobufStreamOutput.writeShort(percent);
-            if (loadAverage == null) {
-                out.writeBoolNoTag(false);
-            } else {
-                out.writeBoolNoTag(true);
-                protobufStreamOutput.writeDoubleArray(loadAverage);
-            }
-        }
-
-        public short getPercent() {
-            return percent;
-        }
-
-        public double[] getLoadAverage() {
-            return loadAverage;
-        }
-
-        @Override
-        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-            builder.startObject(Fields.CPU);
-            builder.field(Fields.PERCENT, getPercent());
-            if (getLoadAverage() != null && Arrays.stream(getLoadAverage()).anyMatch(load -> load != -1)) {
-                builder.startObject(Fields.LOAD_AVERAGE);
-                if (getLoadAverage()[0] != -1) {
-                    builder.field(Fields.LOAD_AVERAGE_1M, getLoadAverage()[0]);
-                }
-                if (getLoadAverage()[1] != -1) {
-                    builder.field(Fields.LOAD_AVERAGE_5M, getLoadAverage()[1]);
-                }
-                if (getLoadAverage()[2] != -1) {
-                    builder.field(Fields.LOAD_AVERAGE_15M, getLoadAverage()[2]);
-                }
-                builder.endObject();
-            }
-            builder.endObject();
-            return builder;
-        }
-    }
-
-    /**
-     * Swap information.
-    *
-    * @opensearch.internal
-    */
-    public static class Swap implements ProtobufWriteable, ToXContentFragment {
-
-        private static final Logger logger = LogManager.getLogger(Swap.class);
-
-        private final long total;
-        private final long free;
-
-        public Swap(long total, long free) {
-            assert total >= 0 : "expected total swap to be positive, got: " + total;
-            assert free >= 0 : "expected free swap to be positive, got: " + total;
-            this.total = total;
-            this.free = free;
-        }
-
-        public Swap(CodedInputStream in) throws IOException {
-            this.total = in.readInt64();
-            assert total >= 0 : "expected total swap to be positive, got: " + total;
-            this.free = in.readInt64();
-            assert free >= 0 : "expected free swap to be positive, got: " + total;
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeInt64NoTag(total);
-            out.writeInt64NoTag(free);
-        }
-
-        public ByteSizeValue getFree() {
-            return new ByteSizeValue(free);
-        }
-
-        public ByteSizeValue getUsed() {
-            if (total == 0) {
-                // The work in https://github.com/elastic/elasticsearch/pull/42725 established that total memory
-                // can be reported as negative in some cases. Swap can similarly be reported as negative and in
-                // those cases, we force it to zero in which case we can no longer correctly report the used swap
-                // as (total-free) and should report it as zero.
-                //
-                // We intentionally check for (total == 0) rather than (total - free < 0) so as not to hide
-                // cases where (free > total) which would be a different bug.
-                if (free > 0) {
-                    logger.debug("cannot compute used swap when total swap is 0 and free swap is " + free);
-                }
-                return new ByteSizeValue(0);
-            }
-            return new ByteSizeValue(total - free);
-        }
-
-        public ByteSizeValue getTotal() {
-            return new ByteSizeValue(total);
-        }
-
-        @Override
-        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-            builder.startObject(Fields.SWAP);
-            builder.humanReadableField(Fields.TOTAL_IN_BYTES, Fields.TOTAL, getTotal());
-            builder.humanReadableField(Fields.FREE_IN_BYTES, Fields.FREE, getFree());
-            builder.humanReadableField(Fields.USED_IN_BYTES, Fields.USED, getUsed());
-            builder.endObject();
-            return builder;
-        }
-    }
-
-    /**
-     * OS Memory information.
-    *
-    * @opensearch.internal
-    */
-    public static class Mem implements ProtobufWriteable, ToXContentFragment {
-
-        private static final Logger logger = LogManager.getLogger(Mem.class);
-
-        private final long total;
-        private final long free;
-
-        public Mem(long total, long free) {
-            assert total >= 0 : "expected total memory to be positive, got: " + total;
-            assert free >= 0 : "expected free memory to be positive, got: " + total;
-            this.total = total;
-            this.free = free;
-        }
-
-        public Mem(CodedInputStream in) throws IOException {
-            this.total = in.readInt64();
-            assert total >= 0 : "expected total memory to be positive, got: " + total;
-            this.free = in.readInt64();
-            assert free >= 0 : "expected free memory to be positive, got: " + total;
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeInt64NoTag(total);
-            out.writeInt64NoTag(free);
-        }
-
-        public ByteSizeValue getTotal() {
-            return new ByteSizeValue(total);
-        }
-
-        public ByteSizeValue getUsed() {
-            if (total == 0) {
-                // The work in https://github.com/elastic/elasticsearch/pull/42725 established that total memory
-                // can be reported as negative in some cases. In those cases, we force it to zero in which case
-                // we can no longer correctly report the used memory as (total-free) and should report it as zero.
-                //
-                // We intentionally check for (total == 0) rather than (total - free < 0) so as not to hide
-                // cases where (free > total) which would be a different bug.
-                if (free > 0) {
-                    logger.debug("cannot compute used memory when total memory is 0 and free memory is " + free);
-                }
-                return new ByteSizeValue(0);
-            }
-            return new ByteSizeValue(total - free);
-        }
-
-        public short getUsedPercent() {
-            return calculatePercentage(getUsed().getBytes(), total);
-        }
-
-        public ByteSizeValue getFree() {
-            return new ByteSizeValue(free);
-        }
-
-        public short getFreePercent() {
-            return calculatePercentage(free, total);
-        }
-
-        @Override
-        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-            builder.startObject(Fields.MEM);
-            builder.humanReadableField(Fields.TOTAL_IN_BYTES, Fields.TOTAL, getTotal());
-            builder.humanReadableField(Fields.FREE_IN_BYTES, Fields.FREE, getFree());
-            builder.humanReadableField(Fields.USED_IN_BYTES, Fields.USED, getUsed());
-            builder.field(Fields.FREE_PERCENT, getFreePercent());
-            builder.field(Fields.USED_PERCENT, getUsedPercent());
-            builder.endObject();
-            return builder;
-        }
-    }
-
-    /**
-     * Encapsulates basic cgroup statistics.
-    *
-    * @opensearch.internal
-    */
-    public static class Cgroup implements ProtobufWriteable, ToXContentFragment {
-
-        private final String cpuAcctControlGroup;
-        private final long cpuAcctUsageNanos;
-        private final String cpuControlGroup;
-        private final long cpuCfsPeriodMicros;
-        private final long cpuCfsQuotaMicros;
-        private final CpuStat cpuStat;
-        // These will be null for nodes running versions prior to 6.1.0
-        private final String memoryControlGroup;
-        private final String memoryLimitInBytes;
-        private final String memoryUsageInBytes;
-
-        /**
-         * The control group for the {@code cpuacct} subsystem.
-        *
-        * @return the control group
-        */
-        public String getCpuAcctControlGroup() {
-            return cpuAcctControlGroup;
-        }
-
-        /**
-         * The total CPU time consumed by all tasks in the
-        * {@code cpuacct} control group from
-        * {@link Cgroup#cpuAcctControlGroup}.
-        *
-        * @return the total CPU time in nanoseconds
-        */
-        public long getCpuAcctUsageNanos() {
-            return cpuAcctUsageNanos;
-        }
-
-        /**
-         * The control group for the {@code cpu} subsystem.
-        *
-        * @return the control group
-        */
-        public String getCpuControlGroup() {
-            return cpuControlGroup;
-        }
-
-        /**
-         * The period of time for how frequently the control group from
-        * {@link Cgroup#cpuControlGroup} has its access to CPU
-        * resources reallocated.
-        *
-        * @return the period of time in microseconds
-        */
-        public long getCpuCfsPeriodMicros() {
-            return cpuCfsPeriodMicros;
-        }
-
-        /**
-         * The total amount of time for which all tasks in the control
-        * group from {@link Cgroup#cpuControlGroup} can run in one
-        * period as represented by {@link Cgroup#cpuCfsPeriodMicros}.
-        *
-        * @return the total amount of time in microseconds
-        */
-        public long getCpuCfsQuotaMicros() {
-            return cpuCfsQuotaMicros;
-        }
-
-        /**
-         * The CPU time statistics. See {@link CpuStat}.
-        *
-        * @return the CPU time statistics.
-        */
-        public CpuStat getCpuStat() {
-            return cpuStat;
-        }
-
-        /**
-         * The control group for the {@code memory} subsystem.
-        *
-        * @return the control group
-        */
-        public String getMemoryControlGroup() {
-            return memoryControlGroup;
-        }
-
-        /**
-         * The maximum amount of user memory (including file cache).
-        * This is stored as a <code>String</code> because the value can be too big to fit in a
-        * <code>long</code>.  (The alternative would have been <code>BigInteger</code> but then
-        * it would not be possible to index the OS stats document into OpenSearch without
-        * losing information, as <code>BigInteger</code> is not a supported OpenSearch type.)
-        *
-        * @return the maximum amount of user memory (including file cache).
-        */
-        public String getMemoryLimitInBytes() {
-            return memoryLimitInBytes;
-        }
-
-        /**
-         * The total current memory usage by processes in the cgroup (in bytes).
-        * This is stored as a <code>String</code> for consistency with <code>memoryLimitInBytes</code>.
-        *
-        * @return the total current memory usage by processes in the cgroup (in bytes).
-        */
-        public String getMemoryUsageInBytes() {
-            return memoryUsageInBytes;
-        }
-
-        public Cgroup(
-            final String cpuAcctControlGroup,
-            final long cpuAcctUsageNanos,
-            final String cpuControlGroup,
-            final long cpuCfsPeriodMicros,
-            final long cpuCfsQuotaMicros,
-            final CpuStat cpuStat,
-            final String memoryControlGroup,
-            final String memoryLimitInBytes,
-            final String memoryUsageInBytes
-        ) {
-            this.cpuAcctControlGroup = Objects.requireNonNull(cpuAcctControlGroup);
-            this.cpuAcctUsageNanos = cpuAcctUsageNanos;
-            this.cpuControlGroup = Objects.requireNonNull(cpuControlGroup);
-            this.cpuCfsPeriodMicros = cpuCfsPeriodMicros;
-            this.cpuCfsQuotaMicros = cpuCfsQuotaMicros;
-            this.cpuStat = Objects.requireNonNull(cpuStat);
-            this.memoryControlGroup = memoryControlGroup;
-            this.memoryLimitInBytes = memoryLimitInBytes;
-            this.memoryUsageInBytes = memoryUsageInBytes;
-        }
-
-        Cgroup(final CodedInputStream in) throws IOException {
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-            cpuAcctControlGroup = in.readString();
-            cpuAcctUsageNanos = in.readInt64();
-            cpuControlGroup = in.readString();
-            cpuCfsPeriodMicros = in.readInt64();
-            cpuCfsQuotaMicros = in.readInt64();
-            cpuStat = new CpuStat(in);
-            memoryControlGroup = protobufStreamInput.readOptionalString();
-            memoryLimitInBytes = protobufStreamInput.readOptionalString();
-            memoryUsageInBytes = protobufStreamInput.readOptionalString();
-        }
-
-        @Override
-        public void writeTo(final CodedOutputStream out) throws IOException {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            out.writeStringNoTag(cpuAcctControlGroup);
-            out.writeInt64NoTag(cpuAcctUsageNanos);
-            out.writeStringNoTag(cpuControlGroup);
-            out.writeInt64NoTag(cpuCfsPeriodMicros);
-            out.writeInt64NoTag(cpuCfsQuotaMicros);
-            cpuStat.writeTo(out);
-            protobufStreamOutput.writeOptionalString(memoryControlGroup);
-            protobufStreamOutput.writeOptionalString(memoryLimitInBytes);
-            protobufStreamOutput.writeOptionalString(memoryUsageInBytes);
-        }
-
-        @Override
-        public XContentBuilder toXContent(final XContentBuilder builder, final Params params) throws IOException {
-            builder.startObject("cgroup");
-            {
-                builder.startObject("cpuacct");
-                {
-                    builder.field("control_group", cpuAcctControlGroup);
-                    builder.field("usage_nanos", cpuAcctUsageNanos);
-                }
-                builder.endObject();
-                builder.startObject("cpu");
-                {
-                    builder.field("control_group", cpuControlGroup);
-                    builder.field("cfs_period_micros", cpuCfsPeriodMicros);
-                    builder.field("cfs_quota_micros", cpuCfsQuotaMicros);
-                    cpuStat.toXContent(builder, params);
-                }
-                builder.endObject();
-                if (memoryControlGroup != null) {
-                    builder.startObject("memory");
-                    {
-                        builder.field("control_group", memoryControlGroup);
-                        if (memoryLimitInBytes != null) {
-                            builder.field("limit_in_bytes", memoryLimitInBytes);
-                        }
-                        if (memoryUsageInBytes != null) {
-                            builder.field("usage_in_bytes", memoryUsageInBytes);
-                        }
-                    }
-                    builder.endObject();
-                }
-            }
-            builder.endObject();
-            return builder;
-        }
-
-        /**
-         * Encapsulates CPU time statistics.
-        *
-        * @opensearch.internal
-        */
-        public static class CpuStat implements ProtobufWriteable, ToXContentFragment {
-
-            private final long numberOfElapsedPeriods;
-            private final long numberOfTimesThrottled;
-            private final long timeThrottledNanos;
-
-            /**
-             * The number of elapsed periods.
-            *
-            * @return the number of elapsed periods as measured by
-            * {@code cpu.cfs_period_us}
-            */
-            public long getNumberOfElapsedPeriods() {
-                return numberOfElapsedPeriods;
-            }
-
-            /**
-             * The number of times tasks in the control group have been
-            * throttled.
-            *
-            * @return the number of times
-            */
-            public long getNumberOfTimesThrottled() {
-                return numberOfTimesThrottled;
-            }
-
-            /**
-             * The total time duration for which tasks in the control
-            * group have been throttled.
-            *
-            * @return the total time in nanoseconds
-            */
-            public long getTimeThrottledNanos() {
-                return timeThrottledNanos;
-            }
-
-            public CpuStat(final long numberOfElapsedPeriods, final long numberOfTimesThrottled, final long timeThrottledNanos) {
-                this.numberOfElapsedPeriods = numberOfElapsedPeriods;
-                this.numberOfTimesThrottled = numberOfTimesThrottled;
-                this.timeThrottledNanos = timeThrottledNanos;
-            }
-
-            CpuStat(final CodedInputStream in) throws IOException {
-                numberOfElapsedPeriods = in.readInt64();
-                numberOfTimesThrottled = in.readInt64();
-                timeThrottledNanos = in.readInt64();
-            }
-
-            @Override
-            public void writeTo(final CodedOutputStream out) throws IOException {
-                out.writeInt64NoTag(numberOfElapsedPeriods);
-                out.writeInt64NoTag(numberOfTimesThrottled);
-                out.writeInt64NoTag(timeThrottledNanos);
-            }
-
-            @Override
-            public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-                builder.startObject("stat");
-                {
-                    builder.field("number_of_elapsed_periods", numberOfElapsedPeriods);
-                    builder.field("number_of_times_throttled", numberOfTimesThrottled);
-                    builder.field("time_throttled_nanos", timeThrottledNanos);
-                }
-                builder.endObject();
-                return builder;
-            }
-
-        }
-
-    }
-
-    public static short calculatePercentage(long used, long max) {
-        return max <= 0 ? 0 : (short) (Math.round((100d * used) / max));
-    }
-
-}
diff --git a/server/src/main/java/org/opensearch/monitor/process/ProcessProbe.java b/server/src/main/java/org/opensearch/monitor/process/ProcessProbe.java
index aa3b535cf0d30..c2f83003d2c04 100644
--- a/server/src/main/java/org/opensearch/monitor/process/ProcessProbe.java
+++ b/server/src/main/java/org/opensearch/monitor/process/ProcessProbe.java
@@ -147,22 +147,12 @@ public ProcessInfo processInfo(long refreshInterval) {
         return new ProcessInfo(jvmInfo().pid(), BootstrapInfo.isMemoryLocked(), refreshInterval);
     }
 
-    public ProtobufProcessInfo protobufProcessInfo(long refreshInterval) {
-        return new ProtobufProcessInfo(jvmInfo().pid(), BootstrapInfo.isMemoryLocked(), refreshInterval);
-    }
-
     public ProcessStats processStats() {
         ProcessStats.Cpu cpu = new ProcessStats.Cpu(getProcessCpuPercent(), getProcessCpuTotalTime());
         ProcessStats.Mem mem = new ProcessStats.Mem(getTotalVirtualMemorySize());
         return new ProcessStats(System.currentTimeMillis(), getOpenFileDescriptorCount(), getMaxFileDescriptorCount(), cpu, mem);
     }
 
-    public ProtobufProcessStats processProtobufStats() {
-        ProtobufProcessStats.Cpu cpu = new ProtobufProcessStats.Cpu(getProcessCpuPercent(), getProcessCpuTotalTime());
-        ProtobufProcessStats.Mem mem = new ProtobufProcessStats.Mem(getTotalVirtualMemorySize());
-        return new ProtobufProcessStats(System.currentTimeMillis(), getOpenFileDescriptorCount(), getMaxFileDescriptorCount(), cpu, mem);
-    }
-
     /**
      * Returns a given method of the OperatingSystemMXBean,
      * or null if the method is not found or unavailable.
diff --git a/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessInfo.java b/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessInfo.java
deleted file mode 100644
index 7c9895411fbd1..0000000000000
--- a/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessInfo.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.monitor.process;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.node.ProtobufReportingService;
-
-import java.io.IOException;
-
-/**
- * Holds information for monitoring the process
-*
-* @opensearch.internal
-*/
-public class ProtobufProcessInfo implements ProtobufReportingService.ProtobufInfo {
-
-    private final long refreshInterval;
-    private final long id;
-    private final boolean mlockall;
-
-    public ProtobufProcessInfo(long id, boolean mlockall, long refreshInterval) {
-        this.id = id;
-        this.mlockall = mlockall;
-        this.refreshInterval = refreshInterval;
-    }
-
-    public ProtobufProcessInfo(CodedInputStream in) throws IOException {
-        refreshInterval = in.readInt64();
-        id = in.readInt64();
-        mlockall = in.readBool();
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(refreshInterval);
-        out.writeInt64NoTag(id);
-        out.writeBoolNoTag(mlockall);
-    }
-
-    public long refreshInterval() {
-        return this.refreshInterval;
-    }
-
-    public long getRefreshInterval() {
-        return this.refreshInterval;
-    }
-
-    /**
-     * The process id.
-    */
-    public long getId() {
-        return id;
-    }
-
-    public boolean isMlockall() {
-        return mlockall;
-    }
-
-    static final class Fields {
-        static final String PROCESS = "process";
-        static final String REFRESH_INTERVAL = "refresh_interval";
-        static final String REFRESH_INTERVAL_IN_MILLIS = "refresh_interval_in_millis";
-        static final String ID = "id";
-        static final String MLOCKALL = "mlockall";
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.PROCESS);
-        builder.humanReadableField(Fields.REFRESH_INTERVAL_IN_MILLIS, Fields.REFRESH_INTERVAL, new TimeValue(refreshInterval));
-        builder.field(Fields.ID, id);
-        builder.field(Fields.MLOCKALL, mlockall);
-        builder.endObject();
-        return builder;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessService.java b/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessService.java
deleted file mode 100644
index 6de862abc7e9e..0000000000000
--- a/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessService.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * 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.
- */
-
-package org.opensearch.monitor.process;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.opensearch.common.settings.Setting;
-import org.opensearch.common.settings.Setting.Property;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.common.util.SingleObjectCache;
-import org.opensearch.node.ProtobufReportingService;
-
-/**
- * The service for the process
- *
- * @opensearch.internal
- */
-public final class ProtobufProcessService implements ProtobufReportingService<ProtobufProcessInfo> {
-
-    private static final Logger logger = LogManager.getLogger(ProtobufProcessService.class);
-
-    private final ProcessProbe probe;
-    private final ProtobufProcessInfo info;
-    private final SingleObjectCache<ProtobufProcessStats> processStatsCache;
-
-    public static final Setting<TimeValue> REFRESH_INTERVAL_SETTING = Setting.timeSetting(
-        "monitor.process.refresh_interval",
-        TimeValue.timeValueSeconds(1),
-        TimeValue.timeValueSeconds(1),
-        Property.NodeScope
-    );
-
-    public ProtobufProcessService(Settings settings) {
-        this.probe = ProcessProbe.getInstance();
-        final TimeValue refreshInterval = REFRESH_INTERVAL_SETTING.get(settings);
-        processStatsCache = new ProcessStatsCache(refreshInterval, probe.processProtobufStats());
-        this.info = probe.protobufProcessInfo(refreshInterval.millis());
-        logger.debug("using refresh_interval [{}]", refreshInterval);
-    }
-
-    @Override
-    public ProtobufProcessInfo protobufInfo() {
-        return this.info;
-    }
-
-    public ProtobufProcessStats stats() {
-        return processStatsCache.getOrRefresh();
-    }
-
-    private class ProcessStatsCache extends SingleObjectCache<ProtobufProcessStats> {
-        ProcessStatsCache(TimeValue interval, ProtobufProcessStats initValue) {
-            super(interval, initValue);
-        }
-
-        @Override
-        protected ProtobufProcessStats refresh() {
-            return probe.processProtobufStats();
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessStats.java b/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessStats.java
deleted file mode 100644
index ff24e4eb66357..0000000000000
--- a/server/src/main/java/org/opensearch/monitor/process/ProtobufProcessStats.java
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.monitor.process;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-
-/**
- * Holds stats for the process
-*
-* @opensearch.internal
-*/
-public class ProtobufProcessStats implements ProtobufWriteable, ToXContentFragment {
-
-    private final long timestamp;
-    private final long openFileDescriptors;
-    private final long maxFileDescriptors;
-    private final Cpu cpu;
-    private final Mem mem;
-
-    public ProtobufProcessStats(long timestamp, long openFileDescriptors, long maxFileDescriptors, Cpu cpu, Mem mem) {
-        this.timestamp = timestamp;
-        this.openFileDescriptors = openFileDescriptors;
-        this.maxFileDescriptors = maxFileDescriptors;
-        this.cpu = cpu;
-        this.mem = mem;
-    }
-
-    public ProtobufProcessStats(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        timestamp = in.readInt64();
-        openFileDescriptors = in.readInt64();
-        maxFileDescriptors = in.readInt64();
-        cpu = protobufStreamInput.readOptionalWriteable(Cpu::new);
-        mem = protobufStreamInput.readOptionalWriteable(Mem::new);
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeInt64NoTag(timestamp);
-        out.writeInt64NoTag(openFileDescriptors);
-        out.writeInt64NoTag(maxFileDescriptors);
-        protobufStreamOutput.writeOptionalWriteable(cpu);
-        protobufStreamOutput.writeOptionalWriteable(mem);
-    }
-
-    public long getTimestamp() {
-        return timestamp;
-    }
-
-    public long getOpenFileDescriptors() {
-        return openFileDescriptors;
-    }
-
-    public long getMaxFileDescriptors() {
-        return maxFileDescriptors;
-    }
-
-    public Cpu getCpu() {
-        return cpu;
-    }
-
-    public Mem getMem() {
-        return mem;
-    }
-
-    static final class Fields {
-        static final String PROCESS = "process";
-        static final String TIMESTAMP = "timestamp";
-        static final String OPEN_FILE_DESCRIPTORS = "open_file_descriptors";
-        static final String MAX_FILE_DESCRIPTORS = "max_file_descriptors";
-
-        static final String CPU = "cpu";
-        static final String PERCENT = "percent";
-        static final String TOTAL = "total";
-        static final String TOTAL_IN_MILLIS = "total_in_millis";
-
-        static final String MEM = "mem";
-        static final String TOTAL_VIRTUAL = "total_virtual";
-        static final String TOTAL_VIRTUAL_IN_BYTES = "total_virtual_in_bytes";
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.PROCESS);
-        builder.field(Fields.TIMESTAMP, timestamp);
-        builder.field(Fields.OPEN_FILE_DESCRIPTORS, openFileDescriptors);
-        builder.field(Fields.MAX_FILE_DESCRIPTORS, maxFileDescriptors);
-        if (cpu != null) {
-            builder.startObject(Fields.CPU);
-            builder.field(Fields.PERCENT, cpu.percent);
-            builder.humanReadableField(Fields.TOTAL_IN_MILLIS, Fields.TOTAL, new TimeValue(cpu.total));
-            builder.endObject();
-        }
-        if (mem != null) {
-            builder.startObject(Fields.MEM);
-            builder.humanReadableField(Fields.TOTAL_VIRTUAL_IN_BYTES, Fields.TOTAL_VIRTUAL, new ByteSizeValue(mem.totalVirtual));
-            builder.endObject();
-        }
-        builder.endObject();
-        return builder;
-    }
-
-    /**
-     * Process memory information.
-    *
-    * @opensearch.internal
-    */
-    public static class Mem implements ProtobufWriteable {
-
-        private final long totalVirtual;
-
-        public Mem(long totalVirtual) {
-            this.totalVirtual = totalVirtual;
-        }
-
-        public Mem(CodedInputStream in) throws IOException {
-            totalVirtual = in.readInt64();
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeInt64NoTag(totalVirtual);
-        }
-
-        public ByteSizeValue getTotalVirtual() {
-            return new ByteSizeValue(totalVirtual);
-        }
-    }
-
-    /**
-     * Process CPU information.
-    *
-    * @opensearch.internal
-    */
-    public static class Cpu implements ProtobufWriteable {
-
-        private final short percent;
-        private final long total;
-
-        public Cpu(short percent, long total) {
-            this.percent = percent;
-            this.total = total;
-        }
-
-        public Cpu(CodedInputStream in) throws IOException {
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-            percent = protobufStreamInput.readShort();
-            total = in.readInt64();
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            protobufStreamOutput.writeShort(percent);
-            out.writeInt64NoTag(total);
-        }
-
-        /**
-         * Get the Process cpu usage.
-        * <p>
-        * Supported Platforms: All.
-        */
-        public short getPercent() {
-            return percent;
-        }
-
-        /**
-         * Get the Process cpu time (sum of User and Sys).
-        * <p>
-        * Supported Platforms: All.
-        */
-        public TimeValue getTotal() {
-            return new TimeValue(total);
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/node/Node.java b/server/src/main/java/org/opensearch/node/Node.java
index 5c24180cc7cec..14da625deaa50 100644
--- a/server/src/main/java/org/opensearch/node/Node.java
+++ b/server/src/main/java/org/opensearch/node/Node.java
@@ -179,7 +179,6 @@
 import org.opensearch.indices.store.IndicesStore;
 import org.opensearch.ingest.IngestService;
 import org.opensearch.monitor.MonitorService;
-import org.opensearch.monitor.ProtobufMonitorService;
 import org.opensearch.monitor.fs.FsHealthService;
 import org.opensearch.monitor.jvm.JvmInfo;
 import org.opensearch.persistent.PersistentTasksClusterService;
@@ -646,12 +645,6 @@ protected Node(
             initializeFileCache(settings, circuitBreakerService.getBreaker(CircuitBreaker.REQUEST));
             final FileCacheCleaner fileCacheCleaner = new FileCacheCleaner(nodeEnvironment, fileCache);
             final MonitorService monitorService = new MonitorService(settings, nodeEnvironment, threadPool, fileCache);
-            final ProtobufMonitorService protobufMonitorService = new ProtobufMonitorService(
-                settings,
-                nodeEnvironment,
-                threadPool,
-                fileCache
-            );
 
             pluginsService.filterPlugins(CircuitBreakerPlugin.class).forEach(plugin -> {
                 CircuitBreaker breaker = circuitBreakerService.getBreaker(plugin.getCircuitBreaker(settings).getName());
@@ -1059,7 +1052,7 @@ protected Node(
             this.protobufNodeService = new ProtobufNodeService(
                 settings,
                 threadPool,
-                protobufMonitorService,
+                monitorService,
                 discoveryModule.getDiscovery(),
                 transportService,
                 indicesService,
diff --git a/server/src/main/java/org/opensearch/node/ProtobufAdaptiveSelectionStats.java b/server/src/main/java/org/opensearch/node/ProtobufAdaptiveSelectionStats.java
deleted file mode 100644
index da47e0226b69a..0000000000000
--- a/server/src/main/java/org/opensearch/node/ProtobufAdaptiveSelectionStats.java
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.node;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.common.util.set.Sets;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.TimeUnit;
-import java.util.stream.Collectors;
-
-/**
- * Class representing statistics about adaptive replica selection. This includes
-* EWMA of queue size, service time, and response time, as well as outgoing
-* searches to each node and the "rank" based on the ARS formula.
-*
-* @opensearch.internal
-*/
-public class ProtobufAdaptiveSelectionStats implements ProtobufWriteable, ToXContentFragment {
-
-    private final Map<String, Long> clientOutgoingConnections;
-    private final Map<String, ResponseCollectorService.ProtobufComputedNodeStats> nodeComputedStats;
-
-    public ProtobufAdaptiveSelectionStats(
-        Map<String, Long> clientConnections,
-        Map<String, ResponseCollectorService.ProtobufComputedNodeStats> nodeComputedStats
-    ) {
-        this.clientOutgoingConnections = clientConnections;
-        this.nodeComputedStats = nodeComputedStats;
-    }
-
-    public ProtobufAdaptiveSelectionStats(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        this.clientOutgoingConnections = protobufStreamInput.readMap(CodedInputStream::readString, CodedInputStream::readInt64);
-        this.nodeComputedStats = protobufStreamInput.readMap(
-            CodedInputStream::readString,
-            ResponseCollectorService.ProtobufComputedNodeStats::new
-        );
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeMap(
-            this.clientOutgoingConnections,
-            CodedOutputStream::writeStringNoTag,
-            CodedOutputStream::writeInt64NoTag
-        );
-        protobufStreamOutput.writeMap(
-            this.nodeComputedStats,
-            CodedOutputStream::writeStringNoTag,
-            (stream, stats) -> stats.writeTo(stream)
-        );
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject("adaptive_selection");
-        Set<String> allNodeIds = Sets.union(clientOutgoingConnections.keySet(), nodeComputedStats.keySet());
-        for (String nodeId : allNodeIds) {
-            builder.startObject(nodeId);
-            ResponseCollectorService.ProtobufComputedNodeStats stats = nodeComputedStats.get(nodeId);
-            if (stats != null) {
-                long outgoingSearches = clientOutgoingConnections.getOrDefault(nodeId, 0L);
-                builder.field("outgoing_searches", outgoingSearches);
-                builder.field("avg_queue_size", stats.queueSize);
-                if (builder.humanReadable()) {
-                    builder.field("avg_service_time", new TimeValue((long) stats.serviceTime, TimeUnit.NANOSECONDS).toString());
-                }
-                builder.field("avg_service_time_ns", (long) stats.serviceTime);
-                if (builder.humanReadable()) {
-                    builder.field("avg_response_time", new TimeValue((long) stats.responseTime, TimeUnit.NANOSECONDS).toString());
-                }
-                builder.field("avg_response_time_ns", (long) stats.responseTime);
-                builder.field("rank", String.format(Locale.ROOT, "%.1f", stats.rank(outgoingSearches)));
-            }
-            builder.endObject();
-        }
-        builder.endObject();
-        return builder;
-    }
-
-    /**
-     * Returns a map of node id to the outgoing search requests to that node
-    */
-    public Map<String, Long> getOutgoingConnections() {
-        return clientOutgoingConnections;
-    }
-
-    /**
-     * Returns a map of node id to the computed stats
-    */
-    public Map<String, ResponseCollectorService.ProtobufComputedNodeStats> getComputedStats() {
-        return nodeComputedStats;
-    }
-
-    /**
-     * Returns a map of node id to the ranking of the nodes based on the adaptive replica formula
-    */
-    public Map<String, Double> getRanks() {
-        return nodeComputedStats.entrySet()
-            .stream()
-            .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().rank(clientOutgoingConnections.getOrDefault(e.getKey(), 0L))));
-    }
-}
diff --git a/server/src/main/java/org/opensearch/node/ProtobufNodeClosedException.java b/server/src/main/java/org/opensearch/node/ProtobufNodeClosedException.java
deleted file mode 100644
index a07b7e39cdd0f..0000000000000
--- a/server/src/main/java/org/opensearch/node/ProtobufNodeClosedException.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.node;
-
-import com.google.protobuf.CodedInputStream;
-import org.opensearch.ProtobufOpenSearchException;
-import org.opensearch.cluster.node.DiscoveryNode;
-
-import java.io.IOException;
-
-/**
- * An exception indicating that node is closed.
-*
-* @opensearch.internal
-*/
-public class ProtobufNodeClosedException extends ProtobufOpenSearchException {
-
-    public ProtobufNodeClosedException(DiscoveryNode node) {
-        super("node closed " + node);
-    }
-
-    public ProtobufNodeClosedException(CodedInputStream in) throws IOException {
-        super(in);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/node/ProtobufNodeService.java b/server/src/main/java/org/opensearch/node/ProtobufNodeService.java
index 09b78169db755..8623612e5236a 100644
--- a/server/src/main/java/org/opensearch/node/ProtobufNodeService.java
+++ b/server/src/main/java/org/opensearch/node/ProtobufNodeService.java
@@ -26,7 +26,7 @@
 import org.opensearch.indices.IndicesService;
 import org.opensearch.indices.breaker.CircuitBreakerService;
 import org.opensearch.ingest.IngestService;
-import org.opensearch.monitor.ProtobufMonitorService;
+import org.opensearch.monitor.MonitorService;
 import org.opensearch.plugins.PluginsService;
 import org.opensearch.script.ScriptService;
 import org.opensearch.search.aggregations.support.AggregationUsageService;
@@ -47,7 +47,7 @@
 public class ProtobufNodeService implements Closeable {
     private final Settings settings;
     private final ThreadPool threadPool;
-    private final ProtobufMonitorService monitorService;
+    private final MonitorService monitorService;
     private final TransportService transportService;
     private final IndicesService indicesService;
     private final PluginsService pluginService;
@@ -69,7 +69,7 @@ public class ProtobufNodeService implements Closeable {
     ProtobufNodeService(
         Settings settings,
         ThreadPool threadPool,
-        ProtobufMonitorService monitorService,
+        MonitorService monitorService,
         Discovery discovery,
         TransportService transportService,
         IndicesService indicesService,
@@ -131,37 +131,37 @@ public ProtobufNodeInfo info(
             builder.setSettings(settingsFilter.filter(this.settings));
         }
         if (os) {
-            builder.setOs(monitorService.osService().protobufInfo());
+            builder.setOs(monitorService.osService().info());
         }
         if (process) {
-            builder.setProcess(monitorService.processService().protobufInfo());
+            builder.setProcess(monitorService.processService().info());
         }
         if (jvm) {
-            builder.setJvm(monitorService.jvmService().protobufInfo());
+            builder.setJvm(monitorService.jvmService().info());
         }
         if (threadPool) {
-            builder.setThreadPool(this.threadPool.protobufInfo());
+            builder.setThreadPool(this.threadPool.info());
         }
         if (transport) {
-            builder.setTransport(transportService.protobufInfo());
+            builder.setTransport(transportService.info());
         }
         if (http && httpServerTransport != null) {
-            builder.setHttp(httpServerTransport.protobufInfo());
+            builder.setHttp(httpServerTransport.info());
         }
         // if (plugin && pluginService != null) {
         // builder.setPlugins(pluginService.info());
         // }
         if (ingest && ingestService != null) {
-            builder.setIngest(ingestService.protobufInfo());
+            builder.setIngest(ingestService.info());
         }
         if (aggs && aggregationUsageService != null) {
-            builder.setAggsInfo(aggregationUsageService.protobufInfo());
+            builder.setAggsInfo(aggregationUsageService.info());
         }
         if (indices) {
             builder.setTotalIndexingBuffer(indicesService.getTotalIndexingBufferBytes());
         }
         if (searchPipeline && searchPipelineService != null) {
-            builder.setProtobufSearchPipelineInfo(searchPipelineService.protobufInfo());
+            builder.setProtobufSearchPipelineInfo(searchPipelineService.info());
         }
         return builder.build();
     }
@@ -193,19 +193,19 @@ public ProtobufNodeStats stats(
         return new ProtobufNodeStats(
             transportService.getLocalNode(),
             System.currentTimeMillis(),
-            indices.anySet() ? indicesService.protobufStats(indices) : null,
+            indices.anySet() ? indicesService.stats(indices) : null,
             os ? monitorService.osService().stats() : null,
             process ? monitorService.processService().stats() : null,
             jvm ? monitorService.jvmService().stats() : null,
-            threadPool ? this.threadPool.protobufStats() : null,
+            threadPool ? this.threadPool.stats() : null,
             fs ? monitorService.fsService().stats() : null,
-            transport ? transportService.protobufStats() : null,
-            http ? (httpServerTransport == null ? null : httpServerTransport.protobufStats()) : null,
-            circuitBreaker ? circuitBreakerService.protobufStats() : null,
-            script ? scriptService.protobufStats() : null,
-            discoveryStats ? discovery.protobufStats() : null,
-            ingest ? ingestService.protobufStats() : null,
-            adaptiveSelection ? responseCollectorService.getProtobufAdaptiveStats(searchTransportService.getPendingSearchRequests()) : null
+            transport ? transportService.stats() : null,
+            http ? (httpServerTransport == null ? null : httpServerTransport.stats()) : null,
+            circuitBreaker ? circuitBreakerService.stats() : null,
+            script ? scriptService.stats() : null,
+            discoveryStats ? discovery.stats() : null,
+            ingest ? ingestService.stats() : null,
+            adaptiveSelection ? responseCollectorService.getAdaptiveStats(searchTransportService.getPendingSearchRequests()) : null
             // scriptCache ? scriptService.cacheStats() : null,
             // indexingPressure ? this.indexingPressureService.nodeStats() : null,
             // shardIndexingPressure ? this.indexingPressureService.shardStats(indices) : null,
@@ -220,7 +220,7 @@ public IngestService getIngestService() {
         return ingestService;
     }
 
-    public ProtobufMonitorService getMonitorService() {
+    public MonitorService getMonitorService() {
         return monitorService;
     }
 
diff --git a/server/src/main/java/org/opensearch/node/ResponseCollectorService.java b/server/src/main/java/org/opensearch/node/ResponseCollectorService.java
index 8a527f4ae1161..feae8597c1e81 100644
--- a/server/src/main/java/org/opensearch/node/ResponseCollectorService.java
+++ b/server/src/main/java/org/opensearch/node/ResponseCollectorService.java
@@ -8,8 +8,6 @@
 
 package org.opensearch.node;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import org.opensearch.cluster.ClusterChangedEvent;
 import org.opensearch.cluster.ClusterStateListener;
 import org.opensearch.cluster.node.DiscoveryNode;
@@ -81,22 +79,10 @@ public Map<String, ComputedNodeStats> getAllNodeStatistics() {
         return nodeStats;
     }
 
-    public Map<String, ProtobufComputedNodeStats> getAllNodeStatisticsProtobuf() {
-        final int clientNum = nodeIdToStats.size();
-        // Transform the mutable object internally used for accounting into the computed version
-        Map<String, ProtobufComputedNodeStats> nodeStats = new HashMap<>(nodeIdToStats.size());
-        nodeIdToStats.forEach((k, v) -> { nodeStats.put(k, new ProtobufComputedNodeStats(clientNum, v)); });
-        return nodeStats;
-    }
-
     public AdaptiveSelectionStats getAdaptiveStats(Map<String, Long> clientSearchConnections) {
         return new AdaptiveSelectionStats(clientSearchConnections, getAllNodeStatistics());
     }
 
-    public ProtobufAdaptiveSelectionStats getProtobufAdaptiveStats(Map<String, Long> clientSearchConnections) {
-        return new ProtobufAdaptiveSelectionStats(clientSearchConnections, getAllNodeStatisticsProtobuf());
-    }
-
     /**
      * Optionally return a {@code NodeStatistics} for the given nodeid, if
      * response information exists for the given node. Returns an empty
@@ -210,109 +196,6 @@ public String toString() {
         }
     }
 
-    /**
-     * Struct-like class encapsulating a point-in-time snapshot of a particular
-     * node's statistics. This includes the EWMA of queue size, response time,
-     * and service time.
-     */
-    public static class ProtobufComputedNodeStats implements ProtobufWriteable {
-        // We store timestamps with nanosecond precision, however, the
-        // formula specifies milliseconds, therefore we need to convert
-        // the values so the times don't unduely weight the formula
-        private final double FACTOR = 1000000.0;
-        private final int clientNum;
-
-        private double cachedRank = 0;
-
-        public final String nodeId;
-        public final int queueSize;
-        public final double responseTime;
-        public final double serviceTime;
-
-        public ProtobufComputedNodeStats(String nodeId, int clientNum, int queueSize, double responseTime, double serviceTime) {
-            this.nodeId = nodeId;
-            this.clientNum = clientNum;
-            this.queueSize = queueSize;
-            this.responseTime = responseTime;
-            this.serviceTime = serviceTime;
-        }
-
-        ProtobufComputedNodeStats(int clientNum, NodeStatistics nodeStats) {
-            this(
-                nodeStats.nodeId,
-                clientNum,
-                (int) nodeStats.queueSize.getAverage(),
-                nodeStats.responseTime.getAverage(),
-                nodeStats.serviceTime
-            );
-        }
-
-        ProtobufComputedNodeStats(CodedInputStream in) throws IOException {
-            this.nodeId = in.readString();
-            this.clientNum = in.readInt32();
-            this.queueSize = in.readInt32();
-            this.responseTime = in.readDouble();
-            this.serviceTime = in.readDouble();
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeStringNoTag(this.nodeId);
-            out.writeInt32NoTag(this.clientNum);
-            out.writeInt32NoTag(this.queueSize);
-            out.writeDoubleNoTag(this.responseTime);
-            out.writeDoubleNoTag(this.serviceTime);
-        }
-
-        /**
-         * Rank this copy of the data, according to the adaptive replica selection formula from the C3 paper
-         * https://www.usenix.org/system/files/conference/nsdi15/nsdi15-paper-suresh.pdf
-         */
-        private double innerRank(long outstandingRequests) {
-            // the concurrency compensation is defined as the number of
-            // outstanding requests from the client to the node times the number
-            // of clients in the system
-            double concurrencyCompensation = outstandingRequests * clientNum;
-
-            // Cubic queue adjustment factor. The paper chose 3 though we could
-            // potentially make this configurable if desired.
-            int queueAdjustmentFactor = 3;
-
-            // EWMA of queue size
-            double qBar = queueSize;
-            double qHatS = 1 + concurrencyCompensation + qBar;
-
-            // EWMA of response time
-            double rS = responseTime / FACTOR;
-            // EWMA of service time
-            double muBarS = serviceTime / FACTOR;
-
-            // The final formula
-            double rank = rS - (1.0 / muBarS) + (Math.pow(qHatS, queueAdjustmentFactor) / muBarS);
-            return rank;
-        }
-
-        public double rank(long outstandingRequests) {
-            if (cachedRank == 0) {
-                cachedRank = innerRank(outstandingRequests);
-            }
-            return cachedRank;
-        }
-
-        @Override
-        public String toString() {
-            StringBuilder sb = new StringBuilder("ComputedNodeStats[");
-            sb.append(nodeId).append("](");
-            sb.append("nodes: ").append(clientNum);
-            sb.append(", queue: ").append(queueSize);
-            sb.append(", response time: ").append(String.format(Locale.ROOT, "%.1f", responseTime));
-            sb.append(", service time: ").append(String.format(Locale.ROOT, "%.1f", serviceTime));
-            sb.append(", rank: ").append(String.format(Locale.ROOT, "%.1f", rank(1)));
-            sb.append(")");
-            return sb.toString();
-        }
-    }
-
     /**
      * Class encapsulating a node's exponentially weighted queue size, response
      * time, and service time, however, this class is private and intended only
diff --git a/server/src/main/java/org/opensearch/plugins/ProtobufPluginInfo.java b/server/src/main/java/org/opensearch/plugins/ProtobufPluginInfo.java
deleted file mode 100644
index c82e40e71166e..0000000000000
--- a/server/src/main/java/org/opensearch/plugins/ProtobufPluginInfo.java
+++ /dev/null
@@ -1,372 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.plugins;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.Version;
-import org.opensearch.bootstrap.JarHell;
-import org.opensearch.common.Strings;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.core.xcontent.ToXContent.Params;
-import org.opensearch.core.xcontent.ToXContentObject;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Properties;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-
-/**
- * An in-memory representation of the plugin descriptor.
-*
-* @opensearch.api
-*/
-public class ProtobufPluginInfo implements ProtobufWriteable, ToXContentObject {
-
-    public static final String OPENSEARCH_PLUGIN_PROPERTIES = "plugin-descriptor.properties";
-    public static final String OPENSEARCH_PLUGIN_POLICY = "plugin-security.policy";
-
-    private final String name;
-    private final String description;
-    private final String version;
-    private final Version opensearchVersion;
-    private final String javaVersion;
-    private final String classname;
-    private final String customFolderName;
-    private final List<String> extendedPlugins;
-    private final boolean hasNativeController;
-
-    /**
-     * Construct plugin info.
-    *
-    * @param name                  the name of the plugin
-    * @param description           a description of the plugin
-    * @param version               an opaque version identifier for the plugin
-    * @param opensearchVersion     the version of OpenSearch the plugin was built for
-    * @param javaVersion           the version of Java the plugin was built with
-    * @param classname             the entry point to the plugin
-    * @param customFolderName      the custom folder name for the plugin
-    * @param extendedPlugins       other plugins this plugin extends through SPI
-    * @param hasNativeController   whether or not the plugin has a native controller
-    */
-    public ProtobufPluginInfo(
-        String name,
-        String description,
-        String version,
-        Version opensearchVersion,
-        String javaVersion,
-        String classname,
-        String customFolderName,
-        List<String> extendedPlugins,
-        boolean hasNativeController
-    ) {
-        this.name = name;
-        this.description = description;
-        this.version = version;
-        this.opensearchVersion = opensearchVersion;
-        this.javaVersion = javaVersion;
-        this.classname = classname;
-        this.customFolderName = customFolderName;
-        this.extendedPlugins = Collections.unmodifiableList(extendedPlugins);
-        this.hasNativeController = hasNativeController;
-    }
-
-    /**
-     * Construct plugin info.
-    *
-    * @param name                  the name of the plugin
-    * @param description           a description of the plugin
-    * @param version               an opaque version identifier for the plugin
-    * @param opensearchVersion     the version of OpenSearch the plugin was built for
-    * @param javaVersion           the version of Java the plugin was built with
-    * @param classname             the entry point to the plugin
-    * @param extendedPlugins       other plugins this plugin extends through SPI
-    * @param hasNativeController   whether or not the plugin has a native controller
-    */
-    public ProtobufPluginInfo(
-        String name,
-        String description,
-        String version,
-        Version opensearchVersion,
-        String javaVersion,
-        String classname,
-        List<String> extendedPlugins,
-        boolean hasNativeController
-    ) {
-        this(
-            name,
-            description,
-            version,
-            opensearchVersion,
-            javaVersion,
-            classname,
-            null /* customFolderName */,
-            extendedPlugins,
-            hasNativeController
-        );
-    }
-
-    /**
-     * Construct plugin info from a stream.
-    *
-    * @param in the stream
-    * @throws IOException if an I/O exception occurred reading the plugin info from the stream
-    */
-    public ProtobufPluginInfo(final CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        this.name = in.readString();
-        this.description = in.readString();
-        this.version = in.readString();
-        this.opensearchVersion = Version.readVersionProtobuf(in);
-        this.javaVersion = in.readString();
-        this.classname = in.readString();
-        this.customFolderName = in.readString();
-        this.extendedPlugins = protobufStreamInput.readList(CodedInputStream::readString);
-        this.hasNativeController = in.readBool();
-    }
-
-    @Override
-    public void writeTo(final CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeStringNoTag(name);
-        out.writeStringNoTag(description);
-        out.writeStringNoTag(version);
-        out.writeInt32NoTag(opensearchVersion.id);
-        out.writeStringNoTag(javaVersion);
-        out.writeStringNoTag(classname);
-        if (customFolderName != null) {
-            out.writeStringNoTag(customFolderName);
-        } else {
-            out.writeStringNoTag(name);
-        }
-        protobufStreamOutput.writeCollection(extendedPlugins, CodedOutputStream::writeStringNoTag);
-        out.writeBoolNoTag(hasNativeController);
-    }
-
-    /**
-     * Reads the plugin descriptor file.
-    *
-    * @param path           the path to the root directory for the plugin
-    * @return the plugin info
-    * @throws IOException if an I/O exception occurred reading the plugin descriptor
-    */
-    public static ProtobufPluginInfo readFromProperties(final Path path) throws IOException {
-        final Path descriptor = path.resolve(OPENSEARCH_PLUGIN_PROPERTIES);
-
-        final Map<String, String> propsMap;
-        {
-            final Properties props = new Properties();
-            try (InputStream stream = Files.newInputStream(descriptor)) {
-                props.load(stream);
-            }
-            propsMap = props.stringPropertyNames().stream().collect(Collectors.toMap(Function.identity(), props::getProperty));
-        }
-
-        final String name = propsMap.remove("name");
-        if (name == null || name.isEmpty()) {
-            throw new IllegalArgumentException("property [name] is missing in [" + descriptor + "]");
-        }
-        final String description = propsMap.remove("description");
-        if (description == null) {
-            throw new IllegalArgumentException("property [description] is missing for plugin [" + name + "]");
-        }
-        final String version = propsMap.remove("version");
-        if (version == null) {
-            throw new IllegalArgumentException("property [version] is missing for plugin [" + name + "]");
-        }
-
-        final String opensearchVersionString = propsMap.remove("opensearch.version");
-        if (opensearchVersionString == null) {
-            throw new IllegalArgumentException("property [opensearch.version] is missing for plugin [" + name + "]");
-        }
-        final Version opensearchVersion = Version.fromString(opensearchVersionString);
-        final String javaVersionString = propsMap.remove("java.version");
-        if (javaVersionString == null) {
-            throw new IllegalArgumentException("property [java.version] is missing for plugin [" + name + "]");
-        }
-        JarHell.checkVersionFormat(javaVersionString);
-        final String classname = propsMap.remove("classname");
-        if (classname == null) {
-            throw new IllegalArgumentException("property [classname] is missing for plugin [" + name + "]");
-        }
-
-        final String customFolderNameValue = propsMap.remove("custom.foldername");
-        final String customFolderName;
-        customFolderName = customFolderNameValue;
-
-        final String extendedString = propsMap.remove("extended.plugins");
-        final List<String> extendedPlugins;
-        if (extendedString == null) {
-            extendedPlugins = Collections.emptyList();
-        } else {
-            extendedPlugins = Arrays.asList(Strings.delimitedListToStringArray(extendedString, ","));
-        }
-
-        final String hasNativeControllerValue = propsMap.remove("has.native.controller");
-        final boolean hasNativeController;
-        if (hasNativeControllerValue == null) {
-            hasNativeController = false;
-        } else {
-            switch (hasNativeControllerValue) {
-                case "true":
-                    hasNativeController = true;
-                    break;
-                case "false":
-                    hasNativeController = false;
-                    break;
-                default:
-                    final String message = String.format(
-                        Locale.ROOT,
-                        "property [%s] must be [%s], [%s], or unspecified but was [%s]",
-                        "has_native_controller",
-                        "true",
-                        "false",
-                        hasNativeControllerValue
-                    );
-                    throw new IllegalArgumentException(message);
-            }
-        }
-
-        if (propsMap.isEmpty() == false) {
-            throw new IllegalArgumentException("Unknown properties in plugin descriptor: " + propsMap.keySet());
-        }
-
-        return new ProtobufPluginInfo(
-            name,
-            description,
-            version,
-            opensearchVersion,
-            javaVersionString,
-            classname,
-            customFolderName,
-            extendedPlugins,
-            hasNativeController
-        );
-    }
-
-    /**
-     * The name of the plugin.
-    *
-    * @return the plugin name
-    */
-    public String getName() {
-        return name;
-    }
-
-    /**
-     * The description of the plugin.
-    *
-    * @return the plugin description
-    */
-    public String getDescription() {
-        return description;
-    }
-
-    /**
-     * The entry point to the plugin.
-    *
-    * @return the entry point to the plugin
-    */
-    public String getClassname() {
-        return classname;
-    }
-
-    /**
-     * The custom folder name for the plugin.
-    *
-    * @return the custom folder name for the plugin
-    */
-    public String getFolderName() {
-        return customFolderName;
-    }
-
-    /**
-     * Other plugins this plugin extends through SPI.
-    *
-    * @return the names of the plugins extended
-    */
-    public List<String> getExtendedPlugins() {
-        return extendedPlugins;
-    }
-
-    /**
-     * The version of the plugin
-    *
-    * @return the version
-    */
-    public String getVersion() {
-        return version;
-    }
-
-    /**
-     * The version of OpenSearch the plugin was built for.
-    *
-    * @return an OpenSearch version
-    */
-    public Version getOpenSearchVersion() {
-        return opensearchVersion;
-    }
-
-    /**
-     * The version of Java the plugin was built with.
-    *
-    * @return a java version string
-    */
-    public String getJavaVersion() {
-        return javaVersion;
-    }
-
-    /**
-     * Whether or not the plugin has a native controller.
-    *
-    * @return {@code true} if the plugin has a native controller
-    */
-    public boolean hasNativeController() {
-        return hasNativeController;
-    }
-
-    /**
-     * The target folder name for the plugin.
-    *
-    * @return the custom folder name for the plugin if the folder name is specified, else return the id with kebab-case.
-    */
-    public String getTargetFolderName() {
-        return (this.customFolderName == null || this.customFolderName.isEmpty()) ? this.name : this.customFolderName;
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject();
-        {
-            builder.field("name", name);
-            builder.field("version", version);
-            builder.field("opensearch_version", opensearchVersion);
-            builder.field("java_version", javaVersion);
-            builder.field("description", description);
-            builder.field("classname", classname);
-            builder.field("custom_foldername", customFolderName);
-            builder.field("extended_plugins", extendedPlugins);
-            builder.field("has_native_controller", hasNativeController);
-        }
-        builder.endObject();
-
-        return builder;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
index 2de445e4fbd2e..a30ed675d1efc 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
@@ -8,10 +8,8 @@
 
 package org.opensearch.rest.action.cat;
 
-import org.opensearch.action.admin.cluster.node.info.ProtobufNodeInfo;
 import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequest;
 import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoResponse;
-import org.opensearch.action.admin.cluster.node.stats.ProtobufNodeStats;
 import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsRequest;
 import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsResponse;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
@@ -20,34 +18,12 @@
 import org.opensearch.common.Strings;
 import org.opensearch.common.Table;
 import org.opensearch.common.logging.DeprecationLogger;
-import org.opensearch.common.network.NetworkAddress;
-import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.unit.ByteSizeValue;
 import org.opensearch.common.unit.TimeValue;
-import org.opensearch.http.ProtobufHttpInfo;
-import org.opensearch.index.cache.query.ProtobufQueryCacheStats;
-import org.opensearch.index.cache.request.ProtobufRequestCacheStats;
-import org.opensearch.index.engine.ProtobufSegmentsStats;
-import org.opensearch.index.fielddata.ProtobufFieldDataStats;
-import org.opensearch.index.flush.ProtobufFlushStats;
-import org.opensearch.index.get.ProtobufGetStats;
-import org.opensearch.index.merge.ProtobufMergeStats;
-import org.opensearch.index.refresh.ProtobufRefreshStats;
-import org.opensearch.index.search.stats.ProtobufSearchStats;
-import org.opensearch.index.shard.ProtobufIndexingStats;
-import org.opensearch.indices.ProtobufNodeIndicesStats;
-import org.opensearch.monitor.fs.ProtobufFsInfo;
-import org.opensearch.monitor.jvm.JvmInfo;
-import org.opensearch.monitor.jvm.ProtobufJvmStats;
-import org.opensearch.monitor.os.ProtobufOsStats;
-import org.opensearch.monitor.process.ProtobufProcessInfo;
-import org.opensearch.monitor.process.ProtobufProcessStats;
 import org.opensearch.rest.RestRequest;
 import org.opensearch.rest.RestResponse;
 import org.opensearch.rest.action.RestActionListener;
 import org.opensearch.rest.action.RestResponseListener;
-import org.opensearch.script.ProtobufScriptStats;
-import org.opensearch.search.suggest.completion.ProtobufCompletionStats;
 import org.opensearch.server.proto.ClusterStateResponseProto;
 import org.opensearch.server.proto.NodesInfoProto.NodesInfo;
 import org.opensearch.server.proto.NodesStatsProto.NodesStats;
@@ -113,9 +89,8 @@ public RestChannelConsumer doCatRequest(final RestRequest request, final Protobu
                 @Override
                 public void processResponse(final ProtobufClusterStateResponse clusterStateResponse) {
                     ProtobufNodesInfoRequest nodesInfoRequest = new ProtobufNodesInfoRequest();
-                    nodesInfoRequest.timeout(request.param("timeout"));
-                    nodesInfoRequest.clear()
-                        .addMetrics(
+                    nodesInfoRequest.addMetrics(
+                            request.param("timeout"),
                             ProtobufNodesInfoRequest.Metric.JVM.metricName(),
                             ProtobufNodesInfoRequest.Metric.OS.metricName(),
                             ProtobufNodesInfoRequest.Metric.PROCESS.metricName(),
@@ -352,13 +327,6 @@ Table buildTable(
             NodesInfo info = nodesInfo.nodesMap().get(node.getNodeId());
             NodesStats stats = nodesStats.nodesMap().get(node.getNodeId());
 
-            // JvmInfo jvmInfo = info == null ? null : info.getInfo(JvmInfo.class);
-            // ProtobufJvmStats jvmStats = stats == null ? null : stats.getJvm();
-            // ProtobufFsInfo fsInfo = stats == null ? null : stats.getFs();
-            // ProtobufOsStats osStats = stats == null ? null : stats.getOs();
-            // ProtobufProcessStats processStats = stats == null ? null : stats.getProcess();
-            // ProtobufNodeIndicesStats indicesStats = stats == null ? null : stats.getIndices();
-
             table.startRow();
 
             table.addCell(fullId ? node.getNodeId() : Strings.substring(node.getNodeId(), 0, 4));
@@ -366,13 +334,6 @@ Table buildTable(
             table.addCell(node.getHostAddress());
             table.addCell(node.getTransportAddress());
             table.addCell(info == null ? null : info.getAddress());
-            // final ProtobufHttpInfo httpInfo = info == null ? null : info.getInfo(ProtobufHttpInfo.class);
-            // if (httpInfo != null) {
-            //     TransportAddress transportAddress = httpInfo.getAddress().publishAddress();
-            //     table.addCell(NetworkAddress.format(transportAddress.address()));
-            // } else {
-            //     table.addCell("-");
-            // }
 
             table.addCell(node.getVersion().toString());
             table.addCell(info == null ? null : info.getDisplayName());
@@ -385,15 +346,6 @@ Table buildTable(
             double diskUsedRatio = diskTotal.getBytes() == 0 ? 1.0 : (double) diskUsed.getBytes() / diskTotal.getBytes();
             String diskUsedPercent = String.format(Locale.ROOT, "%.2f", 100.0 * diskUsedRatio);
             
-            // String diskUsedPercent = null;
-            // if (fsInfo != null) {
-            //     diskTotal = stats.getDiskTotal();
-            //     diskAvailable = fsInfo.getTotal().getAvailable();
-            //     diskUsed = new ByteSizeValue(diskTotal.getBytes() - diskAvailable.getBytes());
-
-            //     double diskUsedRatio = diskTotal.getBytes() == 0 ? 1.0 : (double) diskUsed.getBytes() / diskTotal.getBytes();
-            //     diskUsedPercent = String.format(Locale.ROOT, "%.2f", 100.0 * diskUsedRatio);
-            // }
             table.addCell(diskTotal);
             table.addCell(diskUsed);
             table.addCell(diskAvailable);
@@ -448,10 +400,8 @@ Table buildTable(
             table.addCell(clusterManagerId == null ? "x" : clusterManagerId.equals(node.getNodeId()) ? "*" : "-");
             table.addCell(node.getNodeName());
 
-            // ProtobufCompletionStats completionStats = indicesStats == null ? null : stats.getIndices().getCompletion();
             table.addCell(stats.getCompletionStats() == null ? null : stats.getCompletionStats().getSize());
 
-            // ProtobufFieldDataStats fdStats = indicesStats == null ? null : stats.getIndices().getFieldData();
             table.addCell(stats.getFieldDataStats() == null ? null : stats.getFieldDataStats().getMemSize());
             table.addCell(stats.getFieldDataStats() == null ? null : stats.getFieldDataStats().getEvictions());
 
diff --git a/server/src/main/java/org/opensearch/script/ProtobufScriptCacheStats.java b/server/src/main/java/org/opensearch/script/ProtobufScriptCacheStats.java
deleted file mode 100644
index cf511b4bee309..0000000000000
--- a/server/src/main/java/org/opensearch/script/ProtobufScriptCacheStats.java
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.script;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
-import java.util.stream.Collectors;
-
-/**
- * Stats for script caching
-*
-* @opensearch.internal
-*
-* @deprecated This class is deprecated in favor of ProtobufScriptStats and ScriptContextStats.  It is removed in OpenSearch 2.0.
-*/
-@Deprecated
-public class ProtobufScriptCacheStats implements ProtobufWriteable, ToXContentFragment {
-    private final Map<String, ProtobufScriptStats> context;
-    private final ProtobufScriptStats general;
-
-    public ProtobufScriptCacheStats(Map<String, ProtobufScriptStats> context) {
-        this.context = Collections.unmodifiableMap(context);
-        this.general = null;
-    }
-
-    public ProtobufScriptCacheStats(ProtobufScriptStats general) {
-        this.general = Objects.requireNonNull(general);
-        this.context = null;
-    }
-
-    public ProtobufScriptCacheStats(CodedInputStream in) throws IOException {
-        boolean isContext = in.readBool();
-        if (isContext == false) {
-            general = new ProtobufScriptStats(in);
-            context = null;
-            return;
-        }
-
-        general = null;
-        int size = in.readInt32();
-        Map<String, ProtobufScriptStats> context = new HashMap<>(size);
-        for (int i = 0; i < size; i++) {
-            String name = in.readString();
-            context.put(name, new ProtobufScriptStats(in));
-        }
-        this.context = Collections.unmodifiableMap(context);
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        if (general != null) {
-            out.writeBoolNoTag(false);
-            general.writeTo(out);
-            return;
-        }
-
-        out.writeBoolNoTag(true);
-        out.writeInt32NoTag(context.size());
-        for (String name : context.keySet().stream().sorted().collect(Collectors.toList())) {
-            out.writeStringNoTag(name);
-            context.get(name).writeTo(out);
-        }
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.SCRIPT_CACHE_STATS);
-        builder.startObject(Fields.SUM);
-        if (general != null) {
-            builder.field(ProtobufScriptStats.Fields.COMPILATIONS, general.getCompilations());
-            builder.field(ProtobufScriptStats.Fields.CACHE_EVICTIONS, general.getCacheEvictions());
-            builder.field(ProtobufScriptStats.Fields.COMPILATION_LIMIT_TRIGGERED, general.getCompilationLimitTriggered());
-            builder.endObject().endObject();
-            return builder;
-        }
-
-        ProtobufScriptStats sum = sum();
-        builder.field(ProtobufScriptStats.Fields.COMPILATIONS, sum.getCompilations());
-        builder.field(ProtobufScriptStats.Fields.CACHE_EVICTIONS, sum.getCacheEvictions());
-        builder.field(ProtobufScriptStats.Fields.COMPILATION_LIMIT_TRIGGERED, sum.getCompilationLimitTriggered());
-        builder.endObject();
-
-        builder.startArray(Fields.CONTEXTS);
-        for (String name : context.keySet().stream().sorted().collect(Collectors.toList())) {
-            ProtobufScriptStats stats = context.get(name);
-            builder.startObject();
-            builder.field(Fields.CONTEXT, name);
-            builder.field(ProtobufScriptStats.Fields.COMPILATIONS, stats.getCompilations());
-            builder.field(ProtobufScriptStats.Fields.CACHE_EVICTIONS, stats.getCacheEvictions());
-            builder.field(ProtobufScriptStats.Fields.COMPILATION_LIMIT_TRIGGERED, stats.getCompilationLimitTriggered());
-            builder.endObject();
-        }
-        builder.endArray();
-        builder.endObject();
-
-        return builder;
-    }
-
-    /**
-     * Get the context specific stats, null if using general cache
-    */
-    public Map<String, ProtobufScriptStats> getContextStats() {
-        return context;
-    }
-
-    /**
-     * Get the general stats, null if using context cache
-    */
-    public ProtobufScriptStats getGeneralStats() {
-        return general;
-    }
-
-    /**
-     * The sum of all script stats, either the general stats or the sum of all stats of the context stats.
-    */
-    public ProtobufScriptStats sum() {
-        if (general != null) {
-            return general;
-        }
-        long compilations = 0;
-        long cacheEvictions = 0;
-        long compilationLimitTriggered = 0;
-        for (ProtobufScriptStats stat : context.values()) {
-            compilations += stat.getCompilations();
-            cacheEvictions += stat.getCacheEvictions();
-            compilationLimitTriggered += stat.getCompilationLimitTriggered();
-        }
-        return new ProtobufScriptStats(compilations, cacheEvictions, compilationLimitTriggered);
-    }
-
-    static final class Fields {
-        static final String SCRIPT_CACHE_STATS = "script_cache";
-        static final String CONTEXT = "context";
-        static final String SUM = "sum";
-        static final String CONTEXTS = "contexts";
-    }
-}
diff --git a/server/src/main/java/org/opensearch/script/ProtobufScriptContextStats.java b/server/src/main/java/org/opensearch/script/ProtobufScriptContextStats.java
deleted file mode 100644
index 52fe4f1bed339..0000000000000
--- a/server/src/main/java/org/opensearch/script/ProtobufScriptContextStats.java
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.script;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.util.Objects;
-
-/**
- * Stats for a script context
-*
-* @opensearch.internal
-*/
-public class ProtobufScriptContextStats implements ProtobufWriteable, ToXContentFragment, Comparable<ProtobufScriptContextStats> {
-    private final String context;
-    private final long compilations;
-    private final long cacheEvictions;
-    private final long compilationLimitTriggered;
-
-    public ProtobufScriptContextStats(String context, long compilations, long cacheEvictions, long compilationLimitTriggered) {
-        this.context = Objects.requireNonNull(context);
-        this.compilations = compilations;
-        this.cacheEvictions = cacheEvictions;
-        this.compilationLimitTriggered = compilationLimitTriggered;
-    }
-
-    public ProtobufScriptContextStats(CodedInputStream in) throws IOException {
-        context = in.readString();
-        compilations = in.readInt64();
-        cacheEvictions = in.readInt64();
-        compilationLimitTriggered = in.readInt64();
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeStringNoTag(context);
-        out.writeInt64NoTag(compilations);
-        out.writeInt64NoTag(cacheEvictions);
-        out.writeInt64NoTag(compilationLimitTriggered);
-    }
-
-    public String getContext() {
-        return context;
-    }
-
-    public long getCompilations() {
-        return compilations;
-    }
-
-    public long getCacheEvictions() {
-        return cacheEvictions;
-    }
-
-    public long getCompilationLimitTriggered() {
-        return compilationLimitTriggered;
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject();
-        builder.field(Fields.CONTEXT, getContext());
-        builder.field(Fields.COMPILATIONS, getCompilations());
-        builder.field(Fields.CACHE_EVICTIONS, getCacheEvictions());
-        builder.field(Fields.COMPILATION_LIMIT_TRIGGERED, getCompilationLimitTriggered());
-        builder.endObject();
-        return builder;
-    }
-
-    @Override
-    public int compareTo(ProtobufScriptContextStats o) {
-        return this.context.compareTo(o.context);
-    }
-
-    static final class Fields {
-        static final String CONTEXT = "context";
-        static final String COMPILATIONS = "compilations";
-        static final String CACHE_EVICTIONS = "cache_evictions";
-        static final String COMPILATION_LIMIT_TRIGGERED = "compilation_limit_triggered";
-    }
-}
diff --git a/server/src/main/java/org/opensearch/script/ProtobufScriptStats.java b/server/src/main/java/org/opensearch/script/ProtobufScriptStats.java
deleted file mode 100644
index c0366f94748ee..0000000000000
--- a/server/src/main/java/org/opensearch/script/ProtobufScriptStats.java
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.script;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Stats for scripts
-*
-* @opensearch.internal
-*/
-public class ProtobufScriptStats implements ProtobufWriteable, ToXContentFragment {
-    private final List<ProtobufScriptContextStats> contextStats;
-    private final long compilations;
-    private final long cacheEvictions;
-    private final long compilationLimitTriggered;
-
-    public ProtobufScriptStats(List<ProtobufScriptContextStats> contextStats) {
-        ArrayList<ProtobufScriptContextStats> ctxStats = new ArrayList<>(contextStats.size());
-        ctxStats.addAll(contextStats);
-        ctxStats.sort(ProtobufScriptContextStats::compareTo);
-        this.contextStats = Collections.unmodifiableList(ctxStats);
-        long compilations = 0;
-        long cacheEvictions = 0;
-        long compilationLimitTriggered = 0;
-        for (ProtobufScriptContextStats stats : contextStats) {
-            compilations += stats.getCompilations();
-            cacheEvictions += stats.getCacheEvictions();
-            compilationLimitTriggered += stats.getCompilationLimitTriggered();
-        }
-        this.compilations = compilations;
-        this.cacheEvictions = cacheEvictions;
-        this.compilationLimitTriggered = compilationLimitTriggered;
-    }
-
-    public ProtobufScriptStats(long compilations, long cacheEvictions, long compilationLimitTriggered) {
-        this.contextStats = Collections.emptyList();
-        this.compilations = compilations;
-        this.cacheEvictions = cacheEvictions;
-        this.compilationLimitTriggered = compilationLimitTriggered;
-    }
-
-    public ProtobufScriptStats(ProtobufScriptContextStats context) {
-        this(context.getCompilations(), context.getCacheEvictions(), context.getCompilationLimitTriggered());
-    }
-
-    public ProtobufScriptStats(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        compilations = in.readInt64();
-        cacheEvictions = in.readInt64();
-        compilationLimitTriggered = in.readInt64();
-        contextStats = protobufStreamInput.readList(ProtobufScriptContextStats::new);
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeInt64NoTag(compilations);
-        out.writeInt64NoTag(cacheEvictions);
-        out.writeInt64NoTag(compilationLimitTriggered);
-        protobufStreamOutput.writeCollection(contextStats, (o, v) -> v.writeTo(o));
-    }
-
-    public List<ProtobufScriptContextStats> getContextStats() {
-        return contextStats;
-    }
-
-    public long getCompilations() {
-        return compilations;
-    }
-
-    public long getCacheEvictions() {
-        return cacheEvictions;
-    }
-
-    public long getCompilationLimitTriggered() {
-        return compilationLimitTriggered;
-    }
-
-    public ProtobufScriptCacheStats toScriptCacheStats() {
-        if (contextStats.isEmpty()) {
-            return new ProtobufScriptCacheStats(this);
-        }
-        Map<String, ProtobufScriptStats> contexts = new HashMap<>(contextStats.size());
-        for (ProtobufScriptContextStats contextStats : contextStats) {
-            contexts.put(contextStats.getContext(), new ProtobufScriptStats(contextStats));
-        }
-        return new ProtobufScriptCacheStats(contexts);
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.SCRIPT_STATS);
-        builder.field(Fields.COMPILATIONS, compilations);
-        builder.field(Fields.CACHE_EVICTIONS, cacheEvictions);
-        builder.field(Fields.COMPILATION_LIMIT_TRIGGERED, compilationLimitTriggered);
-        builder.endObject();
-        return builder;
-    }
-
-    static final class Fields {
-        static final String SCRIPT_STATS = "script";
-        static final String CONTEXTS = "contexts";
-        static final String COMPILATIONS = "compilations";
-        static final String CACHE_EVICTIONS = "cache_evictions";
-        static final String COMPILATION_LIMIT_TRIGGERED = "compilation_limit_triggered";
-    }
-}
diff --git a/server/src/main/java/org/opensearch/script/ScriptCache.java b/server/src/main/java/org/opensearch/script/ScriptCache.java
index 0c536bd7ec133..439953f816cbb 100644
--- a/server/src/main/java/org/opensearch/script/ScriptCache.java
+++ b/server/src/main/java/org/opensearch/script/ScriptCache.java
@@ -155,14 +155,6 @@ public ScriptContextStats stats(String context) {
         return scriptMetrics.stats(context);
     }
 
-    public ProtobufScriptStats protobufStats() {
-        return scriptMetrics.protobufStats();
-    }
-
-    public ProtobufScriptContextStats protobufStats(String context) {
-        return scriptMetrics.protobufStats(context);
-    }
-
     /**
      * Check whether there have been too many compilations within the last minute, throwing a circuit breaking exception if so.
      * This is a variant of the token bucket algorithm: https://en.wikipedia.org/wiki/Token_bucket
diff --git a/server/src/main/java/org/opensearch/script/ScriptMetrics.java b/server/src/main/java/org/opensearch/script/ScriptMetrics.java
index aa348ff5948c9..fd54c757fd017 100644
--- a/server/src/main/java/org/opensearch/script/ScriptMetrics.java
+++ b/server/src/main/java/org/opensearch/script/ScriptMetrics.java
@@ -63,17 +63,4 @@ public ScriptStats stats() {
     public ScriptContextStats stats(String context) {
         return new ScriptContextStats(context, compilationsMetric.count(), cacheEvictionsMetric.count(), compilationLimitTriggered.count());
     }
-
-    public ProtobufScriptStats protobufStats() {
-        return new ProtobufScriptStats(compilationsMetric.count(), cacheEvictionsMetric.count(), compilationLimitTriggered.count());
-    }
-
-    public ProtobufScriptContextStats protobufStats(String context) {
-        return new ProtobufScriptContextStats(
-            context,
-            compilationsMetric.count(),
-            cacheEvictionsMetric.count(),
-            compilationLimitTriggered.count()
-        );
-    }
 }
diff --git a/server/src/main/java/org/opensearch/script/ScriptService.java b/server/src/main/java/org/opensearch/script/ScriptService.java
index d34153d126646..11e72ee6a8b66 100644
--- a/server/src/main/java/org/opensearch/script/ScriptService.java
+++ b/server/src/main/java/org/opensearch/script/ScriptService.java
@@ -689,10 +689,6 @@ public ScriptStats stats() {
         return cacheHolder.get().stats();
     }
 
-    public ProtobufScriptStats protobufStats() {
-        return cacheHolder.get().protobufStats();
-    }
-
     public ScriptCacheStats cacheStats() {
         return cacheHolder.get().cacheStats();
     }
@@ -817,18 +813,6 @@ ScriptStats stats() {
             return new ScriptStats(contextStats);
         }
 
-        ProtobufScriptStats protobufStats() {
-            if (general != null) {
-                return general.protobufStats();
-            }
-            List<ProtobufScriptContextStats> contextStats = new ArrayList<>(contextCache.size());
-            for (Map.Entry<String, AtomicReference<ScriptCache>> entry : contextCache.entrySet()) {
-                ScriptCache cache = entry.getValue().get();
-                contextStats.add(cache.protobufStats(entry.getKey()));
-            }
-            return new ProtobufScriptStats(contextStats);
-        }
-
         ScriptCacheStats cacheStats() {
             if (general != null) {
                 return new ScriptCacheStats(general.stats());
diff --git a/server/src/main/java/org/opensearch/script/StoredScriptSource.java b/server/src/main/java/org/opensearch/script/StoredScriptSource.java
index 383e445dd385a..1390bb5cdca07 100644
--- a/server/src/main/java/org/opensearch/script/StoredScriptSource.java
+++ b/server/src/main/java/org/opensearch/script/StoredScriptSource.java
@@ -72,7 +72,7 @@
  *
  * @opensearch.internal
  */
-public class StoredScriptSource extends AbstractDiffable<StoredScriptSource, StoredScriptSource> implements Writeable, ToXContentObject {
+public class StoredScriptSource extends AbstractDiffable<StoredScriptSource> implements Writeable, ToXContentObject {
 
     /**
      * Standard deprecation logger for used to deprecate allowance of empty templates.
@@ -390,16 +390,6 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeMap(options);
     }
 
-    /**
-     * Writes a {@link StoredScriptSource} to a stream. Will write
-     * all of the lang, source, and options parameters.
-     */
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-         // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
-    }
-
     /**
      * This will write XContent from a {@link StoredScriptSource}. The following format will be written:
      *
diff --git a/server/src/main/java/org/opensearch/search/aggregations/support/AggregationUsageService.java b/server/src/main/java/org/opensearch/search/aggregations/support/AggregationUsageService.java
index cdcbe8d2fba61..24a9701161741 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/support/AggregationUsageService.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/support/AggregationUsageService.java
@@ -44,10 +44,9 @@
  *
  * @opensearch.internal
  */
-public class AggregationUsageService implements ReportingService<AggregationInfo>, ProtobufReportingService<ProtobufAggregationInfo> {
+public class AggregationUsageService implements ReportingService<AggregationInfo> {
     private final Map<String, Map<String, LongAdder>> aggs;
     private final AggregationInfo info;
-    private final ProtobufAggregationInfo protobufInfo;
 
     public static final String OTHER_SUBTYPE = "other";
 
@@ -84,7 +83,6 @@ public AggregationUsageService build() {
     private AggregationUsageService(Builder builder) {
         this.aggs = builder.aggs;
         info = new AggregationInfo(aggs);
-        protobufInfo = new ProtobufAggregationInfo(aggs);
     }
 
     public void incAggregationUsage(String aggregationName, String valuesSourceType) {
@@ -122,8 +120,4 @@ public AggregationInfo info() {
         return info;
     }
 
-    @Override
-    public ProtobufAggregationInfo protobufInfo() {
-        return protobufInfo;
-    }
 }
diff --git a/server/src/main/java/org/opensearch/search/aggregations/support/ProtobufAggregationInfo.java b/server/src/main/java/org/opensearch/search/aggregations/support/ProtobufAggregationInfo.java
deleted file mode 100644
index d9dcc049fcf5d..0000000000000
--- a/server/src/main/java/org/opensearch/search/aggregations/support/ProtobufAggregationInfo.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.search.aggregations.support;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.node.ProtobufReportingService;
-
-import java.io.IOException;
-import java.util.Collections;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeMap;
-import java.util.TreeSet;
-import java.util.concurrent.atomic.LongAdder;
-
-/**
- * Data describing an agg
-*
-* @opensearch.internal
-*/
-public class ProtobufAggregationInfo implements ProtobufReportingService.ProtobufInfo {
-
-    private final Map<String, Set<String>> aggs;
-
-    ProtobufAggregationInfo(Map<String, Map<String, LongAdder>> aggs) {
-        // we use a treemap/treeset here to have a test-able / predictable order
-        Map<String, Set<String>> aggsMap = new TreeMap<>();
-        aggs.forEach((s, m) -> aggsMap.put(s, Collections.unmodifiableSet(new TreeSet<>(m.keySet()))));
-        this.aggs = Collections.unmodifiableMap(aggsMap);
-    }
-
-    /**
-     * Read from a stream.
-    */
-    public ProtobufAggregationInfo(CodedInputStream in) throws IOException {
-        aggs = new TreeMap<>();
-        final int size = in.readInt32();
-        for (int i = 0; i < size; i++) {
-            String key = in.readString();
-            final int keys = in.readInt32();
-            final Set<String> types = new TreeSet<>();
-            for (int j = 0; j < keys; j++) {
-                types.add(in.readString());
-            }
-            aggs.put(key, types);
-        }
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt32NoTag(aggs.size());
-        for (Map.Entry<String, Set<String>> e : aggs.entrySet()) {
-            out.writeStringNoTag(e.getKey());
-            out.writeInt32NoTag(e.getValue().size());
-            for (String type : e.getValue()) {
-                out.writeStringNoTag(type);
-            }
-        }
-    }
-
-    public Map<String, Set<String>> getAggregations() {
-        return aggs;
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject("aggregations");
-        for (Map.Entry<String, Set<String>> e : aggs.entrySet()) {
-            builder.startObject(e.getKey());
-            builder.startArray("types");
-            for (String s : e.getValue()) {
-                builder.value(s);
-            }
-            builder.endArray();
-            builder.endObject();
-        }
-        builder.endObject();
-        return builder;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java b/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java
index 4fbfe3b79749c..5438f1e8a459e 100644
--- a/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java
+++ b/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java
@@ -35,7 +35,7 @@
  *
  * See if we can refactor into a common class. I suspect not, just because this one will hold
  */
-public class PipelineConfiguration extends AbstractDiffable<PipelineConfiguration, PipelineConfiguration> implements ToXContentObject {
+public class PipelineConfiguration extends AbstractDiffable<PipelineConfiguration> implements ToXContentObject {
     private static final ObjectParser<Builder, Void> PARSER = new ObjectParser<>(
         "pipeline_config",
         true,
@@ -165,9 +165,4 @@ public int hashCode() {
         return result;
     }
 
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
-    }
 }
diff --git a/server/src/main/java/org/opensearch/search/pipeline/ProtobufSearchPipelineInfo.java b/server/src/main/java/org/opensearch/search/pipeline/ProtobufSearchPipelineInfo.java
deleted file mode 100644
index d95845f1eea77..0000000000000
--- a/server/src/main/java/org/opensearch/search/pipeline/ProtobufSearchPipelineInfo.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.search.pipeline;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.ingest.ProtobufProcessorInfo;
-import org.opensearch.node.ProtobufReportingService;
-
-import java.io.IOException;
-import java.util.List;
-import java.util.Set;
-import java.util.TreeSet;
-
-/**
- * Information about a search pipelines event
-*
-* @opensearch.internal
-*/
-public class ProtobufSearchPipelineInfo implements ProtobufReportingService.ProtobufInfo {
-
-    private final Set<ProtobufProcessorInfo> processors;
-
-    public ProtobufSearchPipelineInfo(List<ProtobufProcessorInfo> processors) {
-        this.processors = new TreeSet<>(processors);  // we use a treeset here to have a test-able / predictable order
-    }
-
-    /**
-     * Read from a stream.
-    */
-    public ProtobufSearchPipelineInfo(CodedInputStream in) throws IOException {
-        processors = new TreeSet<>();
-        final int size = in.readInt32();
-        for (int i = 0; i < size; i++) {
-            processors.add(new ProtobufProcessorInfo(in));
-        }
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt32NoTag(processors.size());
-        for (ProtobufProcessorInfo info : processors) {
-            info.writeTo(out);
-        }
-    }
-
-    public boolean containsProcessor(String type) {
-        return processors.contains(new ProtobufProcessorInfo(type));
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject("search_pipelines");
-        builder.startArray("processors");
-        for (ProtobufProcessorInfo info : processors) {
-            info.toXContent(builder, params);
-        }
-        builder.endArray();
-        builder.endObject();
-        return builder;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/search/pipeline/SearchPipelineService.java b/server/src/main/java/org/opensearch/search/pipeline/SearchPipelineService.java
index 6984f774f3650..ed4350d69ddcf 100644
--- a/server/src/main/java/org/opensearch/search/pipeline/SearchPipelineService.java
+++ b/server/src/main/java/org/opensearch/search/pipeline/SearchPipelineService.java
@@ -41,7 +41,6 @@
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.analysis.AnalysisRegistry;
 import org.opensearch.ingest.ConfigurationUtils;
-import org.opensearch.ingest.ProtobufProcessorInfo;
 import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.node.ReportingService;
 import org.opensearch.plugins.SearchPipelinePlugin;
@@ -68,8 +67,7 @@
 public class SearchPipelineService
     implements
         ClusterStateApplier,
-        ReportingService<SearchPipelineInfo>,
-        ProtobufReportingService<ProtobufSearchPipelineInfo> {
+        ReportingService<SearchPipelineInfo> {
 
     public static final String SEARCH_PIPELINE_ORIGIN = "search_pipeline";
     public static final String AD_HOC_PIPELINE_ID = "_ad_hoc_pipeline";
@@ -451,15 +449,6 @@ public SearchPipelineStats stats() {
         return builder.build();
     }
 
-    @Override
-    public ProtobufSearchPipelineInfo protobufInfo() {
-        List<ProtobufProcessorInfo> processorInfoList = new ArrayList<>();
-        for (Map.Entry<String, Processor.Factory> entry : processorFactories.entrySet()) {
-            processorInfoList.add(new ProtobufProcessorInfo(entry.getKey()));
-        }
-        return new ProtobufSearchPipelineInfo(processorInfoList);
-    }
-
     public static List<PipelineConfiguration> getPipelines(ClusterState clusterState, String... ids) {
         SearchPipelineMetadata metadata = clusterState.getMetadata().custom(SearchPipelineMetadata.TYPE);
         return innerGetPipelines(metadata, ids);
diff --git a/server/src/main/java/org/opensearch/search/suggest/completion/ProtobufCompletionStats.java b/server/src/main/java/org/opensearch/search/suggest/completion/ProtobufCompletionStats.java
deleted file mode 100644
index cf3f6db462f16..0000000000000
--- a/server/src/main/java/org/opensearch/search/suggest/completion/ProtobufCompletionStats.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.search.suggest.completion;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.ProtobufFieldMemoryStats;
-import org.opensearch.common.Nullable;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-
-/**
- * Stats for completion suggester
-*
-* @opensearch.internal
-*/
-public class ProtobufCompletionStats implements ProtobufWriteable, ToXContentFragment {
-
-    private static final String COMPLETION = "completion";
-    private static final String SIZE_IN_BYTES = "size_in_bytes";
-    private static final String SIZE = "size";
-    private static final String FIELDS = "fields";
-
-    private long sizeInBytes;
-    @Nullable
-    private ProtobufFieldMemoryStats fields;
-
-    public ProtobufCompletionStats() {}
-
-    public ProtobufCompletionStats(CodedInputStream in) throws IOException {
-        sizeInBytes = in.readInt64();
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        fields = protobufStreamInput.readOptionalWriteable(ProtobufFieldMemoryStats::new);
-    }
-
-    public ProtobufCompletionStats(long size, @Nullable ProtobufFieldMemoryStats fields) {
-        this.sizeInBytes = size;
-        this.fields = fields;
-    }
-
-    public long getSizeInBytes() {
-        return sizeInBytes;
-    }
-
-    public ByteSizeValue getSize() {
-        return new ByteSizeValue(sizeInBytes);
-    }
-
-    public ProtobufFieldMemoryStats getFields() {
-        return fields;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(sizeInBytes);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeOptionalWriteable(fields);
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(COMPLETION);
-        builder.humanReadableField(SIZE_IN_BYTES, SIZE, getSize());
-        if (fields != null) {
-            fields.toXContent(builder, FIELDS, SIZE_IN_BYTES, SIZE);
-        }
-        builder.endObject();
-        return builder;
-    }
-
-    public void add(ProtobufCompletionStats completion) {
-        if (completion == null) {
-            return;
-        }
-        sizeInBytes += completion.getSizeInBytes();
-        if (completion.fields != null) {
-            if (fields == null) {
-                fields = completion.fields.copy();
-            } else {
-                fields.add(completion.fields);
-            }
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java b/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java
index 9acfe10ee6bbf..812d858e03354 100644
--- a/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java
+++ b/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java
@@ -69,7 +69,6 @@
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.Repository;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequestDeduplicator;
 import org.opensearch.transport.TransportResponseHandler;
@@ -605,18 +604,6 @@ public String executor() {
                         return ThreadPool.Names.SAME;
                     }
 
-                    @Override
-                    public UpdateIndexShardSnapshotStatusResponse read(CodedInputStream in) throws IOException {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'read'");
-                    }
-
-                    @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                    }
-
                     @Override
                     public UpdateIndexShardSnapshotStatusResponse read(byte[] in) throws IOException {
                         // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
index 9fb17ba385680..d3f2a26622ce7 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
@@ -22,13 +22,14 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ProtobufEmptyTransportResponseHandler;
 import org.opensearch.transport.TransportChannel;
-import org.opensearch.transport.ProtobufTransportException;
+import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.ProtobufTransportRequestHandler;
 import org.opensearch.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
+import java.io.OutputStream;
 import java.util.Collection;
 import java.util.List;
 
@@ -131,7 +132,7 @@ public void handleResponse(TransportResponse.Empty response) {
                     }
 
                     @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    public void handleException(TransportException exp) {
                         assert ExceptionsHelper.unwrapCause(exp) instanceof OpenSearchSecurityException == false;
                         logger.warn("Cannot send ban for tasks with the parent [{}] to the node [{}]", taskId, node);
                         groupedListener.onFailure(exp);
@@ -153,7 +154,7 @@ private void removeBanOnNodes(ProtobufCancellableTask task, Collection<Discovery
                 request,
                 new ProtobufEmptyTransportResponseHandler(ThreadPool.Names.SAME) {
                     @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
+                    public void handleException(TransportException exp) {
                         assert ExceptionsHelper.unwrapCause(exp) instanceof OpenSearchSecurityException == false;
                         logger.info("failed to remove the parent ban for task {} on node {}", request.parentTaskId, node);
                     }
@@ -191,23 +192,17 @@ private BanParentTaskRequest(ProtobufTaskId parentTaskId) {
             this.waitForCompletion = false;
         }
 
-        private BanParentTaskRequest(CodedInputStream in) throws IOException {
+        private BanParentTaskRequest(byte[] in) throws IOException {
             super(in);
-            parentTaskId = ProtobufTaskId.readFromStream(in);
-            ban = in.readBool();
-            reason = ban ? in.readString() : null;
-            waitForCompletion = in.readBool();
+            parentTaskId = null;
+            ban = false;
+            reason = null;
+            waitForCompletion = false;
         }
 
         @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
+        public void writeTo(OutputStream out) throws IOException {
             super.writeTo(out);
-            parentTaskId.writeTo(out);
-            out.writeBoolNoTag(ban);
-            if (ban) {
-                out.writeStringNoTag(reason);
-            }
-            out.writeBoolNoTag(waitForCompletion);
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
index 5e0270c470f0b..e34629d223aa6 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
@@ -18,6 +18,7 @@
 import org.opensearch.tasks.proto.TaskIdProto;
 
 import java.io.IOException;
+import java.io.OutputStream;
 
 /**
  * Task id that consists of node id and id of the task on the node
@@ -63,21 +64,13 @@ public ProtobufTaskId(String taskId) {
      * Read a {@linkplain ProtobufTaskId} from a stream. {@linkplain ProtobufTaskId} has this rather than the usual constructor that takes a
     * {@linkplain CodedInputStream} so we can return the {@link #EMPTY_TASK_ID} without allocating.
     */
-    public static ProtobufTaskId readFromStream(CodedInputStream in) throws IOException {
-        String nodeId = in.readString();
-        if (nodeId.isEmpty()) {
-            /*
-            * The only TaskId allowed to have the empty string as its nodeId is the EMPTY_TASK_ID and there is only ever one of it and it
-            * never writes its taskId to save bytes on the wire because it is by far the most common TaskId.
-            */
-            return EMPTY_TASK_ID;
-        }
-        return new ProtobufTaskId(nodeId, in.readInt64());
+    public ProtobufTaskId(byte[] in) throws IOException {
+        this.taskId = TaskIdProto.TaskId.parseFrom(in);
     }
 
     @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        this.taskId.writeTo(out);
+    public void writeTo(OutputStream out) throws IOException {
+        out.write(this.taskId.toByteArray());
     }
 
     public String getNodeId() {
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
index e8e78dd9cde00..a02b26afc8ba5 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
@@ -14,14 +14,13 @@
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.CodedOutputStream;
 import org.opensearch.Version;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 
 import java.io.IOException;
+import java.io.OutputStream;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
@@ -60,10 +59,6 @@ public final class ProtobufTaskInfo implements ProtobufWriteable, ToXContentFrag
 
     private final ProtobufTaskResourceStats resourceStats;
 
-    private ProtobufStreamInput protobufStreamInput;
-
-    private ProtobufStreamOutput protobufStreamOutput;
-
     public ProtobufTaskInfo(
         ProtobufTaskId taskId,
         String type,
@@ -95,60 +90,6 @@ public ProtobufTaskInfo(
         this.resourceStats = resourceStats;
     }
 
-    /**
-     * Read from a stream.
-    */
-    @SuppressWarnings("unchecked")
-    public ProtobufTaskInfo(CodedInputStream in) throws IOException {
-        protobufStreamInput = new ProtobufStreamInput(in);
-        taskId = ProtobufTaskId.readFromStream(in);
-        type = in.readString();
-        action = in.readString();
-        description = protobufStreamInput.readOptionalString();
-        // TODO: fix this
-        status = null;
-        startTime = in.readInt64();
-        runningTimeNanos = in.readInt64();
-        cancellable = in.readBool();
-        if (protobufStreamInput.getVersion().onOrAfter(Version.V_2_0_0)) {
-            cancelled = in.readBool();
-        } else {
-            cancelled = false;
-        }
-        if (cancellable == false && cancelled == true) {
-            throw new IllegalArgumentException("task cannot be cancelled");
-        }
-        parentTaskId = ProtobufTaskId.readFromStream(in);
-        headers = protobufStreamInput.readMap(CodedInputStream::readString, CodedInputStream::readString);
-        if (protobufStreamInput.getVersion().onOrAfter(Version.V_2_1_0)) {
-            resourceStats = protobufStreamInput.readOptionalWriteable(ProtobufTaskResourceStats::new);
-        } else {
-            resourceStats = null;
-        }
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        protobufStreamOutput = new ProtobufStreamOutput(out);
-        taskId.writeTo(out);
-        out.writeStringNoTag(type);
-        out.writeStringNoTag(action);
-        out.writeStringNoTag(description);
-        // TODO: fix this
-        // out.writeOptionalNamedWriteable(status);
-        out.writeInt64NoTag(startTime);
-        out.writeInt64NoTag(runningTimeNanos);
-        out.writeBoolNoTag(cancellable);
-        if (protobufStreamOutput.getVersion().onOrAfter(Version.V_2_0_0)) {
-            out.writeBoolNoTag(cancelled);
-        }
-        parentTaskId.writeTo(out);
-        protobufStreamOutput.writeMap(headers, CodedOutputStream::writeStringNoTag, CodedOutputStream::writeStringNoTag);
-        if (protobufStreamOutput.getVersion().onOrAfter(Version.V_2_1_0)) {
-            protobufStreamOutput.writeOptionalWriteable(resourceStats);
-        }
-    }
-
     public ProtobufTaskId getTaskId() {
         return taskId;
     }
@@ -260,4 +201,10 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         }
         return builder;
     }
+
+    @Override
+    public void writeTo(OutputStream out) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java
index 61220be1026a9..051f96f6203c1 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java
@@ -16,10 +16,8 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.tasks.proto.TaskResourceStatsProto;
 
-import com.google.protobuf.CodedOutputStream;
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
+import java.io.OutputStream;
 import java.util.Map;
 
 /**
@@ -40,8 +38,8 @@ public ProtobufTaskResourceStats(Map<String, TaskResourceStatsProto.TaskResource
     /**
      * Read from a stream.
     */
-    public ProtobufTaskResourceStats(CodedInputStream in) throws IOException {
-        this.taskResourceStats = TaskResourceStatsProto.TaskResourceStats.parseFrom(in.readByteArray());
+    public ProtobufTaskResourceStats(byte[] in) throws IOException {
+        this.taskResourceStats = TaskResourceStatsProto.TaskResourceStats.parseFrom(in);
     }
 
     public Map<String, TaskResourceStatsProto.TaskResourceStats.TaskResourceUsage> getResourceUsageInfo() {
@@ -49,8 +47,8 @@ public Map<String, TaskResourceStatsProto.TaskResourceStats.TaskResourceUsage> g
     }
 
     @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        this.taskResourceStats.writeTo(out);
+    public void writeTo(OutputStream out) throws IOException {
+        out.write(this.taskResourceStats.toByteArray());
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
index 1c3128309f00e..57e114591b20d 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
@@ -17,7 +17,6 @@
 import org.opensearch.client.Requests;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.bytes.BytesReference;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.ToXContentObject;
@@ -26,6 +25,7 @@
 import org.opensearch.common.xcontent.XContentHelper;
 
 import java.io.IOException;
+import java.io.OutputStream;
 import java.util.Map;
 
 import static java.util.Collections.emptyMap;
@@ -46,8 +46,6 @@ public final class ProtobufTaskResult implements ProtobufWriteable, ToXContentOb
     @Nullable
     private final BytesReference response;
 
-    private ProtobufStreamInput protobufStreamInput;
-
     /**
      * Construct a {@linkplain TaskResult} for a task for which we don't have a result or error. That usually means that the task
     * is incomplete, but it could also mean that we waited for the task to complete but it didn't save any error information.
@@ -77,25 +75,6 @@ public ProtobufTaskResult(boolean completed, ProtobufTaskInfo task, @Nullable By
         this.response = result;
     }
 
-    /**
-    * Read from a stream.
-    */
-    public ProtobufTaskResult(CodedInputStream in) throws IOException {
-        protobufStreamInput = new ProtobufStreamInput(in);
-        completed = in.readBool();
-        task = new ProtobufTaskInfo(in);
-        error = protobufStreamInput.readOptionalBytesReference();
-        response = protobufStreamInput.readOptionalBytesReference();
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeBoolNoTag(completed);
-        task.writeTo(out);
-        out.writeByteArrayNoTag(BytesReference.toBytes(error));
-        out.writeByteArrayNoTag(BytesReference.toBytes(response));
-    }
-
     /**
     * Get the task that this wraps.
     */
@@ -174,4 +153,10 @@ private static BytesReference toXContent(Exception error) throws IOException {
             return BytesReference.bytes(builder);
         }
     }
+
+    @Override
+    public void writeTo(OutputStream out) throws IOException {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
+    }
 }
diff --git a/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java b/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java
deleted file mode 100644
index 0addbd9276b22..0000000000000
--- a/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolInfo.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.threadpool;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.node.ProtobufReportingService;
-
-import java.io.IOException;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-
-/**
- * Information about a threadpool
-*
-* @opensearch.internal
-*/
-public class ProtobufThreadPoolInfo implements ProtobufReportingService.ProtobufInfo, Iterable<ThreadPool.Info> {
-
-    private final List<ThreadPool.Info> infos;
-
-    public ProtobufThreadPoolInfo(List<ThreadPool.Info> infos) {
-        this.infos = Collections.unmodifiableList(infos);
-    }
-
-    public ProtobufThreadPoolInfo(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        this.infos = Collections.unmodifiableList(protobufStreamInput.readList(ThreadPool.Info::new));
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeCollection(infos, (o, v) -> v.writeTo(o));
-    }
-
-    @Override
-    public Iterator<ThreadPool.Info> iterator() {
-        return infos.iterator();
-    }
-
-    static final class Fields {
-        static final String THREAD_POOL = "thread_pool";
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.THREAD_POOL);
-        for (ThreadPool.Info info : infos) {
-            info.toXContent(builder, params);
-        }
-        builder.endObject();
-        return builder;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolStats.java b/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolStats.java
deleted file mode 100644
index b4c8c4d612cd8..0000000000000
--- a/server/src/main/java/org/opensearch/threadpool/ProtobufThreadPoolStats.java
+++ /dev/null
@@ -1,191 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.threadpool;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.core.xcontent.ToXContent;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-
-/**
- * Stats for a threadpool
-*
-* @opensearch.internal
-*/
-public class ProtobufThreadPoolStats implements ProtobufWriteable, ToXContentFragment, Iterable<ProtobufThreadPoolStats.Stats> {
-
-    /**
-     * The statistics.
-    *
-    * @opensearch.internal
-    */
-    public static class Stats implements ProtobufWriteable, ToXContentFragment, Comparable<Stats> {
-
-        private final String name;
-        private final int threads;
-        private final int queue;
-        private final int active;
-        private final long rejected;
-        private final int largest;
-        private final long completed;
-
-        public Stats(String name, int threads, int queue, int active, long rejected, int largest, long completed) {
-            this.name = name;
-            this.threads = threads;
-            this.queue = queue;
-            this.active = active;
-            this.rejected = rejected;
-            this.largest = largest;
-            this.completed = completed;
-        }
-
-        public Stats(CodedInputStream in) throws IOException {
-            name = in.readString();
-            threads = in.readInt32();
-            queue = in.readInt32();
-            active = in.readInt32();
-            rejected = in.readInt64();
-            largest = in.readInt32();
-            completed = in.readInt64();
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeStringNoTag(name);
-            out.writeInt32NoTag(threads);
-            out.writeInt32NoTag(queue);
-            out.writeInt32NoTag(active);
-            out.writeInt64NoTag(rejected);
-            out.writeInt32NoTag(largest);
-            out.writeInt64NoTag(completed);
-        }
-
-        public String getName() {
-            return this.name;
-        }
-
-        public int getThreads() {
-            return this.threads;
-        }
-
-        public int getQueue() {
-            return this.queue;
-        }
-
-        public int getActive() {
-            return this.active;
-        }
-
-        public long getRejected() {
-            return rejected;
-        }
-
-        public int getLargest() {
-            return largest;
-        }
-
-        public long getCompleted() {
-            return this.completed;
-        }
-
-        @Override
-        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-            builder.startObject(name);
-            if (threads != -1) {
-                builder.field(Fields.THREADS, threads);
-            }
-            if (queue != -1) {
-                builder.field(Fields.QUEUE, queue);
-            }
-            if (active != -1) {
-                builder.field(Fields.ACTIVE, active);
-            }
-            if (rejected != -1) {
-                builder.field(Fields.REJECTED, rejected);
-            }
-            if (largest != -1) {
-                builder.field(Fields.LARGEST, largest);
-            }
-            if (completed != -1) {
-                builder.field(Fields.COMPLETED, completed);
-            }
-            builder.endObject();
-            return builder;
-        }
-
-        @Override
-        public int compareTo(Stats other) {
-            if ((getName() == null) && (other.getName() == null)) {
-                return 0;
-            } else if ((getName() != null) && (other.getName() == null)) {
-                return 1;
-            } else if (getName() == null) {
-                return -1;
-            } else {
-                int compare = getName().compareTo(other.getName());
-                if (compare == 0) {
-                    compare = Integer.compare(getThreads(), other.getThreads());
-                }
-                return compare;
-            }
-        }
-    }
-
-    private List<Stats> stats;
-
-    public ProtobufThreadPoolStats(List<Stats> stats) {
-        Collections.sort(stats);
-        this.stats = stats;
-    }
-
-    public ProtobufThreadPoolStats(CodedInputStream in) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        stats = protobufStreamInput.readList(Stats::new);
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeCollection(stats, (o, v) -> v.writeTo(o));
-    }
-
-    @Override
-    public Iterator<Stats> iterator() {
-        return stats.iterator();
-    }
-
-    static final class Fields {
-        static final String THREAD_POOL = "thread_pool";
-        static final String THREADS = "threads";
-        static final String QUEUE = "queue";
-        static final String ACTIVE = "active";
-        static final String REJECTED = "rejected";
-        static final String LARGEST = "largest";
-        static final String COMPLETED = "completed";
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params params) throws IOException {
-        builder.startObject(Fields.THREAD_POOL);
-        for (Stats stat : stats) {
-            stat.toXContent(builder, params);
-        }
-        builder.endObject();
-        return builder;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/threadpool/ThreadPool.java b/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
index e55bfc4e5fb50..46eec31863751 100644
--- a/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
+++ b/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
@@ -32,22 +32,16 @@
 
 package org.opensearch.threadpool;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.Version;
 import org.opensearch.common.Nullable;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.unit.ProtobufSizeValue;
 import org.opensearch.common.unit.SizeValue;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.FeatureFlags;
@@ -87,7 +81,7 @@
  *
  * @opensearch.internal
  */
-public class ThreadPool implements ReportingService<ThreadPoolInfo>, Scheduler, ProtobufReportingService<ProtobufThreadPoolInfo> {
+public class ThreadPool implements ReportingService<ThreadPoolInfo>, Scheduler {
 
     private static final Logger logger = LogManager.getLogger(ThreadPool.class);
 
@@ -366,13 +360,6 @@ public ThreadPoolInfo info() {
         return threadPoolInfo;
     }
 
-    @Override
-    public ProtobufThreadPoolInfo protobufInfo() {
-        List<ThreadPool.Info> threadPoolInfos = new ArrayList<>();
-        threadPoolInfo.iterator().forEachRemaining(threadPoolInfos::add);
-        return new ProtobufThreadPoolInfo(threadPoolInfos);
-    }
-
     public Info info(String name) {
         ExecutorHolder holder = executors.get(name);
         if (holder == null) {
@@ -412,37 +399,6 @@ public ThreadPoolStats stats() {
         return new ThreadPoolStats(stats);
     }
 
-    public ProtobufThreadPoolStats protobufStats() {
-        List<ProtobufThreadPoolStats.Stats> stats = new ArrayList<>();
-        for (ExecutorHolder holder : executors.values()) {
-            final String name = holder.info.getName();
-            // no need to have info on "same" thread pool
-            if ("same".equals(name)) {
-                continue;
-            }
-            int threads = -1;
-            int queue = -1;
-            int active = -1;
-            long rejected = -1;
-            int largest = -1;
-            long completed = -1;
-            if (holder.executor() instanceof ThreadPoolExecutor) {
-                ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) holder.executor();
-                threads = threadPoolExecutor.getPoolSize();
-                queue = threadPoolExecutor.getQueue().size();
-                active = threadPoolExecutor.getActiveCount();
-                largest = threadPoolExecutor.getLargestPoolSize();
-                completed = threadPoolExecutor.getCompletedTaskCount();
-                RejectedExecutionHandler rejectedExecutionHandler = threadPoolExecutor.getRejectedExecutionHandler();
-                if (rejectedExecutionHandler instanceof XRejectedExecutionHandler) {
-                    rejected = ((XRejectedExecutionHandler) rejectedExecutionHandler).rejected();
-                }
-            }
-            stats.add(new ProtobufThreadPoolStats.Stats(name, threads, queue, active, rejected, largest, completed));
-        }
-        return new ProtobufThreadPoolStats(stats);
-    }
-
     /**
      * Get the generic {@link ExecutorService}. This executor service
      * {@link Executor#execute(Runnable)} method will run the {@link Runnable} it is given in the
@@ -766,7 +722,7 @@ ExecutorService executor() {
      *
      * @opensearch.internal
      */
-    public static class Info implements Writeable, ToXContentFragment, ProtobufWriteable {
+    public static class Info implements Writeable, ToXContentFragment {
 
         private final String name;
         private final ThreadPoolType type;
@@ -823,40 +779,6 @@ public void writeTo(StreamOutput out) throws IOException {
             out.writeOptionalWriteable(queueSize);
         }
 
-        public Info(CodedInputStream in) throws IOException {
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-            name = in.readString();
-            final String typeStr = in.readString();
-            // Opensearch on or after 3.0.0 version doesn't know about "fixed_auto_queue_size" thread pool. Convert it to RESIZABLE.
-            if (typeStr.equalsIgnoreCase("fixed_auto_queue_size")) {
-                type = ThreadPoolType.RESIZABLE;
-            } else {
-                type = ThreadPoolType.fromType(typeStr);
-            }
-            min = in.readInt32();
-            max = in.readInt32();
-            keepAlive = protobufStreamInput.readOptionalTimeValue();
-            ProtobufSizeValue protobufQueueSize = protobufStreamInput.readOptionalWriteable(ProtobufSizeValue::new);
-            queueSize = new SizeValue(protobufQueueSize.getSize(), protobufQueueSize.getSizeUnit());
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            out.writeStringNoTag(name);
-            if (type == ThreadPoolType.RESIZABLE && protobufStreamOutput.getVersion().before(Version.V_3_0_0)) {
-                // Opensearch on older version doesn't know about "resizable" thread pool. Convert RESIZABLE to FIXED
-                // to avoid serialization/de-serization issue between nodes with different OpenSearch version
-                out.writeStringNoTag(ThreadPoolType.FIXED.getType());
-            } else {
-                out.writeStringNoTag(type.getType());
-            }
-            out.writeInt32NoTag(min);
-            out.writeInt32NoTag(max);
-            protobufStreamOutput.writeOptionalTimeValue(keepAlive);
-            protobufStreamOutput.writeOptionalWriteable(new ProtobufSizeValue(queueSize.getSize(), queueSize.getSizeUnit()));
-        }
-
         public String getName() {
             return this.name;
         }
diff --git a/server/src/main/java/org/opensearch/transport/BytesTransportRequest.java b/server/src/main/java/org/opensearch/transport/BytesTransportRequest.java
index 3293d6887b5b4..3fd84432639d4 100644
--- a/server/src/main/java/org/opensearch/transport/BytesTransportRequest.java
+++ b/server/src/main/java/org/opensearch/transport/BytesTransportRequest.java
@@ -37,8 +37,6 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 
 /**
@@ -80,15 +78,6 @@ public void writeThin(StreamOutput out) throws IOException {
         out.writeVInt(bytes.length());
     }
 
-    /**
-     * Writes the data in a "thin" manner, without the actual bytes, assumes
-     * the actual bytes will be appended right after this content.
-     */
-    public void writeThinProtobuf(CodedOutputStream out) throws IOException {
-        super.writeTo(out);
-        out.writeInt32NoTag(bytes.length());
-    }
-
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         super.writeTo(out);
diff --git a/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java
index 9c5a1c8cc98dc..14bb560228895 100644
--- a/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java
+++ b/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java
@@ -71,18 +71,6 @@ public String executor() {
         return executor;
     }
 
-    @Override
-    public Empty read(CodedInputStream in) throws IOException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'read'");
-    }
-
-    @Override
-    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-    }
-
     @Override
     public Empty read(byte[] in) throws IOException {
         // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/transport/Header.java b/server/src/main/java/org/opensearch/transport/Header.java
index 988a5ea8e50c1..ba4a8cfef5534 100644
--- a/server/src/main/java/org/opensearch/transport/Header.java
+++ b/server/src/main/java/org/opensearch/transport/Header.java
@@ -34,12 +34,9 @@
 
 import org.opensearch.Version;
 import org.opensearch.common.collect.Tuple;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.util.concurrent.ThreadContext;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.Collections;
@@ -140,23 +137,6 @@ void finishParsingHeader(StreamInput input) throws IOException {
         }
     }
 
-    void finishParsingHeaderProtobuf(CodedInputStream input) throws IOException {
-        this.headers = ThreadContext.readHeadersFromStreamProtobuf(input);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(input);
-
-        if (isRequest()) {
-            final String[] featuresFound = protobufStreamInput.readStringArray();
-            if (featuresFound.length == 0) {
-                features = Collections.emptySet();
-            } else {
-                features = Collections.unmodifiableSet(new TreeSet<>(Arrays.asList(featuresFound)));
-            }
-            this.actionName = input.readString();
-        } else {
-            this.actionName = RESPONSE_NAME;
-        }
-    }
-
     @Override
     public String toString() {
         return "Header{"
diff --git a/server/src/main/java/org/opensearch/transport/InboundDecoder.java b/server/src/main/java/org/opensearch/transport/InboundDecoder.java
index 6e21ab67f1cc0..0dd39ed73d787 100644
--- a/server/src/main/java/org/opensearch/transport/InboundDecoder.java
+++ b/server/src/main/java/org/opensearch/transport/InboundDecoder.java
@@ -40,8 +40,6 @@
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.common.lease.Releasable;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.function.Consumer;
 
@@ -206,26 +204,6 @@ static Header readHeader(Version version, int networkMessageSize, BytesReference
         }
     }
 
-    static Header readHeaderProtobuf(Version version, int networkMessageSize, BytesReference bytesReference) throws IOException {
-        CodedInputStream streamInput = bytesReference.protobufInput();
-
-        streamInput.skipRawBytes(TcpHeader.BYTES_REQUIRED_FOR_MESSAGE_SIZE);
-        long requestId = streamInput.readInt64();
-        byte status = streamInput.readRawByte();
-        Version remoteVersion = Version.fromId(streamInput.readInt32());
-        Header header = new Header(networkMessageSize, requestId, status, remoteVersion);
-        final IllegalStateException invalidVersion = ensureVersionCompatibility(remoteVersion, version, header.isHandshake());
-        if (invalidVersion != null) {
-            throw invalidVersion;
-        } else {
-            // Skip since we already have ensured enough data available
-            streamInput.readInt32();
-            header.finishParsingHeaderProtobuf(streamInput);
-        }
-        return header;
-        
-    }
-
     private boolean isOnHeader() {
         return totalNetworkSize == -1;
     }
diff --git a/server/src/main/java/org/opensearch/transport/InboundHandler.java b/server/src/main/java/org/opensearch/transport/InboundHandler.java
index d41a6d9126122..c4e7a283bfdef 100644
--- a/server/src/main/java/org/opensearch/transport/InboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/InboundHandler.java
@@ -51,7 +51,6 @@
 import org.opensearch.core.common.io.stream.ByteBufferStreamInput;
 import org.opensearch.core.common.io.stream.NamedWriteableAwareStreamInput;
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.transport.TransportAddress;
@@ -235,34 +234,18 @@ private void messageReceived(TcpChannel channel, InboundMessage message, long st
                 }
                 // ignore if its null, the service logs it
                 if (handler != null) {
-                    if (handler.toString().contains("Protobuf")) {
-                        final CodedInputStream streamInput;
-                        if (message.getContentLength() > 0 || header.getVersion().equals(Version.CURRENT) == false) {
-                            StreamInput streamInput1 = namedWriteableStream(message.openOrGetStreamInput());
-                            streamInput = CodedInputStream.newInstance(streamInput1);
-                            if (header.isError()) {
-                                handlerResponseErrorProtobuf(requestId, streamInput, handler);
-                            } else {
-                                handleResponseProtobuf(requestId, remoteAddress, streamInput, handler);
-                            }
+                    final StreamInput streamInput;
+                    if (message.getContentLength() > 0 || header.getVersion().equals(Version.CURRENT) == false) {
+                        streamInput = namedWriteableStream(message.openOrGetStreamInput());
+                        assertRemoteVersion(streamInput, header.getVersion());
+                        if (header.isError()) {
+                            handlerResponseError(requestId, streamInput, handler);
                         } else {
-                            assert header.isError() == false;
-                            handleResponseProtobuf(requestId, remoteAddress, EMPTY_CODED_INPUT_STREAM, handler);
+                            handleResponse(requestId, remoteAddress, streamInput, handler);
                         }
                     } else {
-                        final StreamInput streamInput;
-                        if (message.getContentLength() > 0 || header.getVersion().equals(Version.CURRENT) == false) {
-                            streamInput = namedWriteableStream(message.openOrGetStreamInput());
-                            assertRemoteVersion(streamInput, header.getVersion());
-                            if (header.isError()) {
-                                handlerResponseError(requestId, streamInput, handler);
-                            } else {
-                                handleResponse(requestId, remoteAddress, streamInput, handler);
-                            }
-                        } else {
-                            assert header.isError() == false;
-                            handleResponse(requestId, remoteAddress, EMPTY_STREAM_INPUT, handler);
-                        }
+                        assert header.isError() == false;
+                        handleResponse(requestId, remoteAddress, EMPTY_STREAM_INPUT, handler);
                     }
                 }
             }
@@ -414,49 +397,24 @@ private <T extends TransportRequest> void handleRequest(TcpChannel channel, Head
                 if (message.isShortCircuit()) {
                     sendErrorResponse(action, transportChannel, message.getException());
                 } else {
-                    try {
-                        final StreamInput stream = namedWriteableStream(message.openOrGetStreamInput());
-                        assertRemoteVersion(stream, header.getVersion());
-                        final RequestHandlerRegistry<T> reg = requestHandlers.getHandler(action);
-                        assert reg != null;
-
-                        final T request = newRequest(requestId, action, stream, reg);
-                        request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
-                        checkStreamIsFullyConsumed(requestId, action, stream);
-
-                        final String executor = reg.getExecutor();
-                        if (ThreadPool.Names.SAME.equals(executor)) {
-                            try {
-                                reg.processMessageReceived(request, transportChannel);
-                            } catch (Exception e) {
-                                sendErrorResponse(reg.getAction(), transportChannel, e);
-                            }
-                        } else {
-                            threadPool.executor(executor).execute(new RequestHandler<>(reg, request, transportChannel));
-                        }
-                    } catch (Exception e) {
-                        // final CodedInputStream stream = message.openOrGetProtobufCodedInput();
-                        // final StreamInput stream = namedWriteableStream(message.openOrGetStreamInput());
-                        // assertRemoteVersion(stream, header.getVersion());
-                        final StreamInput stream = namedWriteableStream(message.openOrGetStreamInput());
-                        CodedInputStream codedInputStream = CodedInputStream.newInstance(stream);
-                        final ProtobufRequestHandlerRegistry<T> reg = protobufRequestHandlers.getHandler(action);
-                        assert reg != null;
-
-                        final T request = newRequestProtobuf(requestId, action, codedInputStream, reg);
-                        request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
-                        // checkStreamIsFullyConsumed(requestId, action, stream);
-
-                        final String executor = reg.getExecutor();
-                        if (ThreadPool.Names.SAME.equals(executor)) {
-                            try {
-                                reg.processMessageReceived(request, transportChannel);
-                            } catch (Exception exp) {
-                                sendErrorResponse(reg.getAction(), transportChannel, exp);
-                            }
-                        } else {
-                            // threadPool.executor(executor).execute(new RequestHandler<>(reg, request, transportChannel));
+                    final StreamInput stream = namedWriteableStream(message.openOrGetStreamInput());
+                    assertRemoteVersion(stream, header.getVersion());
+                    final RequestHandlerRegistry<T> reg = requestHandlers.getHandler(action);
+                    assert reg != null;
+
+                    final T request = newRequest(requestId, action, stream, reg);
+                    request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
+                    checkStreamIsFullyConsumed(requestId, action, stream);
+
+                    final String executor = reg.getExecutor();
+                    if (ThreadPool.Names.SAME.equals(executor)) {
+                        try {
+                            reg.processMessageReceived(request, transportChannel);
+                        } catch (Exception e) {
+                            sendErrorResponse(reg.getAction(), transportChannel, e);
                         }
+                    } else {
+                        threadPool.executor(executor).execute(new RequestHandler<>(reg, request, transportChannel));
                     }
                 }
             } catch (Exception e) {
@@ -499,28 +457,6 @@ private <T extends TransportRequest> T newRequest(
         }
     }
 
-    private <T extends TransportRequest> T newRequestProtobuf(
-        final long requestId,
-        final String action,
-        final CodedInputStream stream,
-        final ProtobufRequestHandlerRegistry<T> reg
-    ) throws IOException {
-        try {
-            return reg.newRequest(stream);
-        } catch (final EOFException e) {
-            // Another favor of (de)serialization issues is when stream contains less bytes than
-            // the request handler needs to deserialize the payload.
-            throw new IllegalStateException(
-                "Message fully read (request) but more data is expected for requestId ["
-                    + requestId
-                    + "], action ["
-                    + action
-                    + "]; resetting",
-                e
-            );
-        }
-    }
-
     /**
      * Checks if the stream is fully consumed and throws the exceptions if that is not the case.
      * @param requestId request identifier
@@ -671,35 +607,6 @@ private <T extends TransportResponse> void handleProtobufResponse(
         }
     }
 
-    private <T extends TransportResponse> void handleResponseProtobuf(
-        final long requestId,
-        InetSocketAddress remoteAddress,
-        final CodedInputStream stream,
-        final TransportResponseHandler<T> handler
-    ) throws IOException {
-        System.out.println(stream.readTag());
-        final T response;
-        try {
-            response = handler.read(stream);
-            response.remoteAddress(new TransportAddress(remoteAddress));
-            // checkStreamIsFullyConsumed(requestId, handler, stream, false);
-        } catch (Exception e) {
-            final Exception serializationException = new TransportSerializationException(
-                "Failed to deserialize response from handler [" + handler + "]",
-                e
-            );
-            logger.warn(new ParameterizedMessage("Failed to deserialize response from [{}]", remoteAddress), serializationException);
-            handleException(handler, serializationException);
-            return;
-        }
-        final String executor = handler.executor();
-        if (ThreadPool.Names.SAME.equals(executor)) {
-            doHandleResponse(handler, response);
-        } else {
-            threadPool.executor(executor).execute(() -> doHandleResponse(handler, response));
-        }
-    }
-
     private <T extends TransportResponse> void doHandleResponse(TransportResponseHandler<T> handler, T response) {
         try {
             handler.handleResponse(response);
@@ -722,21 +629,6 @@ private void handlerResponseError(final long requestId, StreamInput stream, fina
         handleException(handler, error);
     }
 
-    private void handlerResponseErrorProtobuf(final long requestId, CodedInputStream stream, final TransportResponseHandler<?> handler) {
-        Exception error;
-        try {
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(stream);
-            error = protobufStreamInput.readException();
-            // checkStreamIsFullyConsumed(requestId, handler, stream, true);
-        } catch (Exception e) {
-            error = new TransportSerializationException(
-                "Failed to deserialize exception response from stream for handler [" + handler + "]",
-                e
-            );
-        }
-        handleException(handler, error);
-    }
-
     private void handleException(final TransportResponseHandler<?> handler, Throwable error) {
         if (!(error instanceof RemoteTransportException)) {
             error = new RemoteTransportException(error.getMessage(), error);
diff --git a/server/src/main/java/org/opensearch/transport/InboundMessage.java b/server/src/main/java/org/opensearch/transport/InboundMessage.java
index b15af4d236926..dc8b3954f7916 100644
--- a/server/src/main/java/org/opensearch/transport/InboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/InboundMessage.java
@@ -33,13 +33,11 @@
 package org.opensearch.transport;
 
 import org.opensearch.common.bytes.ReleasableBytesReference;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.lease.Releasables;
-
-import com.google.protobuf.CodedInputStream;
+import org.opensearch.common.util.io.IOUtils;
 
 import java.io.IOException;
 
@@ -56,7 +54,6 @@ public class InboundMessage implements Releasable {
     private final boolean isPing;
     private Releasable breakerRelease;
     private StreamInput streamInput;
-    private CodedInputStream codedInputStream;
 
     public InboundMessage(Header header, ReleasableBytesReference content, Releasable breakerRelease) {
         this.header = header;
@@ -125,17 +122,6 @@ public StreamInput openOrGetStreamInput() throws IOException {
         return streamInput;
     }
 
-    public CodedInputStream openOrGetProtobufCodedInput() throws IOException {
-        assert isPing == false && content != null;
-        if (codedInputStream == null) {
-            streamInput = content.streamInput();
-            codedInputStream = CodedInputStream.newInstance(streamInput);
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(codedInputStream);
-            protobufStreamInput.setVersion(header.getVersion());
-        }
-        return codedInputStream;
-    }
-
     @Override
     public void close() {
         IOUtils.closeWhileHandlingException(streamInput);
diff --git a/server/src/main/java/org/opensearch/transport/PlainTransportFuture.java b/server/src/main/java/org/opensearch/transport/PlainTransportFuture.java
index 6ac8565f0cf0a..71ab562cdc1de 100644
--- a/server/src/main/java/org/opensearch/transport/PlainTransportFuture.java
+++ b/server/src/main/java/org/opensearch/transport/PlainTransportFuture.java
@@ -37,8 +37,6 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.util.concurrent.BaseFuture;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
@@ -127,21 +125,10 @@ public String toString() {
         return "future(" + handler.toString() + ")";
     }
 
-    @Override
-    public V read(CodedInputStream in) throws IOException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'read'");
-    }
-
-    @Override
-    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-    }
-
     @Override
     public V read(byte[] in) throws IOException {
         // TODO Auto-generated method stub
         throw new UnsupportedOperationException("Unimplemented method 'read'");
     }
+
 }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufActionTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufActionTransportException.java
deleted file mode 100644
index a5dcffd4a6861..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufActionTransportException.java
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.transport.TransportAddress;
-
-import java.io.IOException;
-
-/**
- * An action invocation failure.
-*
-* @opensearch.internal
-*/
-public class ProtobufActionTransportException extends ProtobufTransportException {
-
-    private final TransportAddress address;
-
-    private final String action;
-
-    public ProtobufActionTransportException(CodedInputStream in) throws IOException {
-        super(in);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        address = protobufStreamInput.readOptionalWriteable(TransportAddress::new);
-        action = protobufStreamInput.readOptionalString();
-    }
-
-    public ProtobufActionTransportException(String name, TransportAddress address, String action, Throwable cause) {
-        super(buildMessage(name, address, action, null), cause);
-        this.address = address;
-        this.action = action;
-    }
-
-    public ProtobufActionTransportException(String name, TransportAddress address, String action, String msg, Throwable cause) {
-        super(buildMessage(name, address, action, msg), cause);
-        this.address = address;
-        this.action = action;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        super.writeTo(out);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeOptionalWriteable(address);
-        protobufStreamOutput.writeOptionalString(action);
-    }
-
-    /**
-     * The target address to invoke the action on.
-    */
-    public TransportAddress address() {
-        return address;
-    }
-
-    /**
-     * The action to invoke.
-    */
-    public String action() {
-        return action;
-    }
-
-    private static String buildMessage(String name, TransportAddress address, String action, String msg) {
-        StringBuilder sb = new StringBuilder();
-        if (name != null) {
-            sb.append('[').append(name).append(']');
-        }
-        if (address != null) {
-            sb.append('[').append(address).append(']');
-        }
-        if (action != null) {
-            sb.append('[').append(action).append(']');
-        }
-        if (msg != null) {
-            sb.append(" ").append(msg);
-        }
-        return sb.toString();
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufBytesTransportRequest.java b/server/src/main/java/org/opensearch/transport/ProtobufBytesTransportRequest.java
deleted file mode 100644
index 7ad1a160e072a..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufBytesTransportRequest.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.Version;
-import org.opensearch.common.bytes.BytesReference;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-
-import java.io.IOException;
-
-/**
- * A specialized, bytes only request, that can potentially be optimized on the network
-* layer, specifically for the same large buffer send to several nodes.
-*
-* @opensearch.internal
-*/
-public class ProtobufBytesTransportRequest extends TransportRequest {
-
-    BytesReference bytes;
-    Version version;
-
-    public ProtobufBytesTransportRequest(CodedInputStream in) throws IOException {
-        super(in);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        bytes = protobufStreamInput.readBytesReference();
-        version = protobufStreamInput.getVersion();
-    }
-
-    public ProtobufBytesTransportRequest(BytesReference bytes, Version version) {
-        this.bytes = bytes;
-        this.version = version;
-    }
-
-    public Version version() {
-        return this.version;
-    }
-
-    public BytesReference bytes() {
-        return this.bytes;
-    }
-
-    /**
-     * Writes the data in a "thin" manner, without the actual bytes, assumes
-    * the actual bytes will be appended right after this content.
-    */
-    public void writeThin(CodedOutputStream out) throws IOException {
-        super.writeTo(out);
-        out.writeInt32NoTag(bytes.length());
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        super.writeTo(out);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        out.writeByteArrayNoTag(BytesReference.toBytes(bytes));
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufConnectTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufConnectTransportException.java
deleted file mode 100644
index e05ee7c83ca6d..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufConnectTransportException.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-
-import java.io.IOException;
-
-/**
- * Transport connection exception
-*
-* @opensearch.internal
-*/
-public class ProtobufConnectTransportException extends ProtobufActionTransportException {
-
-    private final DiscoveryNode node;
-
-    public ProtobufConnectTransportException(DiscoveryNode node, String msg) {
-        this(node, msg, null, null);
-    }
-
-    public ProtobufConnectTransportException(DiscoveryNode node, String msg, String action) {
-        this(node, msg, action, null);
-    }
-
-    public ProtobufConnectTransportException(DiscoveryNode node, String msg, Throwable cause) {
-        this(node, msg, null, cause);
-    }
-
-    public ProtobufConnectTransportException(DiscoveryNode node, String msg, String action, Throwable cause) {
-        super(node == null ? null : node.getName(), node == null ? null : node.getAddress(), action, msg, cause);
-        this.node = node;
-    }
-
-    public ProtobufConnectTransportException(CodedInputStream in) throws IOException {
-        super(in);
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-        node = protobufStreamInput.readOptionalWriteable(DiscoveryNode::new);
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        super.writeTo(out);
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeOptionalWriteable(node);
-    }
-
-    public DiscoveryNode node() {
-        return node;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java
index 4f28a234957c8..3308de616fc1e 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java
@@ -8,8 +8,6 @@
 
 package org.opensearch.transport;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 
 import org.opensearch.common.io.stream.StreamInput;
@@ -33,17 +31,9 @@ public ProtobufEmptyTransportResponseHandler(String executor) {
         this.executor = executor;
     }
 
-    @Override
-    public TransportResponse.Empty read(CodedInputStream in) {
-        return TransportResponse.Empty.INSTANCE;
-    }
-
     @Override
     public void handleResponse(TransportResponse.Empty response) {}
 
-    @Override
-    public void handleExceptionProtobuf(ProtobufTransportException exp) {}
-
     @Override
     public String executor() {
         return executor;
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufNetworkMessage.java b/server/src/main/java/org/opensearch/transport/ProtobufNetworkMessage.java
deleted file mode 100644
index c79233a4d46dc..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufNetworkMessage.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import org.opensearch.Version;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.util.concurrent.ThreadContext;
-
-/**
- * Represents a transport message sent over the network. Subclasses implement serialization and
-* deserialization.
-*
-* @opensearch.internal
-*/
-public abstract class ProtobufNetworkMessage {
-
-    protected final Version version;
-    protected final ProtobufWriteable threadContext;
-    protected final long requestId;
-    protected final byte status;
-
-    ProtobufNetworkMessage(ThreadContext threadContext, Version version, byte status, long requestId) {
-        this.threadContext = threadContext.captureAsProtobufWriteable();
-        this.version = version;
-        this.requestId = requestId;
-        this.status = status;
-    }
-
-    public Version getVersion() {
-        return version;
-    }
-
-    public long getRequestId() {
-        return requestId;
-    }
-
-    boolean isCompress() {
-        return TransportStatus.isCompress(status);
-    }
-
-    boolean isResponse() {
-        return TransportStatus.isRequest(status) == false;
-    }
-
-    boolean isRequest() {
-        return TransportStatus.isRequest(status);
-    }
-
-    boolean isHandshake() {
-        return TransportStatus.isHandshake(status);
-    }
-
-    boolean isError() {
-        return TransportStatus.isError(status);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufNodeDisconnectedException.java b/server/src/main/java/org/opensearch/transport/ProtobufNodeDisconnectedException.java
deleted file mode 100644
index 19a2ff22dfb55..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufNodeDisconnectedException.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import org.opensearch.cluster.node.DiscoveryNode;
-
-import java.io.IOException;
-
-/**
- * Exception thrown if a node disconnects
-*
-* @opensearch.internal
-*/
-public class ProtobufNodeDisconnectedException extends ProtobufConnectTransportException {
-
-    public ProtobufNodeDisconnectedException(DiscoveryNode node, String action) {
-        super(node, "disconnected", action, null);
-    }
-
-    public ProtobufNodeDisconnectedException(CodedInputStream in) throws IOException {
-        super(in);
-    }
-
-    // stack trace is meaningless...
-
-    @Override
-    public Throwable fillInStackTrace() {
-        return this;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufNodeNotConnectedException.java b/server/src/main/java/org/opensearch/transport/ProtobufNodeNotConnectedException.java
deleted file mode 100644
index 1aa71c609f9d6..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufNodeNotConnectedException.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import org.opensearch.cluster.node.DiscoveryNode;
-
-import java.io.IOException;
-
-/**
- * An exception indicating that a message is sent to a node that is not connected.
-*
-* @opensearch.internal
-*/
-public class ProtobufNodeNotConnectedException extends ProtobufConnectTransportException {
-
-    public ProtobufNodeNotConnectedException(DiscoveryNode node, String msg) {
-        super(node, msg, (String) null);
-    }
-
-    public ProtobufNodeNotConnectedException(CodedInputStream in) throws IOException {
-        super(in);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufPlainTransportFuture.java b/server/src/main/java/org/opensearch/transport/ProtobufPlainTransportFuture.java
deleted file mode 100644
index d7d05e7703721..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufPlainTransportFuture.java
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import org.opensearch.OpenSearchException;
-import org.opensearch.OpenSearchTimeoutException;
-import org.opensearch.common.io.stream.StreamInput;
-import org.opensearch.common.util.concurrent.BaseFuture;
-
-import java.io.IOException;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-
-/**
- * Future for transporting data
-*
-* @opensearch.internal
-*/
-public class ProtobufPlainTransportFuture<V extends TransportResponse> extends BaseFuture<V>
-    implements
-        TransportFuture<V>,
-        TransportResponseHandler<V> {
-
-    private final TransportResponseHandler<V> handler;
-
-    public ProtobufPlainTransportFuture(TransportResponseHandler<V> handler) {
-        this.handler = handler;
-    }
-
-    @Override
-    public V txGet() {
-        try {
-            return get();
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-            throw new IllegalStateException("Future got interrupted", e);
-        } catch (ExecutionException e) {
-            if (e.getCause() instanceof OpenSearchException) {
-                throw (OpenSearchException) e.getCause();
-            } else {
-                throw new ProtobufTransportException("Failed execution", e);
-            }
-        }
-    }
-
-    @Override
-    public V txGet(long timeout, TimeUnit unit) {
-        try {
-            return get(timeout, unit);
-        } catch (TimeoutException e) {
-            throw new OpenSearchTimeoutException(e);
-        } catch (InterruptedException e) {
-            throw new IllegalStateException("Future got interrupted", e);
-        } catch (ExecutionException e) {
-            if (e.getCause() instanceof OpenSearchException) {
-                throw (OpenSearchException) e.getCause();
-            } else {
-                throw new ProtobufTransportException("Failed execution", e);
-            }
-        }
-    }
-
-    @Override
-    public V read(CodedInputStream in) throws IOException {
-        return handler.read(in);
-    }
-
-    @Override
-    public String executor() {
-        return handler.executor();
-    }
-
-    @Override
-    public void handleResponse(V response) {
-        try {
-            handler.handleResponse(response);
-            set(response);
-        } catch (Exception e) {
-            handleExceptionProtobuf(new ProtobufTransportException(e));
-        }
-    }
-
-    @Override
-    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-        try {
-            handler.handleExceptionProtobuf(exp);
-        } finally {
-            setException(exp);
-        }
-    }
-
-    @Override
-    public String toString() {
-        return "future(" + handler.toString() + ")";
-    }
-
-    @Override
-    public V read(StreamInput in) throws IOException {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'read'");
-    }
-
-    @Override
-    public void handleException(TransportException exp) {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'handleException'");
-    }
-
-    @Override
-    public V read(byte[] in) throws IOException {
-        return handler.read(in);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufProxyConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/ProtobufProxyConnectionStrategy.java
deleted file mode 100644
index fa2f36f63208c..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufProxyConnectionStrategy.java
+++ /dev/null
@@ -1,415 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.apache.logging.log4j.message.ParameterizedMessage;
-import org.opensearch.Version;
-import org.opensearch.action.ActionListener;
-import org.opensearch.cluster.ClusterName;
-import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.DiscoveryNodeRole;
-import org.opensearch.common.Strings;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.settings.Setting;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
-import org.opensearch.common.transport.TransportAddress;
-import org.opensearch.common.util.concurrent.CountDown;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.util.Collections;
-import java.util.Map;
-import java.util.Objects;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.Supplier;
-import java.util.stream.Stream;
-
-import static org.opensearch.common.settings.Setting.intSetting;
-
-/**
- * Connect through a proxy
-*
-* @opensearch.internal
-*/
-public class ProtobufProxyConnectionStrategy extends ProtobufRemoteConnectionStrategy {
-
-    /**
-     * The remote address for the proxy. The connections will be opened to the configured address.
-    */
-    public static final Setting.AffixSetting<String> PROXY_ADDRESS = Setting.affixKeySetting(
-        "cluster.remote.",
-        "proxy_address",
-        (ns, key) -> Setting.simpleString(key, new StrategyValidator<>(ns, key, ProtobufConnectionStrategy.PROXY, s -> {
-            if (Strings.hasLength(s)) {
-                parsePort(s);
-            }
-        }), Setting.Property.Dynamic, Setting.Property.NodeScope)
-    );
-
-    /**
-     * The maximum number of socket connections that will be established to a remote cluster. The default is 18.
-    */
-    public static final Setting.AffixSetting<Integer> REMOTE_SOCKET_CONNECTIONS = Setting.affixKeySetting(
-        "cluster.remote.",
-        "proxy_socket_connections",
-        (ns, key) -> intSetting(
-            key,
-            18,
-            1,
-            new StrategyValidator<>(ns, key, ProtobufConnectionStrategy.PROXY),
-            Setting.Property.Dynamic,
-            Setting.Property.NodeScope
-        )
-    );
-
-    /**
-     * A configurable server_name attribute
-    */
-    public static final Setting.AffixSetting<String> SERVER_NAME = Setting.affixKeySetting(
-        "cluster.remote.",
-        "server_name",
-        (ns, key) -> Setting.simpleString(
-            key,
-            new StrategyValidator<>(ns, key, ProtobufConnectionStrategy.PROXY),
-            Setting.Property.Dynamic,
-            Setting.Property.NodeScope
-        )
-    );
-
-    static final int CHANNELS_PER_CONNECTION = 1;
-
-    private static final int MAX_CONNECT_ATTEMPTS_PER_RUN = 3;
-
-    private final int maxNumConnections;
-    private final String configuredAddress;
-    private final String configuredServerName;
-    private final Supplier<TransportAddress> address;
-    private final AtomicReference<ClusterName> remoteClusterName = new AtomicReference<>();
-    private final ConnectionManager.ConnectionValidator clusterNameValidator;
-
-    ProtobufProxyConnectionStrategy(
-        String clusterAlias,
-        TransportService transportService,
-        RemoteConnectionManager connectionManager,
-        Settings settings
-    ) {
-        this(
-            clusterAlias,
-            transportService,
-            connectionManager,
-            settings,
-            REMOTE_SOCKET_CONNECTIONS.getConcreteSettingForNamespace(clusterAlias).get(settings),
-            PROXY_ADDRESS.getConcreteSettingForNamespace(clusterAlias).get(settings),
-            SERVER_NAME.getConcreteSettingForNamespace(clusterAlias).get(settings)
-        );
-    }
-
-    ProtobufProxyConnectionStrategy(
-        String clusterAlias,
-        TransportService transportService,
-        RemoteConnectionManager connectionManager,
-        Settings settings,
-        int maxNumConnections,
-        String configuredAddress
-    ) {
-        this(
-            clusterAlias,
-            transportService,
-            connectionManager,
-            settings,
-            maxNumConnections,
-            configuredAddress,
-            () -> resolveAddress(configuredAddress),
-            null
-        );
-    }
-
-    ProtobufProxyConnectionStrategy(
-        String clusterAlias,
-        TransportService transportService,
-        RemoteConnectionManager connectionManager,
-        Settings settings,
-        int maxNumConnections,
-        String configuredAddress,
-        String configuredServerName
-    ) {
-        this(
-            clusterAlias,
-            transportService,
-            connectionManager,
-            settings,
-            maxNumConnections,
-            configuredAddress,
-            () -> resolveAddress(configuredAddress),
-            configuredServerName
-        );
-    }
-
-    ProtobufProxyConnectionStrategy(
-        String clusterAlias,
-        TransportService transportService,
-        RemoteConnectionManager connectionManager,
-        Settings settings,
-        int maxNumConnections,
-        String configuredAddress,
-        Supplier<TransportAddress> address,
-        String configuredServerName
-    ) {
-        super(clusterAlias, transportService, connectionManager, settings);
-        this.maxNumConnections = maxNumConnections;
-        this.configuredAddress = configuredAddress;
-        this.configuredServerName = configuredServerName;
-        assert Strings.isEmpty(configuredAddress) == false : "Cannot use proxy connection strategy with no configured addresses";
-        this.address = address;
-        this.clusterNameValidator = (newConnection, actualProfile, listener) -> transportService.handshake(
-            newConnection,
-            actualProfile.getHandshakeTimeout().millis(),
-            cn -> true,
-            ActionListener.map(listener, resp -> {
-                ClusterName remote = resp.getClusterName();
-                if (remoteClusterName.compareAndSet(null, remote)) {
-                    return null;
-                } else {
-                    if (remoteClusterName.get().equals(remote) == false) {
-                        DiscoveryNode node = newConnection.getNode();
-                        throw new ProtobufConnectTransportException(node, "handshake failed. unexpected remote cluster name " + remote);
-                    }
-                    return null;
-                }
-            })
-        );
-    }
-
-    static Stream<Setting.AffixSetting<?>> enablementSettings() {
-        return Stream.of(ProxyConnectionStrategy.PROXY_ADDRESS);
-    }
-
-    static ProtobufWriteable.Reader<ProtobufRemoteConnectionInfo.ModeInfo> infoReader() {
-        return ProxyModeInfo::new;
-    }
-
-    @Override
-    protected boolean shouldOpenMoreConnections() {
-        return connectionManager.size() < maxNumConnections;
-    }
-
-    @Override
-    protected boolean strategyMustBeRebuilt(Settings newSettings) {
-        String address = PROXY_ADDRESS.getConcreteSettingForNamespace(clusterAlias).get(newSettings);
-        int numOfSockets = REMOTE_SOCKET_CONNECTIONS.getConcreteSettingForNamespace(clusterAlias).get(newSettings);
-        String serverName = SERVER_NAME.getConcreteSettingForNamespace(clusterAlias).get(newSettings);
-        return numOfSockets != maxNumConnections
-            || configuredAddress.equals(address) == false
-            || Objects.equals(serverName, configuredServerName) == false;
-    }
-
-    @Override
-    protected ProtobufConnectionStrategy strategyType() {
-        return ProtobufConnectionStrategy.PROXY;
-    }
-
-    @Override
-    protected void connectImpl(ActionListener<Void> listener) {
-        performProxyConnectionProcess(listener);
-    }
-
-    @Override
-    public ProtobufRemoteConnectionInfo.ModeInfo getModeInfo() {
-        return new ProxyModeInfo(configuredAddress, configuredServerName, maxNumConnections, connectionManager.size());
-    }
-
-    private void performProxyConnectionProcess(ActionListener<Void> listener) {
-        openConnections(listener, 1);
-    }
-
-    private void openConnections(ActionListener<Void> finished, int attemptNumber) {
-        if (attemptNumber <= MAX_CONNECT_ATTEMPTS_PER_RUN) {
-            TransportAddress resolved = address.get();
-
-            int remaining = maxNumConnections - connectionManager.size();
-            ActionListener<Void> compositeListener = new ActionListener<Void>() {
-
-                private final AtomicInteger successfulConnections = new AtomicInteger(0);
-                private final CountDown countDown = new CountDown(remaining);
-
-                @Override
-                public void onResponse(Void v) {
-                    successfulConnections.incrementAndGet();
-                    if (countDown.countDown()) {
-                        if (shouldOpenMoreConnections()) {
-                            openConnections(finished, attemptNumber + 1);
-                        } else {
-                            finished.onResponse(v);
-                        }
-                    }
-                }
-
-                @Override
-                public void onFailure(Exception e) {
-                    if (countDown.countDown()) {
-                        openConnections(finished, attemptNumber + 1);
-                    }
-                }
-            };
-
-            for (int i = 0; i < remaining; ++i) {
-                String id = clusterAlias + "#" + resolved;
-                Map<String, String> attributes;
-                if (Strings.isNullOrEmpty(configuredServerName)) {
-                    attributes = Collections.emptyMap();
-                } else {
-                    attributes = Collections.singletonMap("server_name", configuredServerName);
-                }
-                DiscoveryNode node = new DiscoveryNode(
-                    id,
-                    new TransportAddress(resolved.address()),
-                    attributes,
-                    DiscoveryNodeRole.BUILT_IN_ROLES,
-                    Version.CURRENT.minimumCompatibilityVersion()
-                );
-
-                connectionManager.connectToNode(node, null, clusterNameValidator, new ActionListener<Void>() {
-                    @Override
-                    public void onResponse(Void v) {
-                        compositeListener.onResponse(v);
-                    }
-
-                    @Override
-                    public void onFailure(Exception e) {
-                        logger.debug(
-                            new ParameterizedMessage(
-                                "failed to open remote connection [remote cluster: {}, address: {}]",
-                                clusterAlias,
-                                resolved
-                            ),
-                            e
-                        );
-                        compositeListener.onFailure(e);
-                    }
-                });
-            }
-        } else {
-            int openConnections = connectionManager.size();
-            if (openConnections == 0) {
-                finished.onFailure(
-                    new IllegalStateException("Unable to open any proxy connections to remote cluster [" + clusterAlias + "]")
-                );
-            } else {
-                logger.debug(
-                    "unable to open maximum number of connections [remote cluster: {}, opened: {}, maximum: {}]",
-                    clusterAlias,
-                    openConnections,
-                    maxNumConnections
-                );
-                finished.onResponse(null);
-            }
-        }
-    }
-
-    private static TransportAddress resolveAddress(String address) {
-        return new TransportAddress(parseConfiguredAddress(address));
-    }
-
-    /**
-     * Contains information about the proxy mode
-    *
-    * @opensearch.internal
-    */
-    public static class ProxyModeInfo implements ProtobufRemoteConnectionInfo.ModeInfo {
-
-        private final String address;
-        private final String serverName;
-        private final int maxSocketConnections;
-        private final int numSocketsConnected;
-
-        public ProxyModeInfo(String address, String serverName, int maxSocketConnections, int numSocketsConnected) {
-            this.address = address;
-            this.serverName = serverName;
-            this.maxSocketConnections = maxSocketConnections;
-            this.numSocketsConnected = numSocketsConnected;
-        }
-
-        private ProxyModeInfo(CodedInputStream input) throws IOException {
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(input);
-            address = input.readString();
-            serverName = input.readString();
-            maxSocketConnections = protobufStreamInput.readVInt();
-            numSocketsConnected = protobufStreamInput.readVInt();
-        }
-
-        @Override
-        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-            builder.field("proxy_address", address);
-            builder.field("server_name", serverName);
-            builder.field("num_proxy_sockets_connected", numSocketsConnected);
-            builder.field("max_proxy_socket_connections", maxSocketConnections);
-            return builder;
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            out.writeStringNoTag(address);
-            out.writeStringNoTag(serverName);
-            out.writeInt32NoTag(maxSocketConnections);
-            out.writeInt32NoTag(numSocketsConnected);
-        }
-
-        @Override
-        public boolean isConnected() {
-            return numSocketsConnected > 0;
-        }
-
-        @Override
-        public String modeName() {
-            return "proxy";
-        }
-
-        public String getAddress() {
-            return address;
-        }
-
-        public String getServerName() {
-            return serverName;
-        }
-
-        public int getMaxSocketConnections() {
-            return maxSocketConnections;
-        }
-
-        public int getNumSocketsConnected() {
-            return numSocketsConnected;
-        }
-
-        @Override
-        public ProtobufRemoteConnectionStrategy.ProtobufConnectionStrategy modeType() {
-            return ProtobufRemoteConnectionStrategy.ProtobufConnectionStrategy.PROXY;
-        }
-
-        @Override
-        public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
-            ProxyModeInfo otherProxy = (ProxyModeInfo) o;
-            return maxSocketConnections == otherProxy.maxSocketConnections
-                && numSocketsConnected == otherProxy.numSocketsConnected
-                && Objects.equals(address, otherProxy.address)
-                && Objects.equals(serverName, otherProxy.serverName);
-        }
-
-        @Override
-        public int hashCode() {
-            return Objects.hash(address, serverName, maxSocketConnections, numSocketsConnected);
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufReceiveTimeoutTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufReceiveTimeoutTransportException.java
deleted file mode 100644
index 137c1763b0bb5..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufReceiveTimeoutTransportException.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import org.opensearch.cluster.node.DiscoveryNode;
-
-import java.io.IOException;
-
-/**
- * Thrown when receiving a timeout
-*
-* @opensearch.internal
-*/
-public class ProtobufReceiveTimeoutTransportException extends ProtobufActionTransportException {
-
-    public ProtobufReceiveTimeoutTransportException(DiscoveryNode node, String action, String msg) {
-        super(node.getName(), node.getAddress(), action, msg, null);
-    }
-
-    public ProtobufReceiveTimeoutTransportException(CodedInputStream in) throws IOException {
-        super(in);
-    }
-
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java
deleted file mode 100644
index 3731e608197f0..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterAwareClient.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import org.opensearch.action.ProtobufActionType;
-import org.opensearch.action.ActionListener;
-import org.opensearch.action.ProtobufActionListenerResponseHandler;
-import org.opensearch.action.ProtobufActionRequest;
-import org.opensearch.action.ProtobufActionResponse;
-import org.opensearch.client.ProtobufClient;
-import org.opensearch.client.support.ProtobufAbstractClient;
-import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.threadpool.ThreadPool;
-
-/**
- * ProtobufClient that is aware of remote clusters
-*
-* @opensearch.internal
-*/
-final class ProtobufRemoteClusterAwareClient extends ProtobufAbstractClient {
-
-    private final TransportService service;
-    private final String clusterAlias;
-    private final RemoteClusterService remoteClusterService;
-
-    ProtobufRemoteClusterAwareClient(Settings settings, ThreadPool threadPool, TransportService service, String clusterAlias) {
-        super(settings, threadPool);
-        this.service = service;
-        this.clusterAlias = clusterAlias;
-        this.remoteClusterService = service.getRemoteClusterService();
-    }
-
-    @Override
-    protected <Request extends ProtobufActionRequest, Response extends ProtobufActionResponse> void doExecute(
-        ProtobufActionType<Response> action,
-        Request request,
-        ActionListener<Response> listener
-    ) {
-        remoteClusterService.ensureConnected(clusterAlias, ActionListener.wrap(v -> {
-            Transport.Connection connection;
-            if (request instanceof RemoteClusterAwareRequest) {
-                DiscoveryNode preferredTargetNode = ((RemoteClusterAwareRequest) request).getPreferredTargetNode();
-                connection = remoteClusterService.getConnection(preferredTargetNode, clusterAlias);
-            } else {
-                connection = remoteClusterService.getConnection(clusterAlias);
-            }
-            service.sendRequest(
-                connection,
-                action.name(),
-                request,
-                TransportRequestOptions.EMPTY,
-                new ProtobufActionListenerResponseHandler<>(listener, action.getResponseReaderTry())
-            );
-        }, listener::onFailure));
-    }
-
-    @Override
-    public void close() {
-        // do nothing
-    }
-
-    @Override
-    public ProtobufClient getRemoteClusterClient(String clusterAlias) {
-        return remoteClusterService.getRemoteClusterClientProtobuf(threadPool(), clusterAlias);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
deleted file mode 100644
index 695d49660b3ed..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterConnection.java
+++ /dev/null
@@ -1,247 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import org.opensearch.action.ActionListener;
-import org.opensearch.action.admin.cluster.state.ClusterStateAction;
-import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
-import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
-import org.opensearch.action.support.ContextPreservingActionListener;
-import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.DiscoveryNodes;
-import org.opensearch.common.io.stream.StreamInput;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.common.util.io.IOUtils;
-import org.opensearch.threadpool.ThreadPool;
-
-import java.io.Closeable;
-import java.io.IOException;
-import java.util.function.Function;
-
-/**
- * Represents a connection to a single remote cluster. In contrast to a local cluster a remote cluster is not joined such that the
-* current node is part of the cluster and it won't receive cluster state updates from the remote cluster. Remote clusters are also not
-* fully connected with the current node. From a connection perspective a local cluster forms a bi-directional star network while in the
-* remote case we only connect to a subset of the nodes in the cluster in an uni-directional fashion.
-*
-* This class also handles the discovery of nodes from the remote cluster. The initial list of seed nodes is only used to discover all nodes
-* in the remote cluster and connects to all eligible nodes, for details see {@link RemoteClusterService#REMOTE_NODE_ATTRIBUTE}.
-*
-* In the case of a disconnection, this class will issue a re-connect task to establish at most
-* {@link SniffConnectionStrategy#REMOTE_CONNECTIONS_PER_CLUSTER} until either all eligible nodes are exhausted or the maximum number of
-* connections per cluster has been reached.
-*
-* @opensearch.internal
-*/
-final class ProtobufRemoteClusterConnection implements Closeable {
-
-    private final TransportService transportService;
-    private final RemoteConnectionManager remoteConnectionManager;
-    private final ProtobufRemoteConnectionStrategy connectionStrategy;
-    private final String clusterAlias;
-    private final ThreadPool threadPool;
-    private volatile boolean skipUnavailable;
-    private final TimeValue initialConnectionTimeout;
-
-    /**
-     * Creates a new {@link ProtobufRemoteClusterConnection}
-    * @param settings the nodes settings object
-    * @param clusterAlias the configured alias of the cluster to connect to
-    * @param transportService the local nodes transport service
-    */
-    ProtobufRemoteClusterConnection(Settings settings, String clusterAlias, TransportService transportService) {
-        this.transportService = transportService;
-        this.clusterAlias = clusterAlias;
-        ConnectionProfile profile = ProtobufRemoteConnectionStrategy.buildConnectionProfile(clusterAlias, settings);
-        this.remoteConnectionManager = new RemoteConnectionManager(
-            clusterAlias,
-            createConnectionManager(profile, transportService)
-        );
-        this.connectionStrategy = ProtobufRemoteConnectionStrategy.buildStrategy(
-            clusterAlias,
-            transportService,
-            remoteConnectionManager,
-            settings
-        );
-        // we register the transport service here as a listener to make sure we notify handlers on disconnect etc.
-        this.remoteConnectionManager.addListener(transportService);
-        this.skipUnavailable = RemoteClusterService.REMOTE_CLUSTER_SKIP_UNAVAILABLE.getConcreteSettingForNamespace(clusterAlias)
-            .get(settings);
-        this.threadPool = transportService.threadPool;
-        initialConnectionTimeout = RemoteClusterService.REMOTE_INITIAL_CONNECTION_TIMEOUT_SETTING.get(settings);
-    }
-
-    /**
-     * Updates the skipUnavailable flag that can be dynamically set for each remote cluster
-    */
-    void updateSkipUnavailable(boolean skipUnavailable) {
-        this.skipUnavailable = skipUnavailable;
-    }
-
-    /**
-     * Returns whether this cluster is configured to be skipped when unavailable
-    */
-    boolean isSkipUnavailable() {
-        return skipUnavailable;
-    }
-
-    /**
-     * Ensures that this cluster is connected. If the cluster is connected this operation
-    * will invoke the listener immediately.
-    */
-    void ensureConnected(ActionListener<Void> listener) {
-        if (remoteConnectionManager.size() == 0) {
-            connectionStrategy.connect(listener);
-        } else {
-            listener.onResponse(null);
-        }
-    }
-
-    /**
-     * Collects all nodes on the connected cluster and returns / passes a nodeID to {@link DiscoveryNode} lookup function
-    * that returns <code>null</code> if the node ID is not found.
-    *
-    * The requests to get cluster state on the connected cluster are made in the system context because logically
-    * they are equivalent to checking a single detail in the local cluster state and should not require that the
-    * user who made the request that is using this method in its implementation is authorized to view the entire
-    * cluster state.
-    */
-    void collectNodes(ActionListener<Function<String, DiscoveryNode>> listener) {
-        Runnable runnable = () -> {
-            final ThreadContext threadContext = threadPool.getThreadContext();
-            final ContextPreservingActionListener<Function<String, DiscoveryNode>> contextPreservingActionListener =
-                new ContextPreservingActionListener<>(threadContext.newRestorableContext(false), listener);
-            try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
-                // we stash any context here since this is an internal execution and should not leak any existing context information
-                threadContext.markAsSystemContext();
-
-                final ProtobufClusterStateRequest request = new ProtobufClusterStateRequest();
-                request.clear();
-                request.nodes(true);
-                request.local(true); // run this on the node that gets the request it's as good as any other
-                Transport.Connection connection = remoteConnectionManager.getAnyRemoteConnection();
-                transportService.sendRequest(
-                    connection,
-                    ClusterStateAction.NAME,
-                    request,
-                    TransportRequestOptions.EMPTY,
-                    new TransportResponseHandler<ProtobufClusterStateResponse>() {
-
-                        @Override
-                        public ProtobufClusterStateResponse read(CodedInputStream in) throws IOException {
-                            return new ProtobufClusterStateResponse(in);
-                        }
-
-                        @Override
-                        public void handleResponse(ProtobufClusterStateResponse response) {
-                            DiscoveryNodes nodes = response.getState().nodes();
-                            contextPreservingActionListener.onResponse(nodes::get);
-                        }
-
-                        @Override
-                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                            contextPreservingActionListener.onFailure(exp);
-                        }
-
-                        @Override
-                        public String executor() {
-                            return ThreadPool.Names.SAME;
-                        }
-
-                        @Override
-                        public ProtobufClusterStateResponse read(StreamInput in) throws IOException {
-                            // TODO Auto-generated method stub
-                            throw new UnsupportedOperationException("Unimplemented method 'read'");
-                        }
-
-                        @Override
-                        public void handleException(TransportException exp) {
-                            // TODO Auto-generated method stub
-                            throw new UnsupportedOperationException("Unimplemented method 'handleException'");
-                        }
-
-                        @Override
-                        public ProtobufClusterStateResponse read(byte[] in) throws IOException {
-                            return new ProtobufClusterStateResponse(in);
-                        }
-                    }
-                );
-            }
-        };
-        try {
-            // just in case if we are not connected for some reason we try to connect and if we fail we have to notify the listener
-            // this will cause some back pressure on the search end and eventually will cause rejections but that's fine
-            // we can't proceed with a search on a cluster level.
-            // in the future we might want to just skip the remote nodes in such a case but that can already be implemented on the
-            // caller end since they provide the listener.
-            ensureConnected(ActionListener.wrap((x) -> runnable.run(), listener::onFailure));
-        } catch (Exception ex) {
-            listener.onFailure(ex);
-        }
-    }
-
-    /**
-     * Returns a connection to the remote cluster, preferably a direct connection to the provided {@link DiscoveryNode}.
-    * If such node is not connected, the returned connection will be a proxy connection that redirects to it.
-    */
-    Transport.Connection getConnection(DiscoveryNode remoteClusterNode) {
-        return remoteConnectionManager.getConnection(remoteClusterNode);
-    }
-
-    Transport.Connection getConnection() {
-        return remoteConnectionManager.getAnyRemoteConnection();
-    }
-
-    @Override
-    public void close() throws IOException {
-        IOUtils.close(connectionStrategy, remoteConnectionManager);
-    }
-
-    public boolean isClosed() {
-        return connectionStrategy.isClosed();
-    }
-
-    // for testing only
-    boolean assertNoRunningConnections() {
-        return connectionStrategy.assertNoRunningConnections();
-    }
-
-    boolean isNodeConnected(final DiscoveryNode node) {
-        return remoteConnectionManager.nodeConnected(node);
-    }
-
-    /**
-     * Get the information about remote nodes to be rendered on {@code _remote/info} requests.
-    */
-    public ProtobufRemoteConnectionInfo getConnectionInfo() {
-        return new ProtobufRemoteConnectionInfo(clusterAlias, connectionStrategy.getModeInfo(), initialConnectionTimeout, skipUnavailable);
-    }
-
-    int getNumNodesConnected() {
-        return remoteConnectionManager.size();
-    }
-
-    private static ConnectionManager createConnectionManager(
-        ConnectionProfile connectionProfile,
-        TransportService transportService
-    ) {
-        return new ClusterConnectionManager(connectionProfile, transportService.transport);
-    }
-
-    ConnectionManager getConnectionManager() {
-        return remoteConnectionManager;
-    }
-
-    boolean shouldRebuildConnection(Settings newSettings) {
-        return connectionStrategy.shouldRebuildConnection(newSettings);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java
deleted file mode 100644
index 404495e07588d..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteClusterService.java
+++ /dev/null
@@ -1,454 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.opensearch.action.ActionListener;
-import org.opensearch.action.OriginalIndices;
-import org.opensearch.action.support.GroupedActionListener;
-import org.opensearch.action.support.IndicesOptions;
-import org.opensearch.action.support.PlainActionFuture;
-import org.opensearch.client.ProtobufClient;
-import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.DiscoveryNodeRole;
-import org.opensearch.common.Strings;
-import org.opensearch.common.settings.ClusterSettings;
-import org.opensearch.common.settings.Setting;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.common.util.concurrent.ConcurrentCollections;
-import org.opensearch.common.util.concurrent.CountDown;
-import org.opensearch.common.util.io.IOUtils;
-import org.opensearch.threadpool.ThreadPool;
-
-import java.io.Closeable;
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.stream.Stream;
-
-import static org.opensearch.common.settings.Setting.boolSetting;
-import static org.opensearch.common.settings.Setting.timeSetting;
-
-/**
- * Basic service for accessing remote clusters via gateway nodes
-*
-* @opensearch.internal
-*/
-public final class ProtobufRemoteClusterService extends RemoteClusterAware implements Closeable {
-
-    private final Logger logger = LogManager.getLogger(ProtobufRemoteClusterService.class);
-
-    /**
-     * The initial connect timeout for remote cluster connections
-    */
-    public static final Setting<TimeValue> REMOTE_INITIAL_CONNECTION_TIMEOUT_SETTING = Setting.positiveTimeSetting(
-        "cluster.remote.initial_connect_timeout",
-        TimeValue.timeValueSeconds(30),
-        Setting.Property.NodeScope
-    );
-
-    /**
-     * The name of a node attribute to select nodes that should be connected to in the remote cluster.
-    * For instance a node can be configured with {@code node.attr.gateway: true} in order to be eligible as a gateway node between
-    * clusters. In that case {@code cluster.remote.node.attr: gateway} can be used to filter out other nodes in the remote cluster.
-    * The value of the setting is expected to be a boolean, {@code true} for nodes that can become gateways, {@code false} otherwise.
-    */
-    public static final Setting<String> REMOTE_NODE_ATTRIBUTE = Setting.simpleString(
-        "cluster.remote.node.attr",
-        Setting.Property.NodeScope
-    );
-
-    /**
-     * If <code>true</code> connecting to remote clusters is supported on this node. If <code>false</code> this node will not establish
-    * connections to any remote clusters configured. Search requests executed against this node (where this node is the coordinating node)
-    * will fail if remote cluster syntax is used as an index pattern. The default is <code>true</code>
-    */
-    public static final Setting<Boolean> ENABLE_REMOTE_CLUSTERS = Setting.boolSetting(
-        "cluster.remote.connect",
-        true,
-        Setting.Property.Deprecated,
-        Setting.Property.NodeScope
-    );
-
-    public static final Setting.AffixSetting<Boolean> REMOTE_CLUSTER_SKIP_UNAVAILABLE = Setting.affixKeySetting(
-        "cluster.remote.",
-        "skip_unavailable",
-        (ns, key) -> boolSetting(key, false, new RemoteConnectionEnabled<>(ns, key), Setting.Property.Dynamic, Setting.Property.NodeScope)
-    );
-
-    public static final Setting.AffixSetting<TimeValue> REMOTE_CLUSTER_PING_SCHEDULE = Setting.affixKeySetting(
-        "cluster.remote.",
-        "transport.ping_schedule",
-        (ns, key) -> timeSetting(
-            key,
-            TransportSettings.PING_SCHEDULE,
-            new RemoteConnectionEnabled<>(ns, key),
-            Setting.Property.Dynamic,
-            Setting.Property.NodeScope
-        )
-    );
-
-    public static final Setting.AffixSetting<Boolean> REMOTE_CLUSTER_COMPRESS = Setting.affixKeySetting(
-        "cluster.remote.",
-        "transport.compress",
-        (ns, key) -> boolSetting(
-            key,
-            TransportSettings.TRANSPORT_COMPRESS,
-            new RemoteConnectionEnabled<>(ns, key),
-            Setting.Property.Dynamic,
-            Setting.Property.NodeScope
-        )
-    );
-
-    private final boolean enabled;
-
-    public boolean isEnabled() {
-        return enabled;
-    }
-
-    private final TransportService transportService;
-    private final Map<String, ProtobufRemoteClusterConnection> remoteClusters = ConcurrentCollections.newConcurrentMap();
-
-    ProtobufRemoteClusterService(Settings settings, TransportService transportService) {
-        super(settings);
-        this.enabled = DiscoveryNode.isRemoteClusterClient(settings);
-        this.transportService = transportService;
-    }
-
-    /**
-     * Returns <code>true</code> if at least one remote cluster is configured
-    */
-    public boolean isCrossClusterSearchEnabled() {
-        return remoteClusters.isEmpty() == false;
-    }
-
-    boolean isRemoteNodeConnected(final String remoteCluster, final DiscoveryNode node) {
-        return remoteClusters.get(remoteCluster).isNodeConnected(node);
-    }
-
-    public Map<String, OriginalIndices> groupIndices(IndicesOptions indicesOptions, String[] indices, Predicate<String> indexExists) {
-        Map<String, OriginalIndices> originalIndicesMap = new HashMap<>();
-        if (isCrossClusterSearchEnabled()) {
-            final Map<String, List<String>> groupedIndices = groupClusterIndices(getRemoteClusterNames(), indices, indexExists);
-            if (groupedIndices.isEmpty()) {
-                // search on _all in the local cluster if neither local indices nor remote indices were specified
-                originalIndicesMap.put(LOCAL_CLUSTER_GROUP_KEY, new OriginalIndices(Strings.EMPTY_ARRAY, indicesOptions));
-            } else {
-                for (Map.Entry<String, List<String>> entry : groupedIndices.entrySet()) {
-                    String clusterAlias = entry.getKey();
-                    List<String> originalIndices = entry.getValue();
-                    originalIndicesMap.put(clusterAlias, new OriginalIndices(originalIndices.toArray(new String[0]), indicesOptions));
-                }
-            }
-        } else {
-            originalIndicesMap.put(LOCAL_CLUSTER_GROUP_KEY, new OriginalIndices(indices, indicesOptions));
-        }
-        return originalIndicesMap;
-    }
-
-    /**
-     * Returns <code>true</code> iff the given cluster is configured as a remote cluster. Otherwise <code>false</code>
-    */
-    boolean isRemoteClusterRegistered(String clusterName) {
-        return remoteClusters.containsKey(clusterName);
-    }
-
-    /**
-     * Returns the registered remote cluster names.
-    */
-    public Set<String> getRegisteredRemoteClusterNames() {
-        // remoteClusters is unmodifiable so its key set will be unmodifiable too
-        return remoteClusters.keySet();
-    }
-
-    /**
-     * Returns a connection to the given node on the given remote cluster
-    *
-    * @throws IllegalArgumentException if the remote cluster is unknown
-    */
-    public Transport.Connection getConnection(DiscoveryNode node, String cluster) {
-        return getRemoteClusterConnection(cluster).getConnection(node);
-    }
-
-    /**
-     * Ensures that the given cluster alias is connected. If the cluster is connected this operation
-    * will invoke the listener immediately.
-    */
-    void ensureConnected(String clusterAlias, ActionListener<Void> listener) {
-        getRemoteClusterConnection(clusterAlias).ensureConnected(listener);
-    }
-
-    /**
-     * Returns whether the cluster identified by the provided alias is configured to be skipped when unavailable
-    */
-    public boolean isSkipUnavailable(String clusterAlias) {
-        return getRemoteClusterConnection(clusterAlias).isSkipUnavailable();
-    }
-
-    public Transport.Connection getConnection(String cluster) {
-        return getRemoteClusterConnection(cluster).getConnection();
-    }
-
-    ProtobufRemoteClusterConnection getRemoteClusterConnection(String cluster) {
-        if (enabled == false) {
-            throw new IllegalArgumentException(
-                "this node does not have the " + DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName() + " role"
-            );
-        }
-        ProtobufRemoteClusterConnection connection = remoteClusters.get(cluster);
-        if (connection == null) {
-            throw new NoSuchRemoteClusterException(cluster);
-        }
-        return connection;
-    }
-
-    Set<String> getRemoteClusterNames() {
-        return this.remoteClusters.keySet();
-    }
-
-    @Override
-    public void listenForUpdates(ClusterSettings clusterSettings) {
-        super.listenForUpdates(clusterSettings);
-        clusterSettings.addAffixUpdateConsumer(REMOTE_CLUSTER_SKIP_UNAVAILABLE, this::updateSkipUnavailable, (alias, value) -> {});
-    }
-
-    private synchronized void updateSkipUnavailable(String clusterAlias, Boolean skipUnavailable) {
-        ProtobufRemoteClusterConnection remote = this.remoteClusters.get(clusterAlias);
-        if (remote != null) {
-            remote.updateSkipUnavailable(skipUnavailable);
-        }
-    }
-
-    @Override
-    protected void updateRemoteCluster(String clusterAlias, Settings settings) {
-        CountDownLatch latch = new CountDownLatch(1);
-        updateRemoteCluster(clusterAlias, settings, ActionListener.wrap(latch::countDown));
-
-        try {
-            // Wait 10 seconds for a connections. We must use a latch instead of a future because we
-            // are on the cluster state thread and our custom future implementation will throw an
-            // assertion.
-            if (latch.await(10, TimeUnit.SECONDS) == false) {
-                logger.warn("failed to connect to new remote cluster {} within {}", clusterAlias, TimeValue.timeValueSeconds(10));
-            }
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-        }
-    }
-
-    /**
-     * This method updates the list of remote clusters. It's intended to be used as an update consumer on the settings infrastructure
-    *
-    * @param clusterAlias a cluster alias to discovery node mapping representing the remote clusters seeds nodes
-    * @param newSettings the updated settings for the remote connection
-    * @param listener a listener invoked once every configured cluster has been connected to
-    */
-    synchronized void updateRemoteCluster(String clusterAlias, Settings newSettings, ActionListener<Void> listener) {
-        if (LOCAL_CLUSTER_GROUP_KEY.equals(clusterAlias)) {
-            throw new IllegalArgumentException("remote clusters must not have the empty string as its key");
-        }
-
-        ProtobufRemoteClusterConnection remote = this.remoteClusters.get(clusterAlias);
-        if (RemoteConnectionStrategy.isConnectionEnabled(clusterAlias, newSettings) == false) {
-            try {
-                IOUtils.close(remote);
-            } catch (IOException e) {
-                logger.warn("failed to close remote cluster connections for cluster: " + clusterAlias, e);
-            }
-            remoteClusters.remove(clusterAlias);
-            listener.onResponse(null);
-            return;
-        }
-
-        if (remote == null) {
-            // this is a new cluster we have to add a new representation
-            Settings finalSettings = Settings.builder().put(this.settings, false).put(newSettings, false).build();
-            remote = new ProtobufRemoteClusterConnection(finalSettings, clusterAlias, transportService);
-            remoteClusters.put(clusterAlias, remote);
-            remote.ensureConnected(listener);
-        } else if (remote.shouldRebuildConnection(newSettings)) {
-            // Changes to connection configuration. Must tear down existing connection
-            try {
-                IOUtils.close(remote);
-            } catch (IOException e) {
-                logger.warn("failed to close remote cluster connections for cluster: " + clusterAlias, e);
-            }
-            remoteClusters.remove(clusterAlias);
-            Settings finalSettings = Settings.builder().put(this.settings, false).put(newSettings, false).build();
-            remote = new ProtobufRemoteClusterConnection(finalSettings, clusterAlias, transportService);
-            remoteClusters.put(clusterAlias, remote);
-            remote.ensureConnected(listener);
-        } else {
-            // No changes to connection configuration.
-            listener.onResponse(null);
-        }
-    }
-
-    /**
-     * Connects to all remote clusters in a blocking fashion. This should be called on node startup to establish an initial connection
-    * to all configured seed nodes.
-    */
-    void initializeRemoteClusters() {
-        final TimeValue timeValue = REMOTE_INITIAL_CONNECTION_TIMEOUT_SETTING.get(settings);
-        final PlainActionFuture<Collection<Void>> future = new PlainActionFuture<>();
-        Set<String> enabledClusters = RemoteClusterAware.getEnabledRemoteClusters(settings);
-
-        if (enabledClusters.isEmpty()) {
-            return;
-        }
-
-        GroupedActionListener<Void> listener = new GroupedActionListener<>(future, enabledClusters.size());
-        for (String clusterAlias : enabledClusters) {
-            updateRemoteCluster(clusterAlias, settings, listener);
-        }
-
-        if (enabledClusters.isEmpty()) {
-            future.onResponse(null);
-        }
-
-        try {
-            future.get(timeValue.millis(), TimeUnit.MILLISECONDS);
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-        } catch (TimeoutException ex) {
-            logger.warn("failed to connect to remote clusters within {}", timeValue.toString());
-        } catch (Exception e) {
-            throw new IllegalStateException("failed to connect to remote clusters", e);
-        }
-    }
-
-    @Override
-    public void close() throws IOException {
-        IOUtils.close(remoteClusters.values());
-    }
-
-    public Stream<ProtobufRemoteConnectionInfo> getRemoteConnectionInfos() {
-        return remoteClusters.values().stream().map(ProtobufRemoteClusterConnection::getConnectionInfo);
-    }
-
-    /**
-     * Collects all nodes of the given clusters and returns / passes a (clusterAlias, nodeId) to {@link DiscoveryNode}
-    * function on success.
-    */
-    public void collectNodes(Set<String> clusters, ActionListener<BiFunction<String, String, DiscoveryNode>> listener) {
-        if (enabled == false) {
-            throw new IllegalArgumentException(
-                "this node does not have the " + DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName() + " role"
-            );
-        }
-        Map<String, ProtobufRemoteClusterConnection> remoteClusters = this.remoteClusters;
-        for (String cluster : clusters) {
-            if (remoteClusters.containsKey(cluster) == false) {
-                listener.onFailure(new NoSuchRemoteClusterException(cluster));
-                return;
-            }
-        }
-
-        final Map<String, Function<String, DiscoveryNode>> clusterMap = new HashMap<>();
-        CountDown countDown = new CountDown(clusters.size());
-        Function<String, DiscoveryNode> nullFunction = s -> null;
-        for (final String cluster : clusters) {
-            ProtobufRemoteClusterConnection connection = remoteClusters.get(cluster);
-            connection.collectNodes(new ActionListener<Function<String, DiscoveryNode>>() {
-                @Override
-                public void onResponse(Function<String, DiscoveryNode> nodeLookup) {
-                    synchronized (clusterMap) {
-                        clusterMap.put(cluster, nodeLookup);
-                    }
-                    if (countDown.countDown()) {
-                        listener.onResponse((clusterAlias, nodeId) -> clusterMap.getOrDefault(clusterAlias, nullFunction).apply(nodeId));
-                    }
-                }
-
-                @Override
-                public void onFailure(Exception e) {
-                    if (countDown.fastForward()) { // we need to check if it's true since we could have multiple failures
-                        listener.onFailure(e);
-                    }
-                }
-            });
-        }
-    }
-
-    /**
-     * Returns a client to the remote cluster if the given cluster alias exists.
-    *
-    * @param threadPool   the {@link ThreadPool} for the client
-    * @param clusterAlias the cluster alias the remote cluster is registered under
-    * @throws IllegalArgumentException if the given clusterAlias doesn't exist
-    */
-    public ProtobufClient getRemoteClusterClient(ThreadPool threadPool, String clusterAlias) {
-        if (transportService.getRemoteClusterService().isEnabled() == false) {
-            throw new IllegalArgumentException(
-                "this node does not have the " + DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName() + " role"
-            );
-        }
-        if (transportService.getRemoteClusterService().getRemoteClusterNames().contains(clusterAlias) == false) {
-            throw new NoSuchRemoteClusterException(clusterAlias);
-        }
-        return new ProtobufRemoteClusterAwareClient(settings, threadPool, transportService, clusterAlias);
-    }
-
-    Collection<ProtobufRemoteClusterConnection> getConnections() {
-        return remoteClusters.values();
-    }
-
-    /**
-     * Internal class to hold cluster alias and key and track a remote connection
-    *
-    * @opensearch.internal
-    */
-    private static class RemoteConnectionEnabled<T> implements Setting.Validator<T> {
-
-        private final String clusterAlias;
-        private final String key;
-
-        private RemoteConnectionEnabled(String clusterAlias, String key) {
-            this.clusterAlias = clusterAlias;
-            this.key = key;
-        }
-
-        @Override
-        public void validate(T value) {}
-
-        @Override
-        public void validate(T value, Map<Setting<?>, Object> settings, boolean isPresent) {
-            if (isPresent && RemoteConnectionStrategy.isConnectionEnabled(clusterAlias, settings) == false) {
-                throw new IllegalArgumentException("Cannot configure setting [" + key + "] if remote cluster is not enabled.");
-            }
-        }
-
-        @Override
-        public Iterator<Setting<?>> settings() {
-            return Stream.concat(
-                Stream.of(RemoteConnectionStrategy.REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(clusterAlias)),
-                settingsStream()
-            ).iterator();
-        }
-
-        private Stream<Setting<?>> settingsStream() {
-            return Arrays.stream(RemoteConnectionStrategy.ConnectionStrategy.values())
-                .flatMap(strategy -> strategy.getEnablementSettings().get())
-                .map(as -> as.getConcreteSettingForNamespace(clusterAlias));
-        }
-    };
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionInfo.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionInfo.java
deleted file mode 100644
index 6527c3e0e5814..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionInfo.java
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-import java.util.Objects;
-
-/**
- * This class encapsulates all remote cluster information to be rendered on
-* {@code _remote/info} requests.
-*
-* @opensearch.internal
-*/
-public final class ProtobufRemoteConnectionInfo implements ToXContentFragment, ProtobufWriteable {
-
-    final ModeInfo modeInfo;
-    final TimeValue initialConnectionTimeout;
-    final String clusterAlias;
-    final boolean skipUnavailable;
-
-    public ProtobufRemoteConnectionInfo(
-        String clusterAlias,
-        ModeInfo modeInfo,
-        TimeValue initialConnectionTimeout,
-        boolean skipUnavailable
-    ) {
-        this.clusterAlias = clusterAlias;
-        this.modeInfo = modeInfo;
-        this.initialConnectionTimeout = initialConnectionTimeout;
-        this.skipUnavailable = skipUnavailable;
-    }
-
-    public ProtobufRemoteConnectionInfo(CodedInputStream input) throws IOException {
-        ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(input);
-        ProtobufRemoteConnectionStrategy.ProtobufConnectionStrategy mode = protobufStreamInput.readEnum(
-            ProtobufRemoteConnectionStrategy.ProtobufConnectionStrategy.class
-        );
-        modeInfo = mode.getReader().read(input);
-        initialConnectionTimeout = protobufStreamInput.readTimeValue();
-        clusterAlias = input.readString();
-        skipUnavailable = input.readBool();
-    }
-
-    public boolean isConnected() {
-        return modeInfo.isConnected();
-    }
-
-    public String getClusterAlias() {
-        return clusterAlias;
-    }
-
-    public ModeInfo getModeInfo() {
-        return modeInfo;
-    }
-
-    public TimeValue getInitialConnectionTimeout() {
-        return initialConnectionTimeout;
-    }
-
-    public boolean isSkipUnavailable() {
-        return skipUnavailable;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-        protobufStreamOutput.writeEnum(modeInfo.modeType());
-        modeInfo.writeTo(out);
-        protobufStreamOutput.writeTimeValue(initialConnectionTimeout);
-        out.writeStringNoTag(clusterAlias);
-        out.writeBoolNoTag(skipUnavailable);
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(clusterAlias);
-        {
-            builder.field("connected", modeInfo.isConnected());
-            builder.field("mode", modeInfo.modeName());
-            modeInfo.toXContent(builder, params);
-            builder.field("initial_connect_timeout", initialConnectionTimeout);
-            builder.field("skip_unavailable", skipUnavailable);
-        }
-        builder.endObject();
-        return builder;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        ProtobufRemoteConnectionInfo that = (ProtobufRemoteConnectionInfo) o;
-        return skipUnavailable == that.skipUnavailable
-            && Objects.equals(modeInfo, that.modeInfo)
-            && Objects.equals(initialConnectionTimeout, that.initialConnectionTimeout)
-            && Objects.equals(clusterAlias, that.clusterAlias);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(modeInfo, initialConnectionTimeout, clusterAlias, skipUnavailable);
-    }
-
-    /**
-     * Mode information
-    *
-    * @opensearch.internal
-    */
-    public interface ModeInfo extends ToXContentFragment, ProtobufWriteable {
-
-        boolean isConnected();
-
-        String modeName();
-
-        ProtobufRemoteConnectionStrategy.ProtobufConnectionStrategy modeType();
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java
deleted file mode 100644
index ffab5879f527b..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteConnectionStrategy.java
+++ /dev/null
@@ -1,484 +0,0 @@
-/*
-* 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.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.message.ParameterizedMessage;
-import org.apache.lucene.store.AlreadyClosedException;
-import org.opensearch.action.ActionListener;
-import org.opensearch.action.support.ContextPreservingActionListener;
-import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.common.Strings;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.settings.Setting;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.unit.TimeValue;
-import org.opensearch.common.util.concurrent.AbstractRunnable;
-import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
-import org.opensearch.threadpool.ThreadPool;
-
-import java.io.Closeable;
-import java.net.InetAddress;
-import java.net.InetSocketAddress;
-import java.net.UnknownHostException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.Consumer;
-import java.util.function.Supplier;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-/**
- * Strategy to connect to remote nodes
-*
-* @opensearch.internal
-*/
-public abstract class ProtobufRemoteConnectionStrategy implements TransportConnectionListener, Closeable {
-
-    enum ProtobufConnectionStrategy {
-        SNIFF(
-            ProtobufSniffConnectionStrategy.CHANNELS_PER_CONNECTION,
-            ProtobufSniffConnectionStrategy::enablementSettings,
-            ProtobufSniffConnectionStrategy::infoReader
-        ) {
-            @Override
-            public String toString() {
-                return "sniff";
-            }
-        },
-        PROXY(
-            ProtobufProxyConnectionStrategy.CHANNELS_PER_CONNECTION,
-            ProtobufProxyConnectionStrategy::enablementSettings,
-            ProtobufProxyConnectionStrategy::infoReader
-        ) {
-            @Override
-            public String toString() {
-                return "proxy";
-            }
-        };
-
-        private final int numberOfChannels;
-        private final Supplier<Stream<Setting.AffixSetting<?>>> enablementSettings;
-        private final Supplier<ProtobufWriteable.Reader<ProtobufRemoteConnectionInfo.ModeInfo>> reader;
-
-        ProtobufConnectionStrategy(
-            int numberOfChannels,
-            Supplier<Stream<Setting.AffixSetting<?>>> enablementSettings,
-            Supplier<ProtobufWriteable.Reader<ProtobufRemoteConnectionInfo.ModeInfo>> reader
-        ) {
-            this.numberOfChannels = numberOfChannels;
-            this.enablementSettings = enablementSettings;
-            this.reader = reader;
-        }
-
-        public int getNumberOfChannels() {
-            return numberOfChannels;
-        }
-
-        public Supplier<Stream<Setting.AffixSetting<?>>> getEnablementSettings() {
-            return enablementSettings;
-        }
-
-        public ProtobufWriteable.Reader<ProtobufRemoteConnectionInfo.ModeInfo> getReader() {
-            return reader.get();
-        }
-    }
-
-    public static final Setting.AffixSetting<ProtobufConnectionStrategy> REMOTE_CONNECTION_MODE = Setting.affixKeySetting(
-        "cluster.remote.",
-        "mode",
-        key -> new Setting<>(
-            key,
-            ProtobufConnectionStrategy.SNIFF.name(),
-            value -> ProtobufConnectionStrategy.valueOf(value.toUpperCase(Locale.ROOT)),
-            Setting.Property.NodeScope,
-            Setting.Property.Dynamic
-        )
-    );
-
-    // this setting is intentionally not registered, it is only used in tests
-    public static final Setting<Integer> REMOTE_MAX_PENDING_CONNECTION_LISTENERS = Setting.intSetting(
-        "cluster.remote.max_pending_connection_listeners",
-        1000,
-        Setting.Property.NodeScope
-    );
-
-    private final int maxPendingConnectionListeners;
-
-    protected final Logger logger = LogManager.getLogger(getClass());
-
-    private final AtomicBoolean closed = new AtomicBoolean(false);
-    private final Object mutex = new Object();
-    private List<ActionListener<Void>> listeners = new ArrayList<>();
-
-    protected final TransportService transportService;
-    protected final RemoteConnectionManager connectionManager;
-    protected final String clusterAlias;
-
-    ProtobufRemoteConnectionStrategy(
-        String clusterAlias,
-        TransportService transportService,
-        RemoteConnectionManager connectionManager,
-        Settings settings
-    ) {
-        this.clusterAlias = clusterAlias;
-        this.transportService = transportService;
-        this.connectionManager = connectionManager;
-        this.maxPendingConnectionListeners = REMOTE_MAX_PENDING_CONNECTION_LISTENERS.get(settings);
-        connectionManager.addListener(this);
-    }
-
-    static ConnectionProfile buildConnectionProfile(String clusterAlias, Settings settings) {
-        ProtobufConnectionStrategy mode = REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(clusterAlias).get(settings);
-        ConnectionProfile.Builder builder = new ConnectionProfile.Builder().setConnectTimeout(
-            TransportSettings.CONNECT_TIMEOUT.get(settings)
-        )
-            .setHandshakeTimeout(TransportSettings.CONNECT_TIMEOUT.get(settings))
-            .setCompressionEnabled(RemoteClusterService.REMOTE_CLUSTER_COMPRESS.getConcreteSettingForNamespace(clusterAlias).get(settings))
-            .setPingInterval(RemoteClusterService.REMOTE_CLUSTER_PING_SCHEDULE.getConcreteSettingForNamespace(clusterAlias).get(settings))
-            .addConnections(
-                0,
-                TransportRequestOptions.Type.BULK,
-                TransportRequestOptions.Type.STATE,
-                TransportRequestOptions.Type.RECOVERY,
-                TransportRequestOptions.Type.PING
-            )
-            .addConnections(mode.numberOfChannels, TransportRequestOptions.Type.REG);
-        return builder.build();
-    }
-
-    static ProtobufRemoteConnectionStrategy buildStrategy(
-        String clusterAlias,
-        TransportService transportService,
-        RemoteConnectionManager connectionManager,
-        Settings settings
-    ) {
-        ProtobufConnectionStrategy mode = REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(clusterAlias).get(settings);
-        switch (mode) {
-            case SNIFF:
-                return new ProtobufSniffConnectionStrategy(clusterAlias, transportService, connectionManager, settings);
-            case PROXY:
-                return new ProtobufProxyConnectionStrategy(clusterAlias, transportService, connectionManager, settings);
-            default:
-                throw new AssertionError("Invalid connection strategy" + mode);
-        }
-    }
-
-    static Set<String> getRemoteClusters(Settings settings) {
-        final Stream<Setting.AffixSetting<?>> enablementSettings = Arrays.stream(ProtobufConnectionStrategy.values())
-            .flatMap(strategy -> strategy.getEnablementSettings().get());
-        return enablementSettings.flatMap(s -> getClusterAlias(settings, s)).collect(Collectors.toSet());
-    }
-
-    public static boolean isConnectionEnabled(String clusterAlias, Settings settings) {
-        ProtobufConnectionStrategy mode = REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(clusterAlias).get(settings);
-        if (mode.equals(ProtobufConnectionStrategy.SNIFF)) {
-            List<String> seeds = ProtobufSniffConnectionStrategy.REMOTE_CLUSTER_SEEDS.getConcreteSettingForNamespace(clusterAlias)
-                .get(settings);
-            return seeds.isEmpty() == false;
-        } else {
-            String address = ProtobufProxyConnectionStrategy.PROXY_ADDRESS.getConcreteSettingForNamespace(clusterAlias).get(settings);
-            return Strings.isEmpty(address) == false;
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    public static boolean isConnectionEnabled(String clusterAlias, Map<Setting<?>, Object> settings) {
-        ProtobufConnectionStrategy mode = (ProtobufConnectionStrategy) settings.get(
-            REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(clusterAlias)
-        );
-        if (mode.equals(ProtobufConnectionStrategy.SNIFF)) {
-            List<String> seeds = (List<String>) settings.get(
-                ProtobufSniffConnectionStrategy.REMOTE_CLUSTER_SEEDS.getConcreteSettingForNamespace(clusterAlias)
-            );
-            return seeds.isEmpty() == false;
-        } else {
-            String address = (String) settings.get(
-                ProtobufProxyConnectionStrategy.PROXY_ADDRESS.getConcreteSettingForNamespace(clusterAlias)
-            );
-            return Strings.isEmpty(address) == false;
-        }
-    }
-
-    private static <T> Stream<String> getClusterAlias(Settings settings, Setting.AffixSetting<T> affixSetting) {
-        Stream<Setting<T>> allConcreteSettings = affixSetting.getAllConcreteSettings(settings);
-        return allConcreteSettings.map(affixSetting::getNamespace);
-    }
-
-    static InetSocketAddress parseConfiguredAddress(String configuredAddress) {
-        final String host = parseHost(configuredAddress);
-        final int port = parsePort(configuredAddress);
-        InetAddress hostAddress;
-        try {
-            hostAddress = InetAddress.getByName(host);
-        } catch (UnknownHostException e) {
-            throw new IllegalArgumentException("unknown host [" + host + "]", e);
-        }
-        return new InetSocketAddress(hostAddress, port);
-    }
-
-    static String parseHost(final String configuredAddress) {
-        return configuredAddress.substring(0, indexOfPortSeparator(configuredAddress));
-    }
-
-    static int parsePort(String remoteHost) {
-        try {
-            int port = Integer.parseInt(remoteHost.substring(indexOfPortSeparator(remoteHost) + 1));
-            if (port <= 0) {
-                throw new IllegalArgumentException("port number must be > 0 but was: [" + port + "]");
-            }
-            return port;
-        } catch (NumberFormatException e) {
-            throw new IllegalArgumentException("failed to parse port", e);
-        }
-    }
-
-    private static int indexOfPortSeparator(String remoteHost) {
-        int portSeparator = remoteHost.lastIndexOf(':'); // in case we have a IPv6 address ie. [::1]:9300
-        if (portSeparator == -1 || portSeparator == remoteHost.length()) {
-            throw new IllegalArgumentException("remote hosts need to be configured as [host:port], found [" + remoteHost + "] instead");
-        }
-        return portSeparator;
-    }
-
-    /**
-     * Triggers a connect round unless there is one running already. If there is a connect round running, the listener will either
-    * be queued or rejected and failed.
-    */
-    void connect(ActionListener<Void> connectListener) {
-        boolean runConnect = false;
-        final ActionListener<Void> listener = ContextPreservingActionListener.wrapPreservingContext(
-            connectListener,
-            transportService.getThreadPool().getThreadContext()
-        );
-        boolean closed;
-        synchronized (mutex) {
-            closed = this.closed.get();
-            if (closed) {
-                assert listeners.isEmpty();
-            } else {
-                if (listeners.size() >= maxPendingConnectionListeners) {
-                    assert listeners.size() == maxPendingConnectionListeners;
-                    listener.onFailure(new OpenSearchRejectedExecutionException("connect listener queue is full"));
-                    return;
-                } else {
-                    listeners.add(listener);
-                }
-                runConnect = listeners.size() == 1;
-            }
-        }
-        if (closed) {
-            connectListener.onFailure(new AlreadyClosedException("connect handler is already closed"));
-            return;
-        }
-        if (runConnect) {
-            ExecutorService executor = transportService.getThreadPool().executor(ThreadPool.Names.MANAGEMENT);
-            executor.submit(new AbstractRunnable() {
-                @Override
-                public void onFailure(Exception e) {
-                    ActionListener.onFailure(getAndClearListeners(), e);
-                }
-
-                @Override
-                protected void doRun() {
-                    connectImpl(new ActionListener<Void>() {
-                        @Override
-                        public void onResponse(Void aVoid) {
-                            ActionListener.onResponse(getAndClearListeners(), aVoid);
-                        }
-
-                        @Override
-                        public void onFailure(Exception e) {
-                            ActionListener.onFailure(getAndClearListeners(), e);
-                        }
-                    });
-                }
-            });
-        }
-    }
-
-    boolean shouldRebuildConnection(Settings newSettings) {
-        ProtobufConnectionStrategy newMode = REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(clusterAlias).get(newSettings);
-        if (newMode.equals(strategyType()) == false) {
-            return true;
-        } else {
-            Boolean compressionEnabled = RemoteClusterService.REMOTE_CLUSTER_COMPRESS.getConcreteSettingForNamespace(clusterAlias)
-                .get(newSettings);
-            TimeValue pingSchedule = RemoteClusterService.REMOTE_CLUSTER_PING_SCHEDULE.getConcreteSettingForNamespace(clusterAlias)
-                .get(newSettings);
-
-            ConnectionProfile oldProfile = connectionManager.getConnectionProfile();
-            ConnectionProfile.Builder builder = new ConnectionProfile.Builder(oldProfile);
-            builder.setCompressionEnabled(compressionEnabled);
-            builder.setPingInterval(pingSchedule);
-            ConnectionProfile newProfile = builder.build();
-            return connectionProfileChanged(oldProfile, newProfile) || strategyMustBeRebuilt(newSettings);
-        }
-    }
-
-    protected abstract boolean strategyMustBeRebuilt(Settings newSettings);
-
-    protected abstract ProtobufConnectionStrategy strategyType();
-
-    @Override
-    public void onNodeDisconnected(DiscoveryNode node, Transport.Connection connection) {
-        if (shouldOpenMoreConnections()) {
-            // try to reconnect and fill up the slot of the disconnected node
-            connect(
-                ActionListener.wrap(
-                    ignore -> logger.trace("[{}] successfully connected after disconnect of {}", clusterAlias, node),
-                    e -> logger.debug(
-                        () -> new ParameterizedMessage("[{}] failed to connect after disconnect of {}", clusterAlias, node),
-                        e
-                    )
-                )
-            );
-        }
-    }
-
-    @Override
-    public void close() {
-        final List<ActionListener<Void>> toNotify;
-        synchronized (mutex) {
-            if (closed.compareAndSet(false, true)) {
-                connectionManager.removeListener(this);
-                toNotify = listeners;
-                listeners = Collections.emptyList();
-            } else {
-                toNotify = Collections.emptyList();
-            }
-        }
-        ActionListener.onFailure(toNotify, new AlreadyClosedException("connect handler is already closed"));
-    }
-
-    public boolean isClosed() {
-        return closed.get();
-    }
-
-    // for testing only
-    boolean assertNoRunningConnections() {
-        synchronized (mutex) {
-            assert listeners.isEmpty();
-        }
-        return true;
-    }
-
-    protected abstract boolean shouldOpenMoreConnections();
-
-    protected abstract void connectImpl(ActionListener<Void> listener);
-
-    protected abstract ProtobufRemoteConnectionInfo.ModeInfo getModeInfo();
-
-    private List<ActionListener<Void>> getAndClearListeners() {
-        final List<ActionListener<Void>> result;
-        synchronized (mutex) {
-            if (listeners.isEmpty()) {
-                result = Collections.emptyList();
-            } else {
-                result = listeners;
-                listeners = new ArrayList<>();
-            }
-        }
-        return result;
-    }
-
-    private boolean connectionProfileChanged(ConnectionProfile oldProfile, ConnectionProfile newProfile) {
-        return Objects.equals(oldProfile.getCompressionEnabled(), newProfile.getCompressionEnabled()) == false
-            || Objects.equals(oldProfile.getPingInterval(), newProfile.getPingInterval()) == false;
-    }
-
-    /**
-     * Internal strategy validation object
-    *
-    * @opensearch.internal
-    */
-    static class StrategyValidator<T> implements Setting.Validator<T> {
-
-        private final String key;
-        private final ProtobufConnectionStrategy expectedStrategy;
-        private final String namespace;
-        private final Consumer<T> valueChecker;
-
-        StrategyValidator(String namespace, String key, ProtobufConnectionStrategy expectedStrategy) {
-            this(namespace, key, expectedStrategy, (v) -> {});
-        }
-
-        StrategyValidator(String namespace, String key, ProtobufConnectionStrategy expectedStrategy, Consumer<T> valueChecker) {
-            this.namespace = namespace;
-            this.key = key;
-            this.expectedStrategy = expectedStrategy;
-            this.valueChecker = valueChecker;
-        }
-
-        @Override
-        public void validate(T value) {
-            valueChecker.accept(value);
-        }
-
-        @Override
-        public void validate(T value, Map<Setting<?>, Object> settings, boolean isPresent) {
-            Setting<ProtobufConnectionStrategy> concrete = REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(namespace);
-            ProtobufConnectionStrategy modeType = (ProtobufConnectionStrategy) settings.get(concrete);
-            if (isPresent && modeType.equals(expectedStrategy) == false) {
-                throw new IllegalArgumentException(
-                    "Setting \""
-                        + key
-                        + "\" cannot be used with the configured \""
-                        + concrete.getKey()
-                        + "\" [required="
-                        + expectedStrategy.name()
-                        + ", configured="
-                        + modeType.name()
-                        + "]"
-                );
-            }
-        }
-
-        @Override
-        public Iterator<Setting<?>> settings() {
-            Setting<ProtobufConnectionStrategy> concrete = REMOTE_CONNECTION_MODE.getConcreteSettingForNamespace(namespace);
-            Stream<Setting<?>> settingStream = Stream.of(concrete);
-            return settingStream.iterator();
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRemoteTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufRemoteTransportException.java
deleted file mode 100644
index 9c2f0484b9d1a..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufRemoteTransportException.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import org.opensearch.OpenSearchWrapperException;
-import org.opensearch.common.transport.TransportAddress;
-
-import java.io.IOException;
-
-/**
- * A remote exception for an action. A wrapper exception around the actual remote cause and does not fill the
-* stack trace.
-*
-* @opensearch.internal
-*/
-public class ProtobufRemoteTransportException extends ProtobufActionTransportException implements OpenSearchWrapperException {
-
-    public ProtobufRemoteTransportException(String msg, Throwable cause) {
-        super(msg, null, null, cause);
-    }
-
-    public ProtobufRemoteTransportException(String name, TransportAddress address, String action, Throwable cause) {
-        super(name, address, action, cause);
-    }
-
-    public ProtobufRemoteTransportException(CodedInputStream in) throws IOException {
-        super(in);
-    }
-
-    @Override
-    public Throwable fillInStackTrace() {
-        // no need for stack trace here, we always have cause
-        return this;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
index 488a26b60e5d5..d6ca419277637 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
@@ -56,7 +56,7 @@ public String getAction() {
         return action;
     }
 
-    public Request newRequest(CodedInputStream in) throws IOException {
+    public Request newRequest(byte[] in) throws IOException {
         return requestReader.read(in);
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufSendRequestTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufSendRequestTransportException.java
deleted file mode 100644
index 88abf8e1bc4f1..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufSendRequestTransportException.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import org.opensearch.OpenSearchWrapperException;
-import org.opensearch.cluster.node.DiscoveryNode;
-
-import java.io.IOException;
-
-/**
- * Thrown when an error occurs while sending a request
-*
-* @opensearch.internal
-*/
-public class ProtobufSendRequestTransportException extends ProtobufActionTransportException implements OpenSearchWrapperException {
-
-    public ProtobufSendRequestTransportException(DiscoveryNode node, String action, Throwable cause) {
-        super(node == null ? null : node.getName(), node == null ? null : node.getAddress(), action, cause);
-    }
-
-    public ProtobufSendRequestTransportException(CodedInputStream in) throws IOException {
-        super(in);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java
deleted file mode 100644
index 7562cc3825c43..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufSniffConnectionStrategy.java
+++ /dev/null
@@ -1,646 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.apache.logging.log4j.message.ParameterizedMessage;
-import org.opensearch.Version;
-import org.opensearch.action.ActionListener;
-import org.opensearch.action.StepListener;
-import org.opensearch.action.admin.cluster.state.ClusterStateAction;
-import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
-import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
-import org.opensearch.cluster.ClusterName;
-import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.DiscoveryNodeRole;
-import org.opensearch.common.Booleans;
-import org.opensearch.common.SetOnce;
-import org.opensearch.common.Strings;
-import org.opensearch.common.UUIDs;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.io.stream.StreamInput;
-import org.opensearch.common.settings.Setting;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
-import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.common.util.io.IOUtils;
-import org.opensearch.threadpool.ThreadPool;
-
-import java.io.IOException;
-import java.net.InetSocketAddress;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Objects;
-import java.util.Set;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-import java.util.function.Supplier;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import static org.opensearch.common.settings.Setting.intSetting;
-
-/**
- * Sniff for initial seed nodes
-*
-* @opensearch.internal
-*/
-public class ProtobufSniffConnectionStrategy extends ProtobufRemoteConnectionStrategy {
-
-    /**
-     * A list of initial seed nodes to discover eligible nodes from the remote cluster
-    */
-    public static final Setting.AffixSetting<List<String>> REMOTE_CLUSTER_SEEDS = Setting.affixKeySetting(
-        "cluster.remote.",
-        "seeds",
-        (ns, key) -> Setting.listSetting(key, Collections.emptyList(), s -> {
-            // validate seed address
-            parsePort(s);
-            return s;
-        }, new StrategyValidator<>(ns, key, ProtobufConnectionStrategy.SNIFF), Setting.Property.Dynamic, Setting.Property.NodeScope)
-    );
-
-    /**
-     * A proxy address for the remote cluster. By default this is not set, meaning that OpenSearch will connect directly to the nodes in
-    * the remote cluster using their publish addresses. If this setting is set to an IP address or hostname then OpenSearch will connect
-    * to the nodes in the remote cluster using this address instead. Use of this setting is not recommended and it is deliberately
-    * undocumented as it does not work well with all proxies.
-    */
-    public static final Setting.AffixSetting<String> REMOTE_CLUSTERS_PROXY = Setting.affixKeySetting(
-        "cluster.remote.",
-        "proxy",
-        (ns, key) -> Setting.simpleString(key, new StrategyValidator<>(ns, key, ProtobufConnectionStrategy.SNIFF, s -> {
-            if (Strings.hasLength(s)) {
-                parsePort(s);
-            }
-        }), Setting.Property.Dynamic, Setting.Property.NodeScope),
-        () -> REMOTE_CLUSTER_SEEDS
-    );
-
-    /**
-     * The maximum number of connections that will be established to a remote cluster. For instance if there is only a single
-    * seed node, other nodes will be discovered up to the given number of nodes in this setting. The default is 3.
-    */
-    public static final Setting<Integer> REMOTE_CONNECTIONS_PER_CLUSTER = intSetting(
-        "cluster.remote.connections_per_cluster",
-        3,
-        1,
-        Setting.Property.NodeScope
-    );
-    /**
-     * The maximum number of node connections that will be established to a remote cluster. For instance if there is only a single
-    * seed node, other nodes will be discovered up to the given number of nodes in this setting. The default is 3.
-    */
-    public static final Setting.AffixSetting<Integer> REMOTE_NODE_CONNECTIONS = Setting.affixKeySetting(
-        "cluster.remote.",
-        "node_connections",
-        (ns, key) -> intSetting(
-            key,
-            REMOTE_CONNECTIONS_PER_CLUSTER,
-            1,
-            new StrategyValidator<>(ns, key, ProtobufConnectionStrategy.SNIFF),
-            Setting.Property.Dynamic,
-            Setting.Property.NodeScope
-        )
-    );
-
-    static final int CHANNELS_PER_CONNECTION = 6;
-
-    private static final Predicate<DiscoveryNode> DEFAULT_NODE_PREDICATE = (node) -> Version.CURRENT.isCompatible(node.getVersion())
-        && (node.isClusterManagerNode() == false || node.isDataNode() || node.isIngestNode());
-
-    private final List<String> configuredSeedNodes;
-    private final List<Supplier<DiscoveryNode>> seedNodes;
-    private final int maxNumRemoteConnections;
-    private final Predicate<DiscoveryNode> nodePredicate;
-    private final SetOnce<ClusterName> remoteClusterName = new SetOnce<>();
-    private final String proxyAddress;
-
-    ProtobufSniffConnectionStrategy(
-        String clusterAlias,
-        TransportService transportService,
-        RemoteConnectionManager connectionManager,
-        Settings settings
-    ) {
-        this(
-            clusterAlias,
-            transportService,
-            connectionManager,
-            REMOTE_CLUSTERS_PROXY.getConcreteSettingForNamespace(clusterAlias).get(settings),
-            settings,
-            REMOTE_NODE_CONNECTIONS.getConcreteSettingForNamespace(clusterAlias).get(settings),
-            getNodePredicate(settings),
-            REMOTE_CLUSTER_SEEDS.getConcreteSettingForNamespace(clusterAlias).get(settings)
-        );
-    }
-
-    ProtobufSniffConnectionStrategy(
-        String clusterAlias,
-        TransportService transportService,
-        RemoteConnectionManager connectionManager,
-        String proxyAddress,
-        Settings settings,
-        int maxNumRemoteConnections,
-        Predicate<DiscoveryNode> nodePredicate,
-        List<String> configuredSeedNodes
-    ) {
-        this(
-            clusterAlias,
-            transportService,
-            connectionManager,
-            proxyAddress,
-            settings,
-            maxNumRemoteConnections,
-            nodePredicate,
-            configuredSeedNodes,
-            configuredSeedNodes.stream()
-                .map(seedAddress -> (Supplier<DiscoveryNode>) () -> resolveSeedNode(clusterAlias, seedAddress, proxyAddress))
-                .collect(Collectors.toList())
-        );
-    }
-
-    ProtobufSniffConnectionStrategy(
-        String clusterAlias,
-        TransportService transportService,
-        RemoteConnectionManager connectionManager,
-        String proxyAddress,
-        Settings settings,
-        int maxNumRemoteConnections,
-        Predicate<DiscoveryNode> nodePredicate,
-        List<String> configuredSeedNodes,
-        List<Supplier<DiscoveryNode>> seedNodes
-    ) {
-        super(clusterAlias, transportService, connectionManager, settings);
-        this.proxyAddress = proxyAddress;
-        this.maxNumRemoteConnections = maxNumRemoteConnections;
-        this.nodePredicate = nodePredicate;
-        this.configuredSeedNodes = configuredSeedNodes;
-        this.seedNodes = seedNodes;
-    }
-
-    static Stream<Setting.AffixSetting<?>> enablementSettings() {
-        return Stream.of(ProtobufSniffConnectionStrategy.REMOTE_CLUSTER_SEEDS);
-    }
-
-    static ProtobufWriteable.Reader<ProtobufRemoteConnectionInfo.ModeInfo> infoReader() {
-        return SniffModeInfo::new;
-    }
-
-    @Override
-    protected boolean shouldOpenMoreConnections() {
-        return connectionManager.size() < maxNumRemoteConnections;
-    }
-
-    @Override
-    protected boolean strategyMustBeRebuilt(Settings newSettings) {
-        String proxy = REMOTE_CLUSTERS_PROXY.getConcreteSettingForNamespace(clusterAlias).get(newSettings);
-        List<String> addresses = REMOTE_CLUSTER_SEEDS.getConcreteSettingForNamespace(clusterAlias).get(newSettings);
-        int nodeConnections = REMOTE_NODE_CONNECTIONS.getConcreteSettingForNamespace(clusterAlias).get(newSettings);
-        return nodeConnections != maxNumRemoteConnections
-            || seedsChanged(configuredSeedNodes, addresses)
-            || proxyChanged(proxyAddress, proxy);
-    }
-
-    @Override
-    protected ProtobufConnectionStrategy strategyType() {
-        return ProtobufConnectionStrategy.SNIFF;
-    }
-
-    @Override
-    protected void connectImpl(ActionListener<Void> listener) {
-        collectRemoteNodes(seedNodes.iterator(), listener);
-    }
-
-    @Override
-    protected ProtobufRemoteConnectionInfo.ModeInfo getModeInfo() {
-        return new SniffModeInfo(configuredSeedNodes, maxNumRemoteConnections, connectionManager.size());
-    }
-
-    private void collectRemoteNodes(Iterator<Supplier<DiscoveryNode>> seedNodes, ActionListener<Void> listener) {
-        if (Thread.currentThread().isInterrupted()) {
-            listener.onFailure(new InterruptedException("remote connect thread got interrupted"));
-            return;
-        }
-
-        if (seedNodes.hasNext()) {
-            final Consumer<Exception> onFailure = e -> {
-                if (e instanceof ConnectTransportException || e instanceof IOException || e instanceof IllegalStateException) {
-                    // ISE if we fail the handshake with an version incompatible node
-                    if (seedNodes.hasNext()) {
-                        logger.debug(
-                            () -> new ParameterizedMessage(
-                                "fetching nodes from external cluster [{}] failed moving to next seed node",
-                                clusterAlias
-                            ),
-                            e
-                        );
-                        collectRemoteNodes(seedNodes, listener);
-                        return;
-                    }
-                }
-                logger.warn(new ParameterizedMessage("fetching nodes from external cluster [{}] failed", clusterAlias), e);
-                listener.onFailure(e);
-            };
-
-            final DiscoveryNode seedNode = seedNodes.next().get();
-            logger.trace("[{}] opening transient connection to seed node: [{}]", clusterAlias, seedNode);
-            final StepListener<Transport.Connection> openConnectionStep = new StepListener<>();
-            try {
-                connectionManager.openConnection(seedNode, null, openConnectionStep);
-            } catch (Exception e) {
-                onFailure.accept(e);
-            }
-
-            final StepListener<TransportService.HandshakeResponse> handshakeStep = new StepListener<>();
-            openConnectionStep.whenComplete(connection -> {
-                ConnectionProfile connectionProfile = connectionManager.getConnectionProfile();
-                transportService.handshake(
-                    connection,
-                    connectionProfile.getHandshakeTimeout().millis(),
-                    getRemoteClusterNamePredicate(),
-                    handshakeStep
-                );
-            }, onFailure);
-
-            final StepListener<Void> fullConnectionStep = new StepListener<>();
-            handshakeStep.whenComplete(handshakeResponse -> {
-                final DiscoveryNode handshakeNode = handshakeResponse.getDiscoveryNode();
-
-                if (nodePredicate.test(handshakeNode) && shouldOpenMoreConnections()) {
-                    logger.trace(
-                        "[{}] opening managed connection to seed node: [{}] proxy address: [{}]",
-                        clusterAlias,
-                        handshakeNode,
-                        proxyAddress
-                    );
-                    final DiscoveryNode handshakeNodeWithProxy = maybeAddProxyAddress(proxyAddress, handshakeNode);
-                    connectionManager.connectToNode(
-                        handshakeNodeWithProxy,
-                        null,
-                        transportService.connectionValidator(handshakeNodeWithProxy),
-                        fullConnectionStep
-                    );
-                } else {
-                    fullConnectionStep.onResponse(null);
-                }
-            }, e -> {
-                final Transport.Connection connection = openConnectionStep.result();
-                final DiscoveryNode node = connection.getNode();
-                logger.debug(() -> new ParameterizedMessage("[{}] failed to handshake with seed node: [{}]", clusterAlias, node), e);
-                IOUtils.closeWhileHandlingException(connection);
-                onFailure.accept(e);
-            });
-
-            fullConnectionStep.whenComplete(aVoid -> {
-                if (remoteClusterName.get() == null) {
-                    TransportService.HandshakeResponse handshakeResponse = handshakeStep.result();
-                    assert handshakeResponse.getClusterName().value() != null;
-                    remoteClusterName.set(handshakeResponse.getClusterName());
-                }
-                final Transport.Connection connection = openConnectionStep.result();
-
-                ProtobufClusterStateRequest request = new ProtobufClusterStateRequest();
-                request.clear();
-                request.nodes(true);
-                // here we pass on the connection since we can only close it once the sendRequest returns otherwise
-                // due to the async nature (it will return before it's actually sent) this can cause the request to fail
-                // due to an already closed connection.
-                ThreadPool threadPool = transportService.getThreadPool();
-                ThreadContext threadContext = threadPool.getThreadContext();
-                TransportService.ContextRestoreResponseHandler<ProtobufClusterStateResponse> responseHandler =
-                    new TransportService.ContextRestoreResponseHandler<>(
-                        threadContext.newRestorableContext(false),
-                        new SniffClusterStateResponseHandler(connection, listener, seedNodes)
-                    );
-                try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
-                    // we stash any context here since this is an internal execution and should not leak any
-                    // existing context information.
-                    threadContext.markAsSystemContext();
-                    transportService.sendRequest(
-                        connection,
-                        ClusterStateAction.NAME,
-                        request,
-                        TransportRequestOptions.EMPTY,
-                        responseHandler
-                    );
-                }
-            }, e -> {
-                final Transport.Connection connection = openConnectionStep.result();
-                final DiscoveryNode node = connection.getNode();
-                logger.debug(
-                    () -> new ParameterizedMessage("[{}] failed to open managed connection to seed node: [{}]", clusterAlias, node),
-                    e
-                );
-                IOUtils.closeWhileHandlingException(openConnectionStep.result());
-                onFailure.accept(e);
-            });
-        } else {
-            listener.onFailure(new NoSeedNodeLeftException(clusterAlias));
-        }
-    }
-
-    /* This class handles the _state response from the remote cluster when sniffing nodes to connect to */
-    private class SniffClusterStateResponseHandler implements TransportResponseHandler<ProtobufClusterStateResponse> {
-
-        private final Transport.Connection connection;
-        private final ActionListener<Void> listener;
-        private final Iterator<Supplier<DiscoveryNode>> seedNodes;
-
-        SniffClusterStateResponseHandler(
-            Transport.Connection connection,
-            ActionListener<Void> listener,
-            Iterator<Supplier<DiscoveryNode>> seedNodes
-        ) {
-            this.connection = connection;
-            this.listener = listener;
-            this.seedNodes = seedNodes;
-        }
-
-        @Override
-        public ProtobufClusterStateResponse read(CodedInputStream in) throws IOException {
-            return new ProtobufClusterStateResponse(in);
-        }
-
-        @Override
-        public void handleResponse(ProtobufClusterStateResponse response) {
-            handleNodes(response.getState().nodes().getNodes().valuesIt());
-        }
-
-        private void handleNodes(Iterator<DiscoveryNode> nodesIter) {
-            while (nodesIter.hasNext()) {
-                final DiscoveryNode node = nodesIter.next();
-                if (nodePredicate.test(node) && shouldOpenMoreConnections()) {
-                    logger.trace("[{}] opening managed connection to node: [{}] proxy address: [{}]", clusterAlias, node, proxyAddress);
-                    final DiscoveryNode nodeWithProxy = maybeAddProxyAddress(proxyAddress, node);
-                    connectionManager.connectToNode(
-                        nodeWithProxy,
-                        null,
-                        transportService.connectionValidator(node),
-                        new ActionListener<Void>() {
-                            @Override
-                            public void onResponse(Void aVoid) {
-                                handleNodes(nodesIter);
-                            }
-
-                            @Override
-                            public void onFailure(Exception e) {
-                                if (e instanceof ConnectTransportException || e instanceof IllegalStateException) {
-                                    // ISE if we fail the handshake with an version incompatible node
-                                    // fair enough we can't connect just move on
-                                    logger.debug(
-                                        () -> new ParameterizedMessage(
-                                            "[{}] failed to open managed connection to node [{}]",
-                                            clusterAlias,
-                                            node
-                                        ),
-                                        e
-                                    );
-                                    handleNodes(nodesIter);
-                                } else {
-                                    logger.warn(
-                                        new ParameterizedMessage("[{}] failed to open managed connection to node [{}]", clusterAlias, node),
-                                        e
-                                    );
-                                    IOUtils.closeWhileHandlingException(connection);
-                                    collectRemoteNodes(seedNodes, listener);
-                                }
-                            }
-                        }
-                    );
-                    return;
-                }
-            }
-            // We have to close this connection before we notify listeners - this is mainly needed for test correctness
-            // since if we do it afterwards we might fail assertions that check if all high level connections are closed.
-            // from a code correctness perspective we could also close it afterwards.
-            IOUtils.closeWhileHandlingException(connection);
-            int openConnections = connectionManager.size();
-            if (openConnections == 0) {
-                listener.onFailure(new IllegalStateException("Unable to open any connections to remote cluster [" + clusterAlias + "]"));
-            } else {
-                listener.onResponse(null);
-            }
-        }
-
-        @Override
-        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-            logger.warn(new ParameterizedMessage("fetching nodes from external cluster {} failed", clusterAlias), exp);
-            try {
-                IOUtils.closeWhileHandlingException(connection);
-            } finally {
-                // once the connection is closed lets try the next node
-                collectRemoteNodes(seedNodes, listener);
-            }
-        }
-
-        @Override
-        public String executor() {
-            return ThreadPool.Names.MANAGEMENT;
-        }
-
-        @Override
-        public ProtobufClusterStateResponse read(StreamInput in) throws IOException {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'read'");
-        }
-
-        @Override
-        public void handleException(TransportException exp) {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'handleException'");
-        }
-
-        @Override
-        public ProtobufClusterStateResponse read(byte[] in) throws IOException {
-            return new ProtobufClusterStateResponse(in);
-        }
-    }
-
-    private Predicate<ClusterName> getRemoteClusterNamePredicate() {
-        return new Predicate<ClusterName>() {
-            @Override
-            public boolean test(ClusterName c) {
-                return remoteClusterName.get() == null || c.equals(remoteClusterName.get());
-            }
-
-            @Override
-            public String toString() {
-                return remoteClusterName.get() == null
-                    ? "any cluster name"
-                    : "expected remote cluster name [" + remoteClusterName.get().value() + "]";
-            }
-        };
-    }
-
-    private static DiscoveryNode resolveSeedNode(String clusterAlias, String address, String proxyAddress) {
-        if (proxyAddress == null || proxyAddress.isEmpty()) {
-            TransportAddress transportAddress = new TransportAddress(parseConfiguredAddress(address));
-            return new DiscoveryNode(
-                clusterAlias + "#" + transportAddress.toString(),
-                transportAddress,
-                Version.CURRENT.minimumCompatibilityVersion()
-            );
-        } else {
-            TransportAddress transportAddress = new TransportAddress(parseConfiguredAddress(proxyAddress));
-            String hostName = ProtobufRemoteConnectionStrategy.parseHost(proxyAddress);
-            return new DiscoveryNode(
-                "",
-                clusterAlias + "#" + address,
-                UUIDs.randomBase64UUID(),
-                hostName,
-                address,
-                transportAddress,
-                Collections.singletonMap("server_name", hostName),
-                DiscoveryNodeRole.BUILT_IN_ROLES,
-                Version.CURRENT.minimumCompatibilityVersion()
-            );
-        }
-    }
-
-    // Default visibility for tests
-    static Predicate<DiscoveryNode> getNodePredicate(Settings settings) {
-        if (RemoteClusterService.REMOTE_NODE_ATTRIBUTE.exists(settings)) {
-            // nodes can be tagged with node.attr.remote_gateway: true to allow a node to be a gateway node for cross cluster search
-            String attribute = RemoteClusterService.REMOTE_NODE_ATTRIBUTE.get(settings);
-            return DEFAULT_NODE_PREDICATE.and((node) -> Booleans.parseBoolean(node.getAttributes().getOrDefault(attribute, "false")));
-        }
-        return DEFAULT_NODE_PREDICATE;
-    }
-
-    private static DiscoveryNode maybeAddProxyAddress(String proxyAddress, DiscoveryNode node) {
-        if (proxyAddress == null || proxyAddress.isEmpty()) {
-            return node;
-        } else {
-            // resolve proxy address lazy here
-            InetSocketAddress proxyInetAddress = parseConfiguredAddress(proxyAddress);
-            return new DiscoveryNode(
-                node.getName(),
-                node.getId(),
-                node.getEphemeralId(),
-                node.getHostName(),
-                node.getHostAddress(),
-                new TransportAddress(proxyInetAddress),
-                node.getAttributes(),
-                node.getRoles(),
-                node.getVersion()
-            );
-        }
-    }
-
-    private boolean seedsChanged(final List<String> oldSeedNodes, final List<String> newSeedNodes) {
-        if (oldSeedNodes.size() != newSeedNodes.size()) {
-            return true;
-        }
-        Set<String> oldSeeds = new HashSet<>(oldSeedNodes);
-        Set<String> newSeeds = new HashSet<>(newSeedNodes);
-        return oldSeeds.equals(newSeeds) == false;
-    }
-
-    private boolean proxyChanged(String oldProxy, String newProxy) {
-        if (oldProxy == null || oldProxy.isEmpty()) {
-            return (newProxy == null || newProxy.isEmpty()) == false;
-        }
-
-        return Objects.equals(oldProxy, newProxy) == false;
-    }
-
-    /**
-     * Information about the sniff mode
-    *
-    * @opensearch.internal
-    */
-    public static class SniffModeInfo implements ProtobufRemoteConnectionInfo.ModeInfo {
-
-        final List<String> seedNodes;
-        final int maxConnectionsPerCluster;
-        final int numNodesConnected;
-
-        public SniffModeInfo(List<String> seedNodes, int maxConnectionsPerCluster, int numNodesConnected) {
-            this.seedNodes = seedNodes;
-            this.maxConnectionsPerCluster = maxConnectionsPerCluster;
-            this.numNodesConnected = numNodesConnected;
-        }
-
-        private SniffModeInfo(CodedInputStream input) throws IOException {
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(input);
-            seedNodes = Arrays.asList(protobufStreamInput.readStringArray());
-            maxConnectionsPerCluster = protobufStreamInput.readVInt();
-            numNodesConnected = protobufStreamInput.readVInt();
-        }
-
-        @Override
-        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-            builder.startArray("seeds");
-            for (String address : seedNodes) {
-                builder.value(address);
-            }
-            builder.endArray();
-            builder.field("num_nodes_connected", numNodesConnected);
-            builder.field("max_connections_per_cluster", maxConnectionsPerCluster);
-            return builder;
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            protobufStreamOutput.writeStringArray(seedNodes.toArray(new String[0]));
-            out.writeInt32NoTag(maxConnectionsPerCluster);
-            out.writeInt32NoTag(numNodesConnected);
-        }
-
-        @Override
-        public boolean isConnected() {
-            return numNodesConnected > 0;
-        }
-
-        @Override
-        public String modeName() {
-            return "sniff";
-        }
-
-        public List<String> getSeedNodes() {
-            return seedNodes;
-        }
-
-        public int getMaxConnectionsPerCluster() {
-            return maxConnectionsPerCluster;
-        }
-
-        public int getNumNodesConnected() {
-            return numNodesConnected;
-        }
-
-        @Override
-        public ProtobufRemoteConnectionStrategy.ProtobufConnectionStrategy modeType() {
-            return ProtobufRemoteConnectionStrategy.ProtobufConnectionStrategy.SNIFF;
-        }
-
-        @Override
-        public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
-            SniffModeInfo sniff = (SniffModeInfo) o;
-            return maxConnectionsPerCluster == sniff.maxConnectionsPerCluster
-                && numNodesConnected == sniff.numNodesConnected
-                && Objects.equals(seedNodes, sniff.seedNodes);
-        }
-
-        @Override
-        public int hashCode() {
-            return Objects.hash(seedNodes, maxConnectionsPerCluster, numNodesConnected);
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java
deleted file mode 100644
index 297b8ba70fa01..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportActionProxy.java
+++ /dev/null
@@ -1,246 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.io.stream.StreamInput;
-import org.opensearch.common.io.stream.TryWriteable;
-import org.opensearch.tasks.ProtobufTask;
-import org.opensearch.threadpool.ThreadPool;
-
-import java.io.IOException;
-import java.io.UncheckedIOException;
-import java.util.function.Function;
-
-/**
- * ProtobufTransportActionProxy allows an arbitrary action to be executed on a defined target node while the initial request is sent to a second
-* node that acts as a request proxy to the target node. This is useful if a node is not directly connected to a target node but is
-* connected to an intermediate node that establishes a transitive connection.
-*
-* @opensearch.internal
-*/
-public final class ProtobufTransportActionProxy {
-
-    private ProtobufTransportActionProxy() {} // no instance
-
-    /**
-     * Handler for proxy requests
-    *
-    * @opensearch.internal
-    */
-    private static class ProxyRequestHandler<T extends ProxyRequest> implements ProtobufTransportRequestHandler<T> {
-
-        private final TransportService service;
-        private final String action;
-        private final Function<TransportRequest, TryWriteable.Reader<? extends TransportResponse>> responseFunction;
-
-        ProxyRequestHandler(
-            TransportService service,
-            String action,
-            Function<TransportRequest, TryWriteable.Reader<? extends TransportResponse>> responseFunction
-        ) {
-            this.service = service;
-            this.action = action;
-            this.responseFunction = responseFunction;
-        }
-
-        @Override
-        public void messageReceived(T request, TransportChannel channel, ProtobufTask task) throws Exception {
-            DiscoveryNode targetNode = request.targetNode;
-            TransportRequest wrappedRequest = request.wrapped;
-            service.sendRequest(
-                targetNode,
-                action,
-                wrappedRequest,
-                new ProxyResponseHandler<>(channel, responseFunction.apply(wrappedRequest))
-            );
-        }
-    }
-
-    /**
-     * Handler for the proxy response
-    *
-    * @opensearch.internal
-    */
-    private static class ProxyResponseHandler<T extends TransportResponse> implements TransportResponseHandler<T> {
-
-        private final TryWriteable.Reader<T> reader;
-        private final TransportChannel channel;
-
-        ProxyResponseHandler(TransportChannel channel, TryWriteable.Reader<T> reader) {
-            this.reader = reader;
-            this.channel = channel;
-        }
-
-        @Override
-        public T read(CodedInputStream in) throws IOException {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'read'");
-        }
-
-        @Override
-        public void handleResponse(T response) {
-            try {
-                channel.sendResponse(response);
-            } catch (IOException e) {
-                throw new UncheckedIOException(e);
-            }
-        }
-
-        @Override
-        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-            try {
-                channel.sendResponse(exp);
-            } catch (IOException e) {
-                throw new UncheckedIOException(e);
-            }
-        }
-
-        @Override
-        public String executor() {
-            return ThreadPool.Names.SAME;
-        }
-
-        @Override
-        public T read(StreamInput in) throws IOException {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'read'");
-        }
-
-        @Override
-        public void handleException(TransportException exp) {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'handleException'");
-        }
-
-        @Override
-        public T read(byte[] in) throws IOException {
-            return reader.read(in);
-        }
-    }
-
-    /**
-     * The proxy request
-    *
-    * @opensearch.internal
-    */
-    static class ProxyRequest<T extends TransportRequest> extends TransportRequest {
-        final T wrapped;
-        final DiscoveryNode targetNode;
-
-        ProxyRequest(T wrapped, DiscoveryNode targetNode) {
-            this.wrapped = wrapped;
-            this.targetNode = targetNode;
-        }
-
-        ProxyRequest(CodedInputStream in, ProtobufWriteable.Reader<T> reader) throws IOException {
-            super(in);
-            targetNode = new DiscoveryNode(in);
-            wrapped = reader.read(in);
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            super.writeTo(out);
-            targetNode.writeTo(out);
-            wrapped.writeTo(out);
-        }
-    }
-
-    /**
-     * Registers a proxy request handler that allows to forward requests for the given action to another node. To be used when the
-    * response type changes based on the upcoming request (quite rare)
-    */
-    public static void registerProxyActionWithDynamicResponseType(
-        TransportService service,
-        String action,
-        Function<TransportRequest, TryWriteable.Reader<? extends TransportResponse>> responseFunction
-    ) {
-        ProtobufRequestHandlerRegistry<? extends TransportRequest> requestHandler = service.getRequestHandlerProtobuf(action);
-        service.registerRequestHandlerProtobuf(
-            getProxyAction(action),
-            ThreadPool.Names.SAME,
-            true,
-            false,
-            in -> new ProxyRequest<>(in, requestHandler::newRequest),
-            new ProxyRequestHandler<>(service, action, responseFunction)
-        );
-    }
-
-    /**
-     * Registers a proxy request handler that allows to forward requests for the given action to another node. To be used when the
-    * response type is always the same (most of the cases).
-    */
-    public static void registerProxyAction(
-        TransportService service,
-        String action,
-        TryWriteable.Reader<? extends TransportResponse> reader
-    ) {
-        ProtobufRequestHandlerRegistry<? extends TransportRequest> requestHandler = service.getRequestHandlerProtobuf(action);
-        service.registerRequestHandlerProtobuf(
-            getProxyAction(action),
-            ThreadPool.Names.SAME,
-            true,
-            false,
-            in -> new ProxyRequest<>(in, requestHandler::newRequest),
-            new ProxyRequestHandler<>(service, action, request -> reader)
-        );
-    }
-
-    private static final String PROXY_ACTION_PREFIX = "internal:transport/proxy/";
-
-    /**
-     * Returns the corresponding proxy action for the given action
-    */
-    public static String getProxyAction(String action) {
-        return PROXY_ACTION_PREFIX + action;
-    }
-
-    /**
-     * Wraps the actual request in a proxy request object that encodes the target node.
-    */
-    public static TransportRequest wrapRequest(DiscoveryNode node, TransportRequest request) {
-        return new ProxyRequest<>(request, node);
-    }
-
-    /**
-     * Unwraps a proxy request and returns the original request
-    */
-    public static TransportRequest unwrapRequest(TransportRequest request) {
-        if (request instanceof ProxyRequest) {
-            return ((ProxyRequest) request).wrapped;
-        }
-        return request;
-    }
-
-    /**
-     * Unwraps a proxy action and returns the underlying action
-    */
-    public static String unwrapAction(String action) {
-        assert isProxyAction(action) : "Attempted to unwrap non-proxy action: " + action;
-        return action.substring(PROXY_ACTION_PREFIX.length());
-    }
-
-    /**
-     * Returns <code>true</code> iff the given action is a proxy action
-    */
-    public static boolean isProxyAction(String action) {
-        return action.startsWith(PROXY_ACTION_PREFIX);
-    }
-
-    /**
-     * Returns <code>true</code> iff the given request is a proxy request
-    */
-    public static boolean isProxyRequest(TransportRequest request) {
-        return request instanceof ProxyRequest;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportException.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportException.java
deleted file mode 100644
index 42bca65d8c1fd..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportException.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import org.opensearch.ProtobufOpenSearchException;
-
-import java.io.IOException;
-
-/**
- * Thrown for any transport errors
-*
-* @opensearch.internal
-*/
-public class ProtobufTransportException extends ProtobufOpenSearchException {
-    public ProtobufTransportException(Throwable cause) {
-        super(cause);
-    }
-
-    public ProtobufTransportException(CodedInputStream in) throws IOException {
-        super(in);
-    }
-
-    public ProtobufTransportException(String msg) {
-        super(msg);
-    }
-
-    public ProtobufTransportException(String msg, Throwable cause) {
-        super(msg, cause);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportInfo.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportInfo.java
deleted file mode 100644
index b7dcf9ab402a3..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportInfo.java
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
-* 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.
-*/
-
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.Nullable;
-import org.opensearch.common.logging.DeprecationLogger;
-import org.opensearch.common.network.InetAddresses;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.node.ProtobufReportingService;
-
-import java.io.IOException;
-import java.util.HashMap;
-import java.util.Map;
-
-import static org.opensearch.common.Booleans.parseBoolean;
-
-/**
- * Transport information
-*
-* @opensearch.internal
-*/
-public class ProtobufTransportInfo implements ProtobufReportingService.ProtobufInfo {
-
-    private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(TransportInfo.class);
-
-    /** Whether to add hostname to publish host field when serializing. */
-    private static final boolean CNAME_IN_PUBLISH_ADDRESS = parseBoolean(
-        System.getProperty("opensearch.transport.cname_in_publish_address"),
-        false
-    );
-
-    private final BoundTransportAddress address;
-    private Map<String, BoundTransportAddress> profileAddresses;
-    private final boolean cnameInPublishAddress;
-
-    public ProtobufTransportInfo(
-        BoundTransportAddress address,
-        @Nullable Map<String, BoundTransportAddress> profileAddresses
-    ) {
-        this(address, profileAddresses, CNAME_IN_PUBLISH_ADDRESS);
-    }
-
-    public ProtobufTransportInfo(
-        BoundTransportAddress address,
-        @Nullable Map<String, BoundTransportAddress> profileAddresses,
-        boolean cnameInPublishAddress
-    ) {
-        this.address = address;
-        this.profileAddresses = profileAddresses;
-        this.cnameInPublishAddress = cnameInPublishAddress;
-    }
-
-    public ProtobufTransportInfo(CodedInputStream in) throws IOException {
-        address = new BoundTransportAddress(in);
-        int size = in.readInt32();
-        if (size > 0) {
-            profileAddresses = new HashMap<>(size);
-            for (int i = 0; i < size; i++) {
-                String key = in.readString();
-                BoundTransportAddress value = new BoundTransportAddress(in);
-                profileAddresses.put(key, value);
-            }
-        }
-        this.cnameInPublishAddress = CNAME_IN_PUBLISH_ADDRESS;
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        address.writeTo(out);
-        if (profileAddresses != null) {
-            out.writeInt32NoTag(profileAddresses.size());
-        } else {
-            out.writeInt32NoTag(0);
-        }
-        if (profileAddresses != null && profileAddresses.size() > 0) {
-            for (Map.Entry<String, BoundTransportAddress> entry : profileAddresses.entrySet()) {
-                out.writeStringNoTag(entry.getKey());
-                entry.getValue().writeTo(out);
-            }
-        }
-    }
-
-    static final class Fields {
-        static final String TRANSPORT = "transport";
-        static final String BOUND_ADDRESS = "bound_address";
-        static final String PUBLISH_ADDRESS = "publish_address";
-        static final String PROFILES = "profiles";
-    }
-
-    private String formatPublishAddressString(String propertyName, TransportAddress publishAddress) {
-        String publishAddressString = publishAddress.toString();
-        String hostString = publishAddress.address().getHostString();
-        if (InetAddresses.isInetAddress(hostString) == false) {
-            if (cnameInPublishAddress) {
-                publishAddressString = hostString + '/' + publishAddress.toString();
-            } else {
-                deprecationLogger.deprecate(
-                    "cname_in_publish_address_" + propertyName,
-                    propertyName
-                        + " was printed as [ip:port] instead of [hostname/ip:port]. "
-                        + "This format is deprecated and will change to [hostname/ip:port] in a future version. "
-                        + "Use -Dopensearch.transport.cname_in_publish_address=true to enforce non-deprecated formatting."
-                );
-            }
-        }
-        return publishAddressString;
-    }
-
-    public BoundTransportAddress address() {
-        return address;
-    }
-
-    public BoundTransportAddress getAddress() {
-        return address();
-    }
-
-    public Map<String, BoundTransportAddress> getProfileAddresses() {
-        return profileAddresses();
-    }
-
-    public Map<String, BoundTransportAddress> profileAddresses() {
-        return profileAddresses;
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.TRANSPORT);
-        builder.array(Fields.BOUND_ADDRESS, (Object[]) address.boundAddresses());
-        builder.field(Fields.PUBLISH_ADDRESS, formatPublishAddressString("transport.publish_address", address.publishAddress()));
-        builder.startObject(Fields.PROFILES);
-        if (profileAddresses != null && profileAddresses.size() > 0) {
-            for (Map.Entry<String, BoundTransportAddress> entry : profileAddresses.entrySet()) {
-                builder.startObject(entry.getKey());
-                builder.array(Fields.BOUND_ADDRESS, (Object[]) entry.getValue().boundAddresses());
-                String propertyName = "transport." + entry.getKey() + ".publish_address";
-                builder.field(Fields.PUBLISH_ADDRESS, formatPublishAddressString(propertyName, entry.getValue().publishAddress()));
-                builder.endObject();
-            }
-        }
-        builder.endObject();
-        builder.endObject();
-        return builder;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufTransportStats.java b/server/src/main/java/org/opensearch/transport/ProtobufTransportStats.java
deleted file mode 100644
index 963bf4665af8b..0000000000000
--- a/server/src/main/java/org/opensearch/transport/ProtobufTransportStats.java
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.transport;
-
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.unit.ByteSizeValue;
-import org.opensearch.core.xcontent.ToXContentFragment;
-import org.opensearch.core.xcontent.XContentBuilder;
-
-import java.io.IOException;
-
-/**
- * Stats for transport activity
-*
-* @opensearch.internal
-*/
-public class ProtobufTransportStats implements ProtobufWriteable, ToXContentFragment {
-
-    private final long serverOpen;
-    private final long totalOutboundConnections;
-    private final long rxCount;
-    private final long rxSize;
-    private final long txCount;
-    private final long txSize;
-
-    public ProtobufTransportStats(long serverOpen, long totalOutboundConnections, long rxCount, long rxSize, long txCount, long txSize) {
-        this.serverOpen = serverOpen;
-        this.totalOutboundConnections = totalOutboundConnections;
-        this.rxCount = rxCount;
-        this.rxSize = rxSize;
-        this.txCount = txCount;
-        this.txSize = txSize;
-    }
-
-    public ProtobufTransportStats(CodedInputStream in) throws IOException {
-        serverOpen = in.readInt64();
-        totalOutboundConnections = in.readInt64();
-        rxCount = in.readInt64();
-        rxSize = in.readInt64();
-        txCount = in.readInt64();
-        txSize = in.readInt64();
-    }
-
-    @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
-        out.writeInt64NoTag(serverOpen);
-        out.writeInt64NoTag(totalOutboundConnections);
-        out.writeInt64NoTag(rxCount);
-        out.writeInt64NoTag(rxSize);
-        out.writeInt64NoTag(txCount);
-        out.writeInt64NoTag(txSize);
-    }
-
-    public long serverOpen() {
-        return this.serverOpen;
-    }
-
-    public long getServerOpen() {
-        return serverOpen();
-    }
-
-    public long rxCount() {
-        return rxCount;
-    }
-
-    public long getRxCount() {
-        return rxCount();
-    }
-
-    public ByteSizeValue rxSize() {
-        return new ByteSizeValue(rxSize);
-    }
-
-    public ByteSizeValue getRxSize() {
-        return rxSize();
-    }
-
-    public long txCount() {
-        return txCount;
-    }
-
-    public long getTxCount() {
-        return txCount();
-    }
-
-    public ByteSizeValue txSize() {
-        return new ByteSizeValue(txSize);
-    }
-
-    public ByteSizeValue getTxSize() {
-        return txSize();
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(Fields.TRANSPORT);
-        builder.field(Fields.SERVER_OPEN, serverOpen);
-        builder.field(Fields.TOTAL_OUTBOUND_CONNECTIONS, totalOutboundConnections);
-        builder.field(Fields.RX_COUNT, rxCount);
-        builder.humanReadableField(Fields.RX_SIZE_IN_BYTES, Fields.RX_SIZE, new ByteSizeValue(rxSize));
-        builder.field(Fields.TX_COUNT, txCount);
-        builder.humanReadableField(Fields.TX_SIZE_IN_BYTES, Fields.TX_SIZE, new ByteSizeValue(txSize));
-        builder.endObject();
-        return builder;
-    }
-
-    static final class Fields {
-        static final String TRANSPORT = "transport";
-        static final String SERVER_OPEN = "server_open";
-        static final String TOTAL_OUTBOUND_CONNECTIONS = "total_outbound_connections";
-        static final String RX_COUNT = "rx_count";
-        static final String RX_SIZE = "rx_size";
-        static final String RX_SIZE_IN_BYTES = "rx_size_in_bytes";
-        static final String TX_COUNT = "tx_count";
-        static final String TX_SIZE = "tx_size";
-        static final String TX_SIZE_IN_BYTES = "tx_size_in_bytes";
-    }
-}
diff --git a/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java b/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java
index 66961c2490f3a..a694ebc186b7d 100644
--- a/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java
+++ b/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java
@@ -173,18 +173,6 @@ public String executor() {
                             return ThreadPool.Names.SAME;
                         }
 
-                        @Override
-                        public ClusterStateResponse read(CodedInputStream in) throws IOException {
-                            // TODO Auto-generated method stub
-                            throw new UnsupportedOperationException("Unimplemented method 'read'");
-                        }
-
-                        @Override
-                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                            // TODO Auto-generated method stub
-                            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                        }
-
                         @Override
                         public ClusterStateResponse read(byte[] in) throws IOException {
                             // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/transport/RemoteClusterService.java b/server/src/main/java/org/opensearch/transport/RemoteClusterService.java
index 598fb932f93e4..6385a9cec2a6e 100644
--- a/server/src/main/java/org/opensearch/transport/RemoteClusterService.java
+++ b/server/src/main/java/org/opensearch/transport/RemoteClusterService.java
@@ -39,10 +39,8 @@
 import org.opensearch.action.support.GroupedActionListener;
 import org.opensearch.action.support.IndicesOptions;
 import org.opensearch.client.Client;
-import org.opensearch.client.ProtobufClient;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
-import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.Strings;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
@@ -153,7 +151,6 @@ public boolean isEnabled() {
     private final Map<String, RemoteClusterConnection> remoteClusters = ConcurrentCollections.newConcurrentMap();
 
     private final TransportService TransportService;
-    private final Map<String, ProtobufRemoteClusterConnection> remoteClustersProtobuf = ConcurrentCollections.newConcurrentMap();
 
     RemoteClusterService(Settings settings, TransportService transportService) {
         super(settings);
@@ -162,13 +159,6 @@ public boolean isEnabled() {
         this.TransportService = null;
     }
 
-    // RemoteClusterService(Settings settings, TransportService transportService) {
-    //     super(settings);
-    //     this.enabled = DiscoveryNode.isRemoteClusterClient(settings);
-    //     this.TransportService = transportService;
-    //     this.transportService = null;
-    // }
-
     /**
      * Returns <code>true</code> if at least one remote cluster is configured
      */
@@ -176,20 +166,13 @@ public boolean isCrossClusterSearchEnabled() {
         return remoteClusters.isEmpty() == false;
     }
 
-    /**
-     * Returns <code>true</code> if at least one remote cluster is configured
-     */
-    public boolean isCrossClusterSearchEnabledProtobuf() {
-        return remoteClustersProtobuf.isEmpty() == false;
-    }
-
     boolean isRemoteNodeConnected(final String remoteCluster, final DiscoveryNode node) {
         return remoteClusters.get(remoteCluster).isNodeConnected(node);
     }
 
     public Map<String, OriginalIndices> groupIndices(IndicesOptions indicesOptions, String[] indices, Predicate<String> indexExists) {
         Map<String, OriginalIndices> originalIndicesMap = new HashMap<>();
-        if (isCrossClusterSearchEnabled() || isCrossClusterSearchEnabledProtobuf()) {
+        if (isCrossClusterSearchEnabled()) {
             final Map<String, List<String>> groupedIndices = groupClusterIndices(getRemoteClusterNames(), indices, indexExists);
             if (groupedIndices.isEmpty()) {
                 // search on _all in the local cluster if neither local indices nor remote indices were specified
@@ -231,15 +214,6 @@ public Transport.Connection getConnection(DiscoveryNode node, String cluster) {
         return getRemoteClusterConnection(cluster).getConnection(node);
     }
 
-    // /**
-    //  * Returns a connection to the given node on the given remote cluster
-    //  *
-    //  * @throws IllegalArgumentException if the remote cluster is unknown
-    //  */
-    // public Transport.ProtobufConnection getConnectionProtobuf(DiscoveryNode node, String cluster) {
-    //     return getRemoteClusterConnectionProtobuf(cluster).getConnection(node);
-    // }
-
     /**
      * Ensures that the given cluster alias is connected. If the cluster is connected this operation
      * will invoke the listener immediately.
@@ -259,10 +233,6 @@ public Transport.Connection getConnection(String cluster) {
         return getRemoteClusterConnection(cluster).getConnection();
     }
 
-    // public Transport.ProtobufConnection getConnectionProtobuf(String cluster) {
-    //     return getRemoteClusterConnectionProtobuf(cluster).getConnection();
-    // }
-
     RemoteClusterConnection getRemoteClusterConnection(String cluster) {
         if (enabled == false) {
             throw new IllegalArgumentException(
@@ -276,19 +246,6 @@ RemoteClusterConnection getRemoteClusterConnection(String cluster) {
         return connection;
     }
 
-    ProtobufRemoteClusterConnection getRemoteClusterConnectionProtobuf(String cluster) {
-        if (enabled == false) {
-            throw new IllegalArgumentException(
-                "this node does not have the " + DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName() + " role"
-            );
-        }
-        ProtobufRemoteClusterConnection connection = remoteClustersProtobuf.get(cluster);
-        if (connection == null) {
-            throw new NoSuchRemoteClusterException(cluster);
-        }
-        return connection;
-    }
-
     Set<String> getRemoteClusterNames() {
         return this.remoteClusters.keySet();
     }
@@ -464,25 +421,6 @@ public Client getRemoteClusterClient(ThreadPool threadPool, String clusterAlias)
         return new RemoteClusterAwareClient(settings, threadPool, transportService, clusterAlias);
     }
 
-    /**
-     * Returns a client to the remote cluster if the given cluster alias exists.
-    *
-    * @param threadPool   the {@link ThreadPool} for the client
-    * @param clusterAlias the cluster alias the remote cluster is registered under
-    * @throws IllegalArgumentException if the given clusterAlias doesn't exist
-    */
-    public ProtobufClient getRemoteClusterClientProtobuf(ThreadPool threadPool, String clusterAlias) {
-        if (TransportService.getRemoteClusterService().isEnabled() == false) {
-            throw new IllegalArgumentException(
-                "this node does not have the " + DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName() + " role"
-            );
-        }
-        if (TransportService.getRemoteClusterService().getRemoteClusterNames().contains(clusterAlias) == false) {
-            throw new NoSuchRemoteClusterException(clusterAlias);
-        }
-        return new ProtobufRemoteClusterAwareClient(settings, threadPool, TransportService, clusterAlias);
-    }
-
     Collection<RemoteClusterConnection> getConnections() {
         return remoteClusters.values();
     }
diff --git a/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java
index bf2b97aebba29..05783f7d7b23d 100644
--- a/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java
+++ b/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java
@@ -474,18 +474,6 @@ public String executor() {
             return ThreadPool.Names.MANAGEMENT;
         }
 
-        @Override
-        public ClusterStateResponse read(CodedInputStream in) throws IOException {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'read'");
-        }
-
-        @Override
-        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-        }
-
         @Override
         public ClusterStateResponse read(byte[] in) throws IOException {
             // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/transport/TcpTransport.java b/server/src/main/java/org/opensearch/transport/TcpTransport.java
index 97ddede0105ae..ae81e6a708ca1 100644
--- a/server/src/main/java/org/opensearch/transport/TcpTransport.java
+++ b/server/src/main/java/org/opensearch/transport/TcpTransport.java
@@ -1081,35 +1081,6 @@ public final RequestHandlers getRequestHandlers() {
         return requestHandlers;
     }
 
-    // @Override
-    // public void setMessageListenerProtobuf(ProtobufTransportMessageListener listener) {
-    //     outboundHandler.setProtobufMessageListener(listener);
-    //     inboundHandler.setProtobufMessageListener(listener);
-    // }
-
-    // @Override
-    // public TransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException {
-    //     // TODO Auto-generated method stub
-    //     throw new UnsupportedOperationException("Unimplemented method 'addressesFromStringProtobuf'");
-    // }
-
-    // @Override
-    // public void openProtobufConnection(DiscoveryNode node, ProtobufConnectionProfile profile, ActionListener<Connection> listener) {
-    //     // TODO Auto-generated method stub
-    //     throw new UnsupportedOperationException("Unimplemented method 'openProtobufConnection'");
-    // }
-
-    @Override
-    public ProtobufTransportStats getProtobufStats() {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'getProtobufStats'");
-    }
-
-    // @Override
-    // public ProtobufResponseHandlers getProtobufResponseHandlers() {
-    //     return protobufResponseHandlers;
-    // }
-
     @Override
     public ProtobufRequestHandlers getProtobufRequestHandlers() {
         return protobufRequestHandlers;
diff --git a/server/src/main/java/org/opensearch/transport/Transport.java b/server/src/main/java/org/opensearch/transport/Transport.java
index eb8d8a7b4e40c..40b5e35dab80e 100644
--- a/server/src/main/java/org/opensearch/transport/Transport.java
+++ b/server/src/main/java/org/opensearch/transport/Transport.java
@@ -35,12 +35,9 @@
 import org.opensearch.Version;
 import org.opensearch.action.ActionListener;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.collect.MapBuilder;
 import org.opensearch.common.lifecycle.LifecycleComponent;
 import org.opensearch.common.transport.BoundTransportAddress;
-// import org.opensearch.common.transport.ProtobufBoundTransportAddress;
-// import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.ConcurrentCollections;
@@ -103,22 +100,6 @@ default boolean isSecure() {
      */
     TransportAddress[] addressesFromString(String address) throws UnknownHostException;
 
-    // /**
-    //  * The address the transport is bound on.
-    // */
-    // ProtobufBoundTransportAddress boundProtobufAddress();
-
-    // /**
-    //  * Further profile bound addresses
-    // * @return <code>null</code> iff profiles are unsupported, otherwise a map with name of profile and its bound transport address
-    // */
-    // Map<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses();
-
-    // /**
-    //  * Returns an address from its string representation.
-    // */
-    // ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException;
-
     /**
      * Returns a list of all local addresses for this transport
      */
@@ -130,26 +111,12 @@ default boolean isSecure() {
      */
     void openConnection(DiscoveryNode node, ConnectionProfile profile, ActionListener<Transport.Connection> listener);
 
-    // /**
-    //  * Opens a new connection to the given node. When the connection is fully connected, the listener is called.
-    //  * The ActionListener will be called on the calling thread or the generic thread pool.
-    //  */
-    // void openProtobufConnection(
-    //     DiscoveryNode node,
-    //     ProtobufConnectionProfile profile,
-    //     ActionListener<Transport.Connection> listener
-    // );
-
     TransportStats getStats();
 
     ResponseHandlers getResponseHandlers();
 
     RequestHandlers getRequestHandlers();
 
-    ProtobufTransportStats getProtobufStats();
-
-    // ProtobufResponseHandlers getProtobufResponseHandlers();
-
     ProtobufRequestHandlers getProtobufRequestHandlers();
 
     /**
diff --git a/server/src/main/java/org/opensearch/transport/TransportActionProxy.java b/server/src/main/java/org/opensearch/transport/TransportActionProxy.java
index 126d090db2636..295fab1cf3554 100644
--- a/server/src/main/java/org/opensearch/transport/TransportActionProxy.java
+++ b/server/src/main/java/org/opensearch/transport/TransportActionProxy.java
@@ -132,18 +132,6 @@ public String executor() {
             return ThreadPool.Names.SAME;
         }
 
-        @Override
-        public T read(CodedInputStream in) throws IOException {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'read'");
-        }
-
-        @Override
-        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-        }
-
         @Override
         public T read(byte[] in) throws IOException {
             // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/transport/TransportHandshaker.java b/server/src/main/java/org/opensearch/transport/TransportHandshaker.java
index 750cc4a4e19de..71eef9b00b1d8 100644
--- a/server/src/main/java/org/opensearch/transport/TransportHandshaker.java
+++ b/server/src/main/java/org/opensearch/transport/TransportHandshaker.java
@@ -189,18 +189,6 @@ public String executor() {
             return ThreadPool.Names.SAME;
         }
 
-        @Override
-        public HandshakeResponse read(CodedInputStream in) throws IOException {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'read'");
-        }
-
-        @Override
-        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-        }
-
         @Override
         public HandshakeResponse read(byte[] in) throws IOException {
             // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/transport/TransportMessage.java b/server/src/main/java/org/opensearch/transport/TransportMessage.java
index e368fd99b1056..6698bc7c31c47 100644
--- a/server/src/main/java/org/opensearch/transport/TransportMessage.java
+++ b/server/src/main/java/org/opensearch/transport/TransportMessage.java
@@ -71,5 +71,5 @@ public TransportMessage(StreamInput in) {}
      * Constructs a new transport message with the data from the {@link CodedInputStream}. This is
     * currently a no-op
     */
-    public TransportMessage(CodedInputStream in) {}
+    public TransportMessage(byte[] in) {}
 }
diff --git a/server/src/main/java/org/opensearch/transport/TransportRequest.java b/server/src/main/java/org/opensearch/transport/TransportRequest.java
index 3194d7da970ea..940bbc7006b14 100644
--- a/server/src/main/java/org/opensearch/transport/TransportRequest.java
+++ b/server/src/main/java/org/opensearch/transport/TransportRequest.java
@@ -46,6 +46,7 @@
 import com.google.protobuf.CodedOutputStream;
 
 import java.io.IOException;
+import java.io.OutputStream;
 
 /**
  * A transport request
@@ -69,7 +70,7 @@ public Empty(StreamInput in) throws IOException {
             super(in);
         }
 
-        public Empty(CodedInputStream in) throws IOException {
+        public Empty(byte[] in) throws IOException {
             super(in);
         }
     }
@@ -94,8 +95,8 @@ public TransportRequest(StreamInput in) throws IOException {
         parentTaskId = TaskId.readFromStream(in);
     }
 
-    public TransportRequest(CodedInputStream in) throws IOException {
-        protobufParentTaskId = ProtobufTaskId.readFromStream(in);
+    public TransportRequest(byte[] in) throws IOException {
+        protobufParentTaskId = new ProtobufTaskId(in);
     }
 
     /**
@@ -136,7 +137,7 @@ public void writeTo(StreamOutput out) throws IOException {
     }
 
     @Override
-    public void writeTo(CodedOutputStream out) throws IOException {
+    public void writeTo(OutputStream out) throws IOException {
         protobufParentTaskId.writeTo(out);
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/TransportResponse.java b/server/src/main/java/org/opensearch/transport/TransportResponse.java
index e26d862700076..e9d56fcb57cc2 100644
--- a/server/src/main/java/org/opensearch/transport/TransportResponse.java
+++ b/server/src/main/java/org/opensearch/transport/TransportResponse.java
@@ -39,6 +39,7 @@
 import com.google.protobuf.CodedOutputStream;
 
 import java.io.IOException;
+import java.io.OutputStream;
 
 /**
  * Response over the transport interface
@@ -66,12 +67,12 @@ public TransportResponse(StreamInput in) throws IOException {
     * currently a no-op. However, this exists to allow extenders to call <code>super(in)</code>
     * so that reading can mirror writing where we often call <code>super.writeTo(out)</code>.
     */
-    public TransportResponse(CodedInputStream in) throws IOException {
+    public TransportResponse(byte[] in) throws IOException {
         super(in);
     }
 
     @Override
-    public void writeTo(CodedOutputStream out) throws IOException {}
+    public void writeTo(OutputStream out) throws IOException {}
 
     @Override
     public void writeTo(StreamOutput out) throws IOException {}
@@ -93,6 +94,6 @@ public String toString() {
         public void writeTo(StreamOutput out) throws IOException {}
 
         @Override
-        public void writeTo(CodedOutputStream out) throws IOException {}
+        public void writeTo(OutputStream out) throws IOException {}
     }
 }
diff --git a/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java
index b657a755702f8..228605bf8820b 100644
--- a/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java
+++ b/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java
@@ -37,8 +37,6 @@
 import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.core.common.io.stream.Writeable;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.function.Function;
 
@@ -47,14 +45,12 @@
  *
  * @opensearch.internal
  */
-public interface TransportResponseHandler<T extends TransportResponse> extends Writeable.Reader<T>, ProtobufWriteable.Reader<T>, TryWriteable.Reader<T> {
+public interface TransportResponseHandler<T extends TransportResponse> extends Writeable.Reader<T>, ProtobufWriteable.Reader<T> {
 
     void handleResponse(T response);
 
     void handleException(TransportException exp);
 
-    void handleExceptionProtobuf(ProtobufTransportException exp);
-
     String executor();
 
     default <Q extends TransportResponse> TransportResponseHandler<Q> wrap(Function<Q, T> converter, Writeable.Reader<Q> reader) {
@@ -80,18 +76,6 @@ public Q read(StreamInput in) throws IOException {
                 return reader.read(in);
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
-
-            @Override
-            public Q read(CodedInputStream in) throws IOException {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'read'");
-            }
-
             @Override
             public Q read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
@@ -111,22 +95,11 @@ public void handleResponse(Q response) {
                 self.handleResponse(converter.apply(response));
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                self.handleExceptionProtobuf(exp);
-            }
-
             @Override
             public String executor() {
                 return self.executor();
             }
 
-            @Override
-            public Q read(CodedInputStream in) throws IOException {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'read'");
-            }
-
             @Override
             public Q read(StreamInput in) throws IOException {
                 // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/transport/TransportService.java b/server/src/main/java/org/opensearch/transport/TransportService.java
index 140e5924e23f4..53d25182cbda1 100644
--- a/server/src/main/java/org/opensearch/transport/TransportService.java
+++ b/server/src/main/java/org/opensearch/transport/TransportService.java
@@ -45,8 +45,6 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
-import org.opensearch.common.io.stream.ProtobufStreamInput;
-import org.opensearch.common.io.stream.ProtobufStreamOutput;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
@@ -66,7 +64,6 @@
 import org.opensearch.core.common.Strings;
 import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
 import org.opensearch.node.NodeClosedException;
-import org.opensearch.node.ProtobufNodeClosedException;
 import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.node.ReportingService;
 import org.opensearch.tasks.Task;
@@ -104,7 +101,6 @@ public class TransportService extends AbstractLifecycleComponent
     implements
         ReportingService<TransportInfo>,
         TransportMessageListener,
-        ProtobufReportingService<ProtobufTransportInfo>,
         TransportConnectionListener {
     private static final Logger logger = LogManager.getLogger(TransportService.class);
 
@@ -407,23 +403,10 @@ public TransportInfo info() {
         return new TransportInfo(boundTransportAddress, transport.profileBoundAddresses());
     }
 
-    @Override
-    public ProtobufTransportInfo protobufInfo() {
-        BoundTransportAddress boundTransportAddress = boundAddress();
-        if (boundTransportAddress == null) {
-            return null;
-        }
-        return new ProtobufTransportInfo(boundTransportAddress, transport.profileBoundAddresses());
-    }
-
     public TransportStats stats() {
         return transport.getStats();
     }
 
-    public ProtobufTransportStats protobufStats() {
-        return transport.getProtobufStats();
-    }
-
     public boolean isTransportSecure() {
         return transport.isSecure();
     }
@@ -448,7 +431,7 @@ public boolean nodeConnected(DiscoveryNode node) {
      *
      * @param node the node to connect to
      */
-    public void connectToNode(DiscoveryNode node) throws ConnectTransportException, ProtobufConnectTransportException {
+    public void connectToNode(DiscoveryNode node) throws ConnectTransportException {
         connectToNode(node, (ConnectionProfile) null);
     }
 
@@ -500,11 +483,11 @@ public void connectToExtensionNode(final DiscoveryNode node, ConnectionProfile c
      * @param node the node to connect to
      * @param listener the action listener to notify
      */
-    public void connectToNode(DiscoveryNode node, ActionListener<Void> listener) throws ConnectTransportException, ProtobufConnectTransportException {
+    public void connectToNode(DiscoveryNode node, ActionListener<Void> listener) throws ConnectTransportException {
         connectToNode(node, null, listener);
     }
 
-    public void connectToExtensionNode(DiscoveryNode node, ActionListener<Void> listener) throws ConnectTransportException, ProtobufConnectTransportException {
+    public void connectToExtensionNode(DiscoveryNode node, ActionListener<Void> listener) throws ConnectTransportException {
         connectToExtensionNode(node, null, listener);
     }
 
@@ -745,7 +728,7 @@ static class HandshakeRequest extends TransportRequest {
             super(in);
         }
 
-        HandshakeRequest(CodedInputStream in) throws IOException {
+        HandshakeRequest(byte[] in) throws IOException {
             super(in);
         }
 
@@ -776,22 +759,6 @@ public HandshakeResponse(StreamInput in) throws IOException {
             version = in.readVersion();
         }
 
-        public HandshakeResponse(CodedInputStream in) throws IOException {
-            super(in);
-            ProtobufStreamInput protobufStreamInput = new ProtobufStreamInput(in);
-            discoveryNode = protobufStreamInput.readOptionalWriteable(DiscoveryNode::new);
-            clusterName = new ClusterName(in);
-            version = Version.readVersionProtobuf(in);
-        }
-
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            ProtobufStreamOutput protobufStreamOutput = new ProtobufStreamOutput(out);
-            protobufStreamOutput.writeOptionalWriteable(discoveryNode);
-            clusterName.writeTo(out);
-            out.writeInt32NoTag(version.id);
-        }
-
         @Override
         public void writeTo(StreamOutput out) throws IOException {
             out.writeOptionalWriteable(discoveryNode);
@@ -944,16 +911,6 @@ public String toString() {
                         return getClass().getName() + "/[" + action + "]:" + handler.toString();
                     }
 
-                    @Override
-                    public T read(CodedInputStream in) throws IOException {
-                        return handler.read(in);
-                    }
-
-                    @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                        handler.handleExceptionProtobuf(exp);
-                    }
-
                     @Override
                     public T read(byte[] in) throws IOException {
                         return handler.read(in);
@@ -1671,26 +1628,10 @@ void setTimeoutHandler(TimeoutHandler handler) {
             this.handler = handler;
         }
 
-        @Override
-        public T read(CodedInputStream in) throws IOException {
-            return delegate.read(in);
-        }
-
         @Override
         public T read(byte[] in) throws IOException {
             return delegate.read(in);
         }
-
-        @Override
-        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-            if (handler != null) {
-                handler.cancel();
-            }
-            try (ThreadContext.StoredContext ignore = contextSupplier.get()) {
-                delegate.handleExceptionProtobuf(exp);
-            }
-        }
-
     }
 
     /**
diff --git a/server/src/test/java/org/opensearch/test/NoopDiscovery.java b/server/src/test/java/org/opensearch/test/NoopDiscovery.java
index 5779ebd03aabd..f7365d7d71693 100644
--- a/server/src/test/java/org/opensearch/test/NoopDiscovery.java
+++ b/server/src/test/java/org/opensearch/test/NoopDiscovery.java
@@ -37,7 +37,6 @@
 import org.opensearch.common.lifecycle.LifecycleListener;
 import org.opensearch.discovery.Discovery;
 import org.opensearch.discovery.DiscoveryStats;
-import org.opensearch.discovery.ProtobufDiscoveryStats;
 
 public class NoopDiscovery implements Discovery {
 
@@ -79,9 +78,4 @@ public void stop() {}
 
     @Override
     public void close() {}
-
-    @Override
-    public ProtobufDiscoveryStats protobufStats() {
-        return null;
-    }
 }
diff --git a/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java b/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java
index d72863baf010d..89f0ee6699bad 100644
--- a/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java
@@ -34,14 +34,10 @@
 
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
 import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.http.HttpInfo;
 import org.opensearch.http.HttpServerTransport;
 import org.opensearch.http.HttpStats;
-import org.opensearch.http.ProtobufHttpInfo;
-import org.opensearch.http.ProtobufHttpStats;
 import org.opensearch.plugins.Plugin;
 
 /**
@@ -61,18 +57,9 @@ public static class TestPlugin extends Plugin {}
         new TransportAddress[] { DUMMY_TRANSPORT_ADDRESS },
         DUMMY_TRANSPORT_ADDRESS
     );
-    // private static final TransportAddress DUMMY_PROTOBUF_TRANSPORT_ADDRESS = new TransportAddress(
-    //     TransportAddress.META_ADDRESS,
-    //     0
-    // );
-    // private static final BoundTransportAddress DUMMY_PROTOBUF_BOUND_ADDRESS = new BoundTransportAddress(
-    //     new TransportAddress[] { DUMMY_PROTOBUF_TRANSPORT_ADDRESS },
-    //     DUMMY_PROTOBUF_TRANSPORT_ADDRESS
-    // );
+    
     private static final HttpInfo DUMMY_HTTP_INFO = new HttpInfo(DUMMY_BOUND_ADDRESS, 0);
     private static final HttpStats DUMMY_HTTP_STATS = new HttpStats(0, 0);
-    private static final ProtobufHttpInfo DUMMY_PROTOBUF_HTTP_INFO = new ProtobufHttpInfo(DUMMY_BOUND_ADDRESS, 0);
-    private static final ProtobufHttpStats DUMMY_PROTOBUF_HTTP_STATS = new ProtobufHttpStats(0, 0);
 
     @Override
     protected void doStart() {}
@@ -98,13 +85,4 @@ public HttpStats stats() {
         return DUMMY_HTTP_STATS;
     }
 
-    @Override
-    public ProtobufHttpInfo protobufInfo() {
-        return DUMMY_PROTOBUF_HTTP_INFO;
-    }
-
-    @Override
-    public ProtobufHttpStats protobufStats() {
-        return DUMMY_PROTOBUF_HTTP_STATS;
-    }
 }
diff --git a/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java b/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
index 9adf613a421ee..8932e9c59c434 100644
--- a/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
@@ -34,22 +34,15 @@
 
 import org.opensearch.action.ActionListener;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
 import org.opensearch.common.transport.BoundTransportAddress;
-// import org.opensearch.common.transport.ProtobufBoundTransportAddress;
-// import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.transport.CloseableConnection;
 import org.opensearch.transport.ConnectionProfile;
-import org.opensearch.transport.ProtobufConnectionProfile;
-// import org.opensearch.transport.ProtobufTransportMessageListener;
 import org.opensearch.transport.TransportRequest;
-import org.opensearch.transport.ProtobufTransportStats;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportMessageListener;
-import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestOptions;
 import org.opensearch.transport.TransportStats;
 
@@ -147,48 +140,6 @@ protected void doClose() {
 
     }
 
-    // @Override
-    // public void setMessageListenerProtobuf(ProtobufTransportMessageListener listener) {
-    //     // TODO Auto-generated method stub
-    //     throw new UnsupportedOperationException("Unimplemented method 'setMessageListener'");
-    // }
-
-    // @Override
-    // public ProtobufBoundTransportAddress boundProtobufAddress() {
-    //     // TODO Auto-generated method stub
-    //     throw new UnsupportedOperationException("Unimplemented method 'boundProtobufAddress'");
-    // }
-
-    // @Override
-    // public Map<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses() {
-    //     // TODO Auto-generated method stub
-    //     throw new UnsupportedOperationException("Unimplemented method 'profileProtobufBoundAddresses'");
-    // }
-
-    // @Override
-    // public ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException {
-    //     // TODO Auto-generated method stub
-    //     throw new UnsupportedOperationException("Unimplemented method 'addressesFromStringProtobuf'");
-    // }
-
-    // @Override
-    // public void openProtobufConnection(DiscoveryNode node, ProtobufConnectionProfile profile, ActionListener<Connection> listener) {
-    //     // TODO Auto-generated method stub
-    //     throw new UnsupportedOperationException("Unimplemented method 'openProtobufConnection'");
-    // }
-
-    @Override
-    public ProtobufTransportStats getProtobufStats() {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'getProtobufStats'");
-    }
-
-    // @Override
-    // public ProtobufResponseHandlers getProtobufResponseHandlers() {
-    //     // TODO Auto-generated method stub
-    //     throw new UnsupportedOperationException("Unimplemented method 'getProtobufResponseHandlers'");
-    // }
-
     @Override
     public ProtobufRequestHandlers getProtobufRequestHandlers() {
         // TODO Auto-generated method stub
diff --git a/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java b/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
index f53b63fa0a578..a1e49be32b0d7 100644
--- a/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
@@ -35,25 +35,18 @@
 import org.opensearch.Version;
 import org.opensearch.action.ActionListener;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.lifecycle.Lifecycle;
 import org.opensearch.common.lifecycle.LifecycleListener;
 import org.opensearch.common.transport.BoundTransportAddress;
-// import org.opensearch.common.transport.ProtobufBoundTransportAddress;
-// import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.tasks.Task;
 import org.opensearch.transport.ConnectionProfile;
-import org.opensearch.transport.ProtobufConnectionProfile;
-// import org.opensearch.transport.ProtobufTransportMessageListener;
 import org.opensearch.transport.TransportRequest;
-import org.opensearch.transport.ProtobufTransportStats;
 import org.opensearch.transport.RequestHandlerRegistry;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportMessageListener;
-import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestHandler;
 import org.opensearch.transport.TransportRequestOptions;
 import org.opensearch.transport.TransportStats;
@@ -325,48 +318,6 @@ void messageReceived(TransportRequestHandler<Request> handler, Request request,
         default void clearCallback() {}
     }
 
-    // @Override
-    // public void setMessageListenerProtobuf(ProtobufTransportMessageListener listener) {
-    //     // TODO Auto-generated method stub
-    //     throw new UnsupportedOperationException("Unimplemented method 'setMessageListener'");
-    // }
-
-    // @Override
-    // public ProtobufBoundTransportAddress boundProtobufAddress() {
-    //     // TODO Auto-generated method stub
-    //     throw new UnsupportedOperationException("Unimplemented method 'boundProtobufAddress'");
-    // }
-
-    // @Override
-    // public Map<String, ProtobufBoundTransportAddress> profileProtobufBoundAddresses() {
-    //     // TODO Auto-generated method stub
-    //     throw new UnsupportedOperationException("Unimplemented method 'profileProtobufBoundAddresses'");
-    // }
-
-    // @Override
-    // public ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException {
-    //     // TODO Auto-generated method stub
-    //     throw new UnsupportedOperationException("Unimplemented method 'addressesFromStringProtobuf'");
-    // }
-
-    // @Override
-    // public void openProtobufConnection(DiscoveryNode node, ProtobufConnectionProfile profile, ActionListener<Connection> listener) {
-    //     // TODO Auto-generated method stub
-    //     throw new UnsupportedOperationException("Unimplemented method 'openProtobufConnection'");
-    // }
-
-    @Override
-    public ProtobufTransportStats getProtobufStats() {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException("Unimplemented method 'getProtobufStats'");
-    }
-
-    // @Override
-    // public ProtobufResponseHandlers getProtobufResponseHandlers() {
-    //     // TODO Auto-generated method stub
-    //     throw new UnsupportedOperationException("Unimplemented method 'getProtobufResponseHandlers'");
-    // }
-
     @Override
     public ProtobufRequestHandlers getProtobufRequestHandlers() {
         // TODO Auto-generated method stub
diff --git a/test/framework/src/test/java/org/opensearch/test/disruption/NetworkDisruptionIT.java b/test/framework/src/test/java/org/opensearch/test/disruption/NetworkDisruptionIT.java
index 22ba5cdbcf691..0ee1146c52ccf 100644
--- a/test/framework/src/test/java/org/opensearch/test/disruption/NetworkDisruptionIT.java
+++ b/test/framework/src/test/java/org/opensearch/test/disruption/NetworkDisruptionIT.java
@@ -45,7 +45,6 @@
 import org.opensearch.test.disruption.NetworkDisruption.TwoPartitions;
 import org.opensearch.test.transport.MockTransportService;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
@@ -223,12 +222,6 @@ public TransportResponse read(CodedInputStream in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
-
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         );
     }

From 35d8906f4be25047ade7a33455ec3fa60eba87df Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Mon, 31 Jul 2023 07:35:33 +0000
Subject: [PATCH 23/37] Ignoring proto generated classes

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .gitignore                                      |   2 +-
 ...tensionRequestProto$ExtensionRequest$1.class | Bin 2790 -> 0 bytes
 ...nRequestProto$ExtensionRequest$Builder.class | Bin 11386 -> 0 bytes
 ...ExtensionRequestProto$ExtensionRequest.class | Bin 12446 -> 0 bytes
 ...RequestProto$ExtensionRequestOrBuilder.class | Bin 697 -> 0 bytes
 .../ExtensionRequestProto$RequestType$1.class   | Bin 1234 -> 0 bytes
 .../ExtensionRequestProto$RequestType.class     | Bin 5611 -> 0 bytes
 .../proto/ExtensionRequestProto.class           | Bin 3318 -> 0 bytes
 .../tasks/proto/TaskIdProto$TaskId$1.class      | Bin 2505 -> 0 bytes
 .../proto/TaskIdProto$TaskId$Builder.class      | Bin 9996 -> 0 bytes
 .../tasks/proto/TaskIdProto$TaskId.class        | Bin 11288 -> 0 bytes
 .../proto/TaskIdProto$TaskIdOrBuilder.class     | Bin 429 -> 0 bytes
 .../opensearch/tasks/proto/TaskIdProto.class    | Bin 2532 -> 0 bytes
 ...ResourceStatsProto$TaskResourceStats$1.class | Bin 2758 -> 0 bytes
 ...ceStatsProto$TaskResourceStats$Builder.class | Bin 14366 -> 0 bytes
 ...eStats$ResourceUsageDefaultEntryHolder.class | Bin 1971 -> 0 bytes
 ...$TaskResourceStats$TaskResourceUsage$1.class | Bin 3039 -> 0 bytes
 ...esourceStats$TaskResourceUsage$Builder.class | Bin 9805 -> 0 bytes
 ...to$TaskResourceStats$TaskResourceUsage.class | Bin 11572 -> 0 bytes
 ...sourceStats$TaskResourceUsageOrBuilder.class | Bin 537 -> 0 bytes
 ...skResourceStatsProto$TaskResourceStats.class | Bin 15186 -> 0 bytes
 ...eStatsProto$TaskResourceStatsOrBuilder.class | Bin 1364 -> 0 bytes
 .../tasks/proto/TaskResourceStatsProto.class    | Bin 4154 -> 0 bytes
 23 files changed, 1 insertion(+), 1 deletion(-)
 delete mode 100644 server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequest$1.class
 delete mode 100644 server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequest$Builder.class
 delete mode 100644 server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequest.class
 delete mode 100644 server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequestOrBuilder.class
 delete mode 100644 server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$RequestType$1.class
 delete mode 100644 server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$RequestType.class
 delete mode 100644 server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto.class
 delete mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskId$1.class
 delete mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskId$Builder.class
 delete mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskId.class
 delete mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskIdOrBuilder.class
 delete mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskIdProto.class
 delete mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$1.class
 delete mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$Builder.class
 delete mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$ResourceUsageDefaultEntryHolder.class
 delete mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsage$1.class
 delete mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsage$Builder.class
 delete mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsage.class
 delete mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsageOrBuilder.class
 delete mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats.class
 delete mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStatsOrBuilder.class
 delete mode 100644 server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto.class

diff --git a/.gitignore b/.gitignore
index 7514d55cc3c9a..c71db2ce0a542 100644
--- a/.gitignore
+++ b/.gitignore
@@ -64,4 +64,4 @@ testfixtures_shared/
 .ci/jobs/
 
 # build files generated
-doc-tools/missing-doclet/bin/
\ No newline at end of file
+doc-tools/missing-doclet/bin/
diff --git a/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequest$1.class b/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequest$1.class
deleted file mode 100644
index c518df95ed79f9b6daffd856f34d8eb068f67b53..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2790
zcmd5;L3i6k5dJ2Tqt;auJ8@`Z0;I*XcHBfwo0d?g1t%oLspI4&G<_Upd84Svl9A+6
z_$wSaa4naV2k*h19|g=RjvI_#c;)%PLE72b-Pv!xot@d=|M>Y=03TvU!w6y14{XEl
z2rm?7U>zCaMZ~h>d!f+@{Kz-fPZfLOtF8#6U8yY$Y72`RRKj)3ZyUDn+paiS-s~P4
z)n*t4rWNg)K_~*k=!)Yx(IbLVEFBQkHNPd&P;gO43ZsPay5osPx7`%M=VsFtgo(Ou
zneKrZII`bUs?m`X61M8Y@}NS<bR<Rw8abxB5%_Jwcg1>=QxbHm=5@N!eiR6^T}hmE
zh9=u#7QU%Fk*Ji01epP+*I!to6Up<^FhRJJgtg{9H(jR{pPc2ptKGvx5%d?Pk;7XW
zrU)CuVN%BxTxDpU_<FVLxGj0+d&OZnUFg}Yq>;yrhPMfg;ov^Ctm7TLOSsq;fh|sg
z;QRk?5S*fp`Iyyl4c7^JQxe~cW4<FpW1n})qM+jg+#uva5k2t^`8J0~qO~o;(6srs
zK20X8H{QDeZyu+-brEwKN`%Fv)lWQ`R`}jJ-}b@ugIq@$w+ORlc>ZM|+-I(m%%8t5
z=4C-9FoSTlSbt_dHx0)(YCC-hmC}KRMZ#pl7$N1zTtc{!xcNV_4I$gl)O+G2w-CyS
zi<6TOL5qV#-p<`2C8T~V5{Ls~DG|=U5J|Y3xa{2H<xDu0$T{Kieq>r-ZkwIBY-r%R
zQ%E}BL5ekeLMSE8OyrXwlEZ$`?wb{gI96QKvyGkRGhsy>XM{B!V;JWQyYF`cOKdo@
zM&{4JdR?d&qyf%l`;P6IQ8(a;ULw7JFVZVR3W&-hKAG`#&vO0H@$7989r-OzPc_dI
z!J2D^q2Rjpm~ihurEo6TgI;r3_lwSj2ESJ}{V>8Tv!?K?2l1a@8Qj;nXK+j0rsiJZ
z!jCMBAkBX{3}qCTSk_M_aC@11B$?+~8J1P<Wu+M!W3wsNRDZ%`W4?Ur7}HOGz~TdS
zTAe?}d&hYHHz^<E=Iib+$bK=czQX*eO13ZAkjmSRv0>TfIpxW=gxfqKp)E*IiVjs7
z!zE=L86|_flEsWNfs!(bvXaA+GKC7aE6No)8=JAO)t(Cs6L)YocB_gd++%lCJj8u|
z6DsUj8q4^IH8bq+G9Iv0W;DyFu(ZO~u0j2i0je5E!$S=pYYdac>|+hZhKAb{nJSN0
z2U)^RHZKoBo0AN!zGU$X-Hb<K9pNv9Ph)8v8*%#?dm!n~@xR7jp3UU2g*v8VFIdI8
N9JaaNV0i>ve*wSPPgDQ^

diff --git a/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequest$Builder.class b/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequest$Builder.class
deleted file mode 100644
index f80c23a713a9a75a01afac549f7fc88e6677a65c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 11386
zcmcgy349z?9sb_SZYP^g+ayiWhLD~qq?<rE%aOLylLphYG(DsuakH7E+orp5j~<Fp
zR1`!|v8b(hA5}rEm8KPxQZE$m`@S#mzzZ)d;P;=I-JRV|mNW#C-{$SUeeZvM|Kq*M
zLr>m&KY)wWECX7hE0G*%OAJ}@lod%vx3pQi(tICF#8YiU$wWHQwjw*R&U#74N~PDz
zY*X=U)6z_Au+K^w2q>H#O>A!)NF)XZEr&>NroZiSD{dttX{&Fwl}behtc~aA_e@Y&
zGd^;xNxFh4RP@HuD`VDR-#I-Bszbp{IvT9sJ!Ekzl!?cvQAZ!&S9flW?1;1tM&bi)
zYkId@(R91Qqya0v+)720v7vM#Nwu2iclv3TUz2LezbApfvP7R1LM5sVR4H6ICKXLg
zMUBGqWAU_=j7J80Qt3!K7VROip1j|B@_y^F{nk_Lp`JdEDy^rc$dt}l-0I3~@3oTa
zBfW!`7%UNu3~r1hWAfRZY|P4dx#d`XNi<4lC$gIsjbK0@XxNS`*xoLNJk3M{PFLv8
zavHNW`UM#U3>4aZtui|449rkiIVKOE6igMEg*gUhD_r7-w^0dXVlJ8#W-^#FNvpt|
zsg8Io9g7UcUTXCz^fY_0zicp)O0}Of;g9=K$su8o-V#eGtnC~h>txdgDNk4!qbiFP
z%9`hItUwvUCeB222nwwxLMSiC*$RB4aE^%zOr%AdN9$xak*tj*t$4cKp?|*6KbMS$
z>{*2cW22@Jj1Ds4Dy(BnjI&+D5SN%(fJ+t58-2*R`ZCTG7Md_nu255u0ts))oeK5#
zbbll>nC^%(AH}0q?z=0-O`-M*G-8Q~rFb3_&dDrk#9pa76%=@diIuX<v}fou0l4g6
zWugODFqy{+VNb+tmW`bzR-;Q{R@~aTAue!oBf~9ID|SV#p)~8ExXRbr?!tEeASp>x
zAe^*PG^4_*ae@J9PU=oaqT5zShU~m7R_GSou2(qUUj?5?&Z0qZudva?CcJ=@z2-fK
zRjGNrq;~jhHt|9<D;SBm2#^j@_Ez~rUQ_y$iS0e!q8{3AB?qjPoK{HqYnFG;xCfa+
zuZbQ+750yx6~@V&xg06Ez!EY03H7HlkzcV{(wj;rBhj>L$Q)q?Un0H5Vg_q085M%Q
zttPf%P+=-#*zF=Ek8F$#W|&MEi5-HmxQPUYxGLqhs=K-4SxA(PNSa82;Wv@8F;?w{
zka>?uEZ-4!r<1Yx0MpS9>@u)Zp|bcp6T2nJ7_rof?L+C^qRz`qTq{rxCF0Aru&=b3
zry6mciR-b46l`|e;)$JcyEd~vo;gCQ-Vo0(>$cJqL*W%BUWr#RE7}p@T|q)S{r&7+
zC3ME!oC@#t=PYe-Uq^f>lcpuD$aeoe%hRw9#0a|Gow2m_Y)Dy=%jqctHxY2QH)Dym
zjy1V&47^rhM&8X`nZd!e3A^jet*OAx2v^`%yxzcV3Qd0DQ>?m)H%KHHG(+F|$bjs=
z-Nc(@u3Y9;#53Dv@(vSk7FgEGq=P?+oLJJ@knX=&qWY~S_F=z56<d*%<#n#YhVl19
zhm^}Z@eTuTXIJ5;YDatrd&)lhd>Bm(F3t4!TgjZUOuQ5CqO_U#&SYfBV`+tH*<dSl
z0Sj3$CZJI`!#Bkg+m;)ua>t-`mIES%7T?YOXk)Y5mxwbdsm)AG>Bs=z@zVvqBuXpX
zZs0D3`F@u2<!#_2St#1a(DhrAiJi`2D@emirkq@uKiTz+x!3ZfVJ4JAxW~XJ6qbyw
zNP38wIE-N?z5YbfIWO{1H1^ExA<VY)5RRJoB<^LGx1np@ie+mq@9NmRV!6VyF;-14
zd0Mxy?kL<b*0S!UJMLLlymh~cW0EpL1Vq-%mG*(c!`i@Sn8N(<w{&;fa&k%qj^lGC
zJ};@pOedU4$uLBJ(qhk`ds$Fs`NBU>g@LEI%zKIAP+|;xrJ!0mcPrWQ=Tuvv!`*X6
zD1RO{BJDR!d=uZIw9&-SZfX4-X)o}eVqNC`4Y`LN#qMS0r{D9Hzt5M@*y6$y=l0c^
zr+J!Wdn?bj(j$axkfeVS_sIV&V5<>7GVx>lgykq=U*0rbq%imCCD}-y+A8FGm6TMe
zpPTq8exb0*pM<w;b=y6OA6`owPk1EBc={vaXr3=viy4V*zmX=2vdtX<d2Y*Vw;|GW
z{ocf4Ib+T&y`Ir9LZ@9Ugg-z}?zH##8}Fq0=c~B~gavJtpP@%;_C@<Y$tmJSg=?QH
zVLayd1kSGKn7xPftDY;?MQ#uP=EM+J{7qc(Vuj`Y0=b48;X<MqUPACOxh-O#x0FV9
zfgmFvSo}Er$HX!`Pk22p8G%Qaita=v$$O)iTqmFAL23Re!`ae*v&wbH2I7%4uQ3(A
z?Thh|6U4$Xwg$!W<m|t=eVi!fo>VYjm>qFG9I-E7t(2h@J#h-*X{a(Lu~BT`xx>BI
zG1LTwwoz>Hy4+B_5j=C0n+#Q<5cXS~e?;PaTw*Abne}Pb6E*qWhMK~Yf!~gk;b15}
zf4N|EYqPF)E`C{HT$^P-R~KBS+gEIcsvW@tMX_M0X$lQ~a<~f(RX>7_-35gXX&Av~
zp2aN8#bD+IZt+wOjqHa!JtW(JE<W>Hl}M#=E`zs>uOR<wxgO?IL@k%>_Q=b1j%T4B
zCMI#!WPWPmC_jNim~xP#MlJtNkXiLB)Y&uq7Sk}@-Lb^x08BiD`s&7NHH?}0jn!NV
z^)SlRA7H3QP{H>?#I)H=#5|l~ljIWsm)uIS6cH-JM=(EJb{H+;>az}`?c?@35yqkU
zC;~cxkbWPgsK0t>R(fcP`l8g8q^UVpg<Fo`yb?qoLy$x(NVHP@%O+aqY;=i|1TMgZ
zB+JJLxX43ZM4m>GFWw~N+dVwOd27_s5m5g{P(4md{Ew2KK&^VhBmFd&k;0;!OU}00
z`MN}xdG-c!d)e~1qUH7;#btRpY<KE%-@Q!v?%oJTvD(z|FqU_=4CC_sC~rB6=O1ek
zQe`$WY-i|6wA*BudJ3v^mB(&VU6F!x!y2q5!7I759MrqY;ME#WnmKkc8>2wOeQ3Oj
zmR#2vz6b65P#z}h4V2-kli1eL|I<*br=woid)PL(Y(vCK5!+f}tL0|g)$#^@Dx*+y
zgxjLi1J~`t#1_79IgG1M4`x5L9mb0UfsWFrF(9BDsq_p?)H5+v&!z-(Fk3g-Qp|EF
zx>As~D@BmJuc7+dHUppKpTJZlk;m4+6(_<k#pu&pj-zoO%y7#CXdFi5pg^~8lMN=X
z<(pyX`KZ(_sMD<;6HL!BpN;`+A$74lb3vueF6y$oi&MgG75#eI2M`P&Y`F(l+kA%+
z8^-ocH2zD5k=c*>Fu!^cBQbmxEfw4&C?Cd4#XBz_#tob74|!mO`Roq*Tzcp{ig!Nk
zb0OyH1!&P1;X-{eF431_scy$gz0f1}s+`!XD0UVwOkbfXGZ}k)EaVE_%28rY2kw@?
z`7EWE*yNl9qg`@h;TyT?)m$6kzSl@vP`B_s9f`fI4`SkdxcRChxaC;c;se-9onE&f
zP#d_5-vaCS5{SspT)rfGHuF`@*P;N|Un)j;qogV^O+ZX@0P|#WZ-KoIFsrq+)&`E?
zE&CA+EN<NQ)LRdry6dcAyzSVfL9t+c@R(~z%_Mm(Z=Ubucq4za;Ok}Ph3;VbyMht7
z8k2PwqizkR>9ts>*I}{l#uB{&9eN|W^(Ji8n{kbPA-3qNu}$}2hkh}3anH57AA9rw
zZq!@w8XdzedMj?@c)Q+aTX3;so18=T;@x<UZS%c&FWyIMPDUK>#|LPeX^7we?GnHq
zrnnE{L!1-5%}0fKg8yD}0$~-Xsd*gcQ>0pEKpD8zz=vhLbA^GsnG)oA1OH0CZsRD<
z4N4pq`#0n9Z!qUyK8A2NZ*U=98*V7@NDiM4Se(T5a>np=n4+&|4DYcCI|;uwr*<tq
zDhZ3fAHzYH#WfryYHCEjqxg7d%Yz6V!jS_Acyd&QtkE~2T;J@WT;ozMr(4(HUQ!Z6
znUV|mFDHjC<BN0m;ZrWJjH^x)dE`Kv$C-fa)1s$@Vm|tu4E08W<aUB&FO$O^n4#Z{
zIr=RgS(<WMHc`v0EKCv-JrCsSTPH;jchuQzE1$eBSKzWty(WDJQ{p=r^6x^8ez(V0
zbva-0;f<@@UYdvvf}MQZI+^lz>_-hV-tpC~!}x4hSPK7H2RX4Lui6}mKmB1k?k=kK
z5puel`2Q$X{1_VaK{V<^HrKF2+2ty!_Y3TIc;8H8KZq}qa~(UPFX15<t9DgtH1K7v
z`6|BVN_Z33N$k&}s~rjVp;`nwim$H@w^F`Vk?(l1eD_hlPf@;Ol<$6m>(jKx15AR)
zDdT5t`J5s#D<@xrD_;$z`nD~f0K=B5!IA1a_^vBe+y%w#0#LAI6({GsSa$EBze<t5
zMst0gVtfNL^*3!%9L&$op<y=B@DN$KB}35gy&M{@bkWcdX31c2$TF>b!p4OkB!0k_
z>W8e;KcWGCY;$zdbGA+^d>=n>RomgJHqWaXgY1XllIl5t{|(jqEiL{#GW$K%dzdBX
z5s!-Vaw^WFieL1qSS3eXSB6D&y2N)#itf)IfD$u$Ys{k_nxP!c5PpeYkwld|=<_4>
zYaddNl_FKSgx6QUbxF<R=w!uV{H{nMe&P1!_LhfFbqg=m+%0Fgx=)bIaziOLuf!v#
zyr&0$ApL?e%>QyI<1b*aHV)&DrC9dh&(Cc8qt9&nU!K|aem{HtwY0*2Kjl6ACn9%`
z7cu`R#byEidFosKb*fvI`9k^Mr370BKPZ>n!n<ofll`|8o1gkax#XUezS=A=#b%|i
zHY0Cg1^b_!c~0O7dwdd4aqI=}U6fXVKu86ZVUHm-ktd0I9<(RhpDQ_5PcSiy<5bkE
r8dawP6GCdbI!#7a!%B5J*YkftRDffUpBp)Uh~tdQ>eWn}U*-P+xO%u+

diff --git a/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequest.class b/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequest.class
deleted file mode 100644
index 9da2f0cd30b626531f60edf3fba0a7fe72fba8b3..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 12446
zcmc&)33yc3b^ebu(r9@IA!KYJHe(FZNFW2oYyzWYfWca@7HqH+F&aHd1EU#vW(3Ag
zw=`|tH0c(nX-E?%X&NUjNgWJAHf|cbt&=8goo-3@HfxupOPaP$TgUBx-g`6iH1iOM
zPQL2<G;iL$_niBm^`3k0eD?L{KM7!`^!ZUDIG9LIv?Zp^c*+bXBa?0BqiKGRCgQ2K
z>0~0EXbWZ<2Fyoh%vAcQwr<F8^}{FF7)eaEO(YT%G1Dd<of&UCWX8>8IBkygnyFNH
z!aTO!k8(kOapvt$cFsg&V`frNn=+HpaO{|wRQSW8Zh;&TEa{>w>2N%KEF7CL%P6|_
zC%A1Oc>i#4aA@fG(cs9zP_U<aq;I&lGdMuHP$>tAz)0Fc51pGfM+CPF_k~Ck>Yg`V
z$5NA(Gw~=j6dL2ex}H<vGvT&aI6l$VKYGfHr1z3~%A86>A2Y{7sZczcCRTmnY@Gz(
z9X!}E+%q&1>Kh#D=<5m!4)+vCMVz_(Xve^y3bv}p%S1=RN$QT{DhHzz@o;)3X$r;{
z7}{PeX!|*7MSCO`r9SoxN}HOG34C3NF|!JSbp~$7YQk@~`YYLVhk+Hi)sH)=pW>)z
z!`3Qnz&d5#WZ*V52$uFl<7VH?)To&p3XjI9jJlpggsv5)gYn&I+}`A=qC$t?;P~iX
zmF}L!Qnd&6lduY<*rNJqQKWYnSc)YT*d~C!-)*1{%k|qm2I_GOm6)E4rUd@cOnBV2
zSg?W>^QC4CWF%iCFBL%rSSP5Cn`c8-Kt`z7!5db_aC|0ZjvY-#&oGzJVZ&2qnm*g?
z6=>x%)?mTCH;VHb+?hQl%yhSziX@}c=>(I^mZoM;p1Cop4Y}`oE76UEegp+OZpvE?
z9KvD2ebG3DjfZ0+%w*|kWQ5E{a!Gq6m$XN$q&<?Ko=3)9GPEv60>SFc<cG}k!KfJ<
z>xe{{$`hH`*mn(;c*H>=xuu~V1HI^@H)LkIX)(t=@a^>!_r}oqaa7QEQ>H6eA~RW_
z3IiDOV^FZ$D;eJqFayJ2E?LW^n#p>eTIa7VBTcRV>57F@sl5da-X48JIGDbdGeVrw
zKvzj?m9;W?NKiAsPY|T9+?+ODQ!tf0j5qr620_RFnVEqRoaD+ko=DmmpCwUKs2C_K
ziE`9H1YF{c;l6=jSO1~D(1{@HlCB~sfy-jjOwGj7Oj3jCaO8Avc-l$N)l~biQ;Z1e
zsq<VlGMG+A;}d)RIK`qPzuAwNV2zhocAiU{Hfa@3BW@spNs5(D*p0*K@m(}}(i|6*
zjB?#s=NWW4E_58>Fn67lMRsN$GP`_YlS?S&L+bU{$ULrT6zyXM9><%AHj<b=cQBcl
zveDk{4h?5=?@(~@BkWNsJUTzhSht+uT6;DbO`AgrLBM-i)4FD?e<nRWljeM8c*-gW
zs)CP3%;~h2+<v@;0cBYwnrI94XM5C_e$>E^sV}W{>ei9qgG0f-!BBtSNLSDB;81X2
zgr(z9P^06=4ZIZ((ygg9+pVkcHvFU?Zx`I@W#0m527U@ZO$L@s!T8LSpsXnrvI~))
zHSi8RY3adMTySbSeU25bTcu9j+k8S-{+~1OF8n-~e~X_@B-nSOdJ4HbIK!7Ek>I?6
z_uv;Y-f=pfI2*UJA-!YMHN0auo*Oo3rkPFNhxhyO6pKqQ&EyR?@Pqgv#$LiQBWLk+
z^a6F#-<Q!AgVq*B%l<)rXubAJ20n}>bk5A?Ks(e}A2IMz{4$GCf}+EiY6I<a>=06|
zUNG=6e4MPEF}7aqQ7f9flt!}m;TZ$JsNUgAS^Ubm#|g($%J7nbi+EBMJ8NJ9lU0b~
zl9F6vbSFlcGs+U_N!@K#OomgFDy9nYYX&~4Leyr2IP7#Pr%xH^KxY+Z@REV6cu;x1
zq&#0D0_8$4o7NqOhNd91V#OH&8hD*E<KtGLcXO#ezY=2R`)$ECFH48wXSgL}jmZse
zBoVVG&W2z$K8N4+<97rry@>5Sl!2G=dxB;s4hm$*C0xggse-X^I?T|qJv@&>@K$eD
zo?hpYbt0NdC(rdTAF)I(lIBzcf2b1vkzl9@usoEpEL+JAn6?OlmPN=aIOUyETq(S$
z`uJ1T$DeTnb_3IT$otOgk}X2`q6+qxD%f9H;ppY=E`2Tvp@$B7njY#bD)cWY^e=P!
zYBBbhvE-pn!CCe$3VIQv=<AB`Z&|)B7K4W{nS7}QL)=wa6f5d=S@;J7-@rFnN?LjP
zfoOWtRhtNodV8^*5}o}<0X#3Sa*hbOSe8XqmTX$gqt2zpypI15gQ|kQr3(62!Q+e9
z#G)WCth74IJl$q2I>p34rt7JK`*#EXq1IbHzdO&2I`TU@l44AIi(yqY-!musZ`I*z
zg0T1G8E^7Zfd??JVLA8O=&AJrHiGwfgDDv4$?to-9@Ap18}SVh!P~rXE=p;Ol3`)}
zF5@YmbLhzn20a%L4BYhI-=#<E3L<lo!qQ!&%#d=SBC2vzYIB7lmD*gHPGoNg&Nme+
zDHdzJa!JxJh9OI&ijb$w<b+cVS6b(JX)3S^{d#`-gtwtRPHP;o=>ldvU9>829^yJ4
zNXv2_WZf(%o?(?UD-j@1u08$lx`J`}DUwyQqVZgUd$n$JJj~;j++p>RqB$@ZI2D_h
zE<A3z#x~UnUBTpn1B!YTqh~DkyxFL2DAYu@?~ZFAbMmaU`_NciXUJ-~jVBiikEd4N
zaI=o&={pXNtX&n$2181umb;3Du_*R=beoip`Q%!s3i)$!ha9%f$v5oe!GgC~t|Gem
zm|t3XqLnM~La~@R5sq~vCuXJ?AK87V3bDnIHVLpgicFf3(>XSwlzp^SHJF%5MtCl)
zcULR()2Fq;-J&yb`3S{%J!>5dn<>BC&9f`7%$~c_a9?lu<sKUKI^&s{bJTv>%{vq?
zifhL?57wMi=9hNvv=&EAceb+2l6mQn5kBwG+&Vb*%K;uq-5`7K8zXKyygU5Tb&d0-
zJjd}1FN+$zKsW>aa)@5IzyP=F`h}<Po)&Vr>0qAQ<hzKVA-~CW(_Za5jHjRX@mB$d
z6R9+|^0cRv|7EDaO8EK7#Y`{9QH2IpDoe8OHEiPrCi@yt>uO(yPQA#qXn2ju=Sscr
zwVu41CH+dPuMw@}z6z_^vW6}D$WQ-nxe7Uc1#6$h`m5N$ZyTS*rcbb=1kL=cAv~14
zj;hjf)R#6OVD)G(?^XF}GjFw6#`vyGR|HzFU~{1KGTH)lTQ6gKpyV=kD9=)h=L(7o
ze2JgmMU~W|R(25hmo45aY!29Ii9lZ1h24a_hZF{%cFSIVQv?}dM){_F>jGEMo<Fhc
zJtx;1DjWC;e8f;m3`>cj9$%%xzJ|5<x`oA_Z=Hk1N0sg8EULVA&Zm-AILdp5-)()B
zTR6VylBFUmO9k%50rofO>7K)BgEb!TT|`$tmv3dY?L!Dh9EuLhVSwt3xUWv?`e$)}
zj<Ajb0k3k%e^S8j(2HJmiBj!A5j=ng9d>Pes_M!Dm(X@$z8q5OA}-4kAIAxY_>Fw3
z9_p2N4iELTd>WM(5q=uJ76oP7yGqAM6)L3K;%D2q-r-k4yP6myr*TpkD0vNaems1D
z|7_!lsx#M<<f6i@=Um%+T3$r--Kc2!6r#`Y<8*K9ET;Mbo9S(vb2G1}%R_EOncN0L
z8n8@O@ut5KD`YhqWeuytwHBg)&DlXzM!%Y7NHH}L&m%~3=0>VBg)}8nlnm3?u*}Z`
zTAqsFQ3v4@9H+l*S?5AnrwHe8t~bz1Xss63e0<Hs7a+dPjD%J!mlo8^7XGTDjTpCD
z_}1Bcv-lbveDy^2eHOkfszyb%4Bw9*a8R8hDz#AqQSE4N^t~Ttz6*`#QC4~(;A33+
z)ab6jlwE|gn{f7^PTFy+>~k5dAq%0NQ{2KSbYlK2>NOIS@s&sYobAnQ^zrS7t!Q}*
z*(-u=>LnNPBeQtoDHtt2eVxTmsJ7<tGw0c)PRQ@?49w!)EwgxUE@!MnIW5`6BlB)r
z?;tIA2+b10RypE=x6Ogax$pse(1GVe$%;CD=LtSPHGXFuL_M7EL+y<vPob>wLTS4K
z%HXSMwD8U0>66-SBdlq35dO-^_C^Ici(h4T<7IrPF{j2Ys3z7vs<EG1xgRw$KuZo{
zl?-8{9K&7m0QSmp{>I@1j>tnU{5@Iq9>OQAByZcbRMp#1PxQQNaAbIaI#q8w+!FY(
znv@YC=TWJ-_t^{dI_Xt$TKP}uXzN*AW{g~(#TDE3M9+6hFlW8H+#tZT0Xa$hVfZCN
z{A2XUaeCw=@kbGmQ@BS?<DkS`-g!8y`@?w7ik=3v;d$oq5+}0D{Du`ZvUDkB;Jt<;
z$#Wc`{xL+rFEFU}aiO-ky>@xy<Q#r|7B8M`uf4Nz(#OY+#z_^+ZYXmaEU|urFRR&W
z$@H7HRbD8t$|IC0NoA&)@n>k2GgvQY(JGH(yPU%Tc?`YsI0ocRE~^YVk}X9Lzm>HL
zmu-V<^~?A)!Dk%)GnRYpWQ*q1B^R+N@Ekr{0-7V2q^&hV-fYcauQ5yT3O-K)W%v69
z>^dE9tx<L@&*2YBz4$%hLR{nU)Ajq0@dbiW&R;CxoCowzJb}JF4`|W>`sW4g@`3(^
zC(w7~0abqUf&O&?=RBZ);|cU#c|gD70R3tKyL_Nu^91_dJfO;NKG45&akg{aZnmiD
zxjJtO%;E3n8Qxw9Kggoz11_l5_(%K`Nz_FDT)?o~F}`6Le-8iR!SSQ0mXEl=8V*NY
zPBZ5JHm(cy-#l1<oM1oZ3HIAJ0QOZ6j+Y7c(sjVT%<?4{RGymsFAvsN3HJFsu-|nw
z`+5Pxe9iuk2gjEP_QgD~$}y)|(M_(C$hPpQ#`n#MFF)L0cH#0l38hlc;T+mc7A4ox
zi&#G^{(SP!Smc@|m54i9E79!8d7BaiW~Dlx@N=$ttEI*&t3?m`92O5dELI0NG4Iu{
zqW}06S^6|;oNpPXc8Or^2jmrI(a&=|d&R|kwIh_SSS$#Z9r5${&8J5P&P=`ZWL>bT
zm2t}zS=QT{18axI7bx8qEuMD8lPOq9B=w@@MkV3y60IOB<yKa8wjNwn^!gl6E6<je
zSp00wHONX*T6-2&fm#W;C^zL(uF6u1tSX?)8k>QcPkFmbFBxNtp6EDuU9<&wHx|;?
zc93?BLwhHm>SSd!%-Xz(+2L%^ERx$7N77AWt#?Q^QctS0@<7Y1+_BI!C8CH_mu_Sm
z7ba<1EJ>y3EcszVt~vQD#cP%YNGhb6b$B-KunwOu)tqe3Z6NK9UUoiSEZjvEl*m@u
z#^)$YjP0^RcCu*N#lAhhO4-ZjzH)=VWh|BbY`>S!4hB)DbjzOdN;xQp^+_4JS=2Vr
dHSNEC9$)R@dl}pBWB<c^_8e%CUY!r!{|jUV`F;QZ

diff --git a/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequestOrBuilder.class b/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$ExtensionRequestOrBuilder.class
deleted file mode 100644
index c7078d153debd2507ac75ad4f2af4806817f02d7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 697
zcmbVKJ5K^Z5dKz><0T^C14}~zjawND8^vHGQ8A+S2aM;D^A>majQlkVe}F&AIGl<=
ztSEM7cAojZnUBx6cL0Z|I#?0tDD6o#qR^15`;U@dE!(~djT~uZm2CYwZs<88W3MOP
z+M>6kn~@(3NIOUh6o>AMD+4$5WT!WzzIBiisP)y8^px@f`tIF}9^@q%<9al$7btsV
ze`ei|M|AH75eX#fjkZ8xJ|@trH!hY#Ff-yvAjggGLZ1<~2LcuD`UjzFwI6z%RGdj_
zjx8C1J<j|O)+9Ww%XU?y`*h|93}knax|q=Y$vA<0I}Aym2Cgw=9FzqPmO>{`T^uuI
z*uj>-$x>}=Go&$RbHDTzAIG^emN(7o;<w6YmgH-2kY+<5gKVsG$j5pO1<pudo#hIO
X*kD~^OR%h@GT3CjeO$#(94~zVR_E8c

diff --git a/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$RequestType$1.class b/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$RequestType$1.class
deleted file mode 100644
index 78f78e3f45ec3b10536e5ce88ce09c25585afc12..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1234
zcmb_bTWb?h5dJ2Y-6ma4(rVSF-fCKtC@wyTNJ_DW6a#4$Tk?LgIoWL4oD=sV_R&8e
z{uF&t@xdS9j}m8dfl@?@?ZVlaIm~?DoVon^{o^Nqr+8>0MQG~4we?u4P>R4A+VXwG
zx~ElWj{_ZPyEVUfBj3g{j9w?Vm6>sPJeHNmCNhNLk$5L;Untjp)jN_-WWpd+9X+yL
ztzBPE@p|#VZmUQJO8AwQibowUl6zuIFt$A9McagQwbmtMnz}FZNMq50i3LKT<0-ix
zk9smV6g^)OmO9!IepduuV$Uu!(a;MCt<D8JtU)LZJk{?CKb9|!r{sj)YP)uR_(mSf
zxN71GVdvbrT3A7ekQ?Y=o~6OX<ysM_O{ga+pQ#s|7NKmRnBe6PbR0Nx*GtO1`qxo-
zl=PjM4?I_iC=S^1L+A7?G|tA&bFg&*h27@96<W&ib?7N~Pew!CCs=KzWYF|Q7|PJZ
zJ;KJB3Swe|u=X!k!oqx#35#=;A7i3Mc=BJ(WuOx~#ti$sdoOhu;STpF%_qxSoaV#J
z!B&nnn<cT#*1sYDg_RU6{u`6akGRCTHFdyc6xiaeMT!4O@H3Vvmf7-mEPZC>Wbmg+
z@XFL-7R;`=hU=i>4#V7-!ECZm0%O$6U$J@`hbA}^8mvt?ZsOKN-sX1!8D0tCE}wPQ
b*HOWykz<|;?z3D*74_!{)AW15B8BQ7DqBzw

diff --git a/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$RequestType.class b/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto$RequestType.class
deleted file mode 100644
index 4599b900d15dbfc53dc3f8d6e2017634af94479b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5611
zcmb_fYj+dZ72RXm9$5?^449e#QNRS-5Ic|nA$9>Hk8KrM21_=Gq;-Tm2!T9fq!9rU
z$g3%B9(|L9w54g<qzP?OVuJ022GVz%ztC@8tKa$?y1MVx*fX|O>L%7&S66#<?z!i&
z@0oKy`}fDU0PMtPDk>CoSout=HENgzBb84dZ#B-?{GGMTLhESWvaMEq>OsG8s%RAK
z1LA3e0}^LP4HcCNmYhhPPPOJzW~Nm)iz6zk6>LgdBdr<B%H)iauA{|ct#WzV%JmwB
zLMmejVFh>h>jww)cw$IDoX}(ONMCFy936-!^!}lEq9dUz2uHuLoox!%-(ep;k%+{)
z<1~A&P`}<Ck=FDJBRj$gT1d$acaV%v>$`WZlpY(5^!LSj^;lxa6>OX<*r^}TW1V^|
zoE(b8y88NiJH*xsg5iFhaTyBt^&aSpQH_G73|fS;hlhImItQYRnbxg))oTN>em&gR
z9g7^%I~8o4yW5PI4-Ixi2dG7fC|DdOAMBKA52kWO!$<l+K^b$W6*$h9bO?Dx!F_W#
zEE`vM5$V}<hecD7a~Jp&Y?-^DT(sRaByY>yHRS{EuBuW{H#-OJza;<4S?O^9R29^E
zGvof_XJWIaZRE{VPDZ*nHL9RFTJ9W09JvN@f}&a5pez|)6VGPMlwHgl3aoiAY+r!W
zwVS(FOV03QbUv~G8WmKX7JO5%NRJKlHcTn^x2JPiGi&cw;A?CeR8SeVh7CW|09pBf
zh6k~ornEaEs~V$jZHn9ZteI(xM4AR`D7;gH3cnvU0z9mtMu30-U)B&1V37cOH7pW9
z6CkWX6JW6bT^be(utb1}h9v?l6(Fi%sQ^I%`ZNRuSSCQfhGp=JUkMHOVY3Rl5dOmD
ztzl~b12`<)ZxzaqXt)=fL`WXh@Kt<`A(7E6(CWsfg~*TC<uMJ-*v#q^&6-B6IC9j;
zCsIdq%vo*JN(&n2vjRI0Ychsil9IWLs5r)|?B*wu%Ndzet|Ol*ju@t`pGg~|HeW`5
z9Op3&r_4=uh$=$%aU(?DbGMLnER-@sMf0R-J#K~!J`G7fTLLg}LWJWaPh%MplqfKw
zVGEX%L-z43L$f$;r_v{RmK=jssjH7xb~Q$t7KGG+PGdB0q*Jyrtf0QXXxiBkV=!CD
zGE5z&Y1t{^F>R^y5Z7JPCQ^D@!{a!`<9^J_PsMZjRO#q8N_ARRk1dT&^DYBC!KeNY
z@r9}ywan<CIOv^5A)U{T+E$)N^S>D4$`oYjo3*e_#Rc{ga~Q?6+J=WtPjiQvbQ+%C
ze40|sl9e&D=ZxW*ygH8)A_>oF_&S~^XK24`mV#~bG~HdpoL<DYRD6>pFIVhc$&%A9
z*6;#eBoC%SNZQnLd+C4C&gNR9*@7)8^Rk9-gN#$H{BV{pm__(5zOUkYQ@z`?w1ywx
zhdiECDGm-<??$ul=m{fjGsv&7($2@yS?N)*Vn(pKth{I;1GtPIsd!z%_Rm!ZMIwGY
zzrc58a~_^CGFR}1il5FS@H1Cx_?Za2Mt8&;Sa`wMpKC08*xY=TC+$KMmH;l{7aHCY
zj8tiru*i>JvV{`%&B{Y4TL`hzgjhaUO9^aBvtnMtyBe+vn)s<AVh$T;SQ>|UG?<#t
z<yrtfyf3QoZ&=XERAIh}1NZ>fRgAIwahVoBTd)ll=MQm%^iJjTsk3Qo^eo#UuM&rk
zk+~EVuXqKAyu!}Qe_?{{!=#2$e8jkT_Xy`wg+iOhoas$n*F-*8Y6Eerm`@vmRti>^
zy=JwDMG7u>^ohj_Q+Ug!v&{93rfLz>H1g6nqoCq8EA0O`{H!X%QkVD&mY3ln#bzEW
z6@TQ-qMY(_4X=tnD_C<UY0*2<4yQpT@?2a=@)$3)JyyZqyOs6a$5Dk<d+SA02ykXU
zC}*~Ua%LAOXEuOxX749wwtaGD$0uhtdva!<$GcBGYO$QUSMYZQRub2F@G9ajd2l`P
zY7f4Pc#Q|IC0^&jcN2#^_#Wc*9=w6L!GkwaI~zmV(<tp}B4!K6-?gF>0)neWS4u3r
zY(Xm}@8<>XF~&xG{&f>dvUaP_H-T-}u|uMVDk~-0B~e>dl|=0l?XIqtXpcl4sw&Yw
zi8}p$iFAp&gVn*3Y>&iW397-8^nQtZgZ^MiJ|^*jU`>TwelQsLghu(sup^$V9K)`7
zvT6+N@nrQF_QaFw81}`J{xRtBWRQ<~IPuwjPJ9^SR5ONy@#~1+#6WTahpr<ziASzu
z=mYv&ffT=wFlXRU8O<e(*h;KrR@Pwy?qT%SV=Fe|A;xtNn$X23y^LXk(R-Bt3}YK|
z*bW;z@FaHeUG*^j&X@5&@G}0%f_+r(0^SPJl$Fs&QnHadHq*4XvG^v8WNl^w+1t$@
zBKK>q@JYMsWLAc0m%%&AG2TWD>NzfTYSblcHYE!!xkgz=Qjg*km*@EaC~#C$(B{lE
z%XEunRjVgayv83T|Ah#+MA%x=TUBBU)v*(GtiHur$Q@aImEXW2`3<@M1N^;{qm5$^
zN0_6VV?Re9N1WNa#@unVbL`>R$DwodaO~%ZT~mZbCC^*vFK~`;mM0kbC((}c*ozD3
z#8c?O(}?039Kf^8!gDyxn7fuAaV!@R;Wh6;-_(b`oWWUoTsj%&WI!6EM*w-1oE?uB
zJh^*<Hk5LgadOu%oxAhN+NUP)%<V}$JC1KOkK?6}@SO^Lic79PrA)rUOukCbUSlR-
zWhP(u*xfKYlglXbyt8QwXA$~J?lIfUD;_14j*@!OyE<#{r_16KoWyJ6_=(Rk?&54c
zZ%(@_IP|8oy6CvuM8AH{-QRN9`nF{2INqsv13YdAnZO~6ytB>qc^$n4-sM&MDo@p~
zcuBs>D)}By*82$In#b%W{wr87a#o3o6^m#x@A-}iJv5<`|7gvd*G%BO=CwDFbI<M)
z{tMh7&Bqzp38}SCx~w_D5IhjI&qoIEs_bap!Lub+){P;a-0y3?m24Mfrq_4ZB(80l
z9UNswaK;@S&D=+%B~Yt0Ph#RzNCtb)l)J7HA5*ddHy!@{7M~Drqum#Ai)5*1dv*)I
h<9vnl?>YYgf5Km?#XbBo{<^oG_y5x8Z&J_Y{{VC&vX}q>

diff --git a/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto.class b/server/bin/main/org/opensearch/extensions/proto/ExtensionRequestProto.class
deleted file mode 100644
index 9bfc6458d4dd93a78e64db200ef57c11d880139a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3318
zcmb_eZBrUo6n-v?F0KUWCN^r@m?l&aEktc<5^Nj9)evDZELv^aZdbS=n;~GACDVNC
zxBia)gEpCI(st6xOuzL<b$WI|7J-S0%@@w@-t#=?{apU}_m95-tiTZAW4KzkDvA0b
zuQj+~mF_3_4>moU^;#owXw~g{LOJ?S;NLfS!`^njitsap9~h5}MAfKO68VD%yks+M
znKheRHKVFGY{NE7I<e~>yY8{;F1y~#u9tbEWSNI{-C|hCmg)}^m3qBW<t=Xxn)edx
z9gRlBdrmTF|J(RIlUK{BQi(Sjb*pF`R5?R(pc9+C#x29<<s9i66~4P1+2{k4Pf~Y0
zR|ZmfF*Jyy%Ds2O2Ubf}vu4_#GYHYST?T);Ugjdkj-_9-Ewfe$;2q|hmS(&p4=!HZ
zO}#u#wTXMRiF>e?!ljB7?k$g;l18mo9~2)S@(Fg4MMFyq@e`=x?cQ-Pa##v9YbNzl
zraa*z{7CHYpM272x5{N{x}e<IQM972>=hMN%j8u(o!!xjN<r6(siG2o`J+4|U3!I<
zQY>cFO)bpid1<y^ub^yZT)Ki|C6z9c2`%iCXQj)pP}YuE1vw_o^eZarZl;h|bBbEj
zJGy>(L5lY4t}EM$x~{0{eLbUY<O{i!<3o5zJ|~6K1%-mt)A`(XUL~^duzXe;qa<Vq
zv8U(q>pNK`EK)9mn@X3dz}oq>@!q1j6MHc1R()B-S%&yYb9KBACCC^L;$56)xNtON
zYfZCS?u>y0*s$sk86HLNX1&GG>dfTbH|_knHwBD<VKRsjND@807sUJcfZ<Gq+ul4e
zEJfd#*a?0*h>Q4;VT|b71MjqQgFz-jH`=CcRufsXVJAm%86Sy=Foceu1TlkInqwki
z7>{P!$gTyN6fwsTJE=NeL{8N6K@4G7#K#QR2O&E(dey25Ai>Z*g8?kk_StC<s)PkB
z2k{B6G7PV_7t&hv#3Ff~QVaBT#oVsr|4I-d0+igWS>tN+;Q>Edy>hl*GOD|VWjd?4
zy^llX&i-FFY=hzK0A>jSK6CsH(#Ev!n^dWl?5S=#+QH)%uTWvRm8w=dvqg;Y!SQ!g
z3NFlgoHcEpbar>3MPxmuq76*lU?_FOYg!^JPWNvFaT6(q+1E4TTvJ-TX_dG$#SBwj
zZg^LI+$kSJFjJ$OFI_bn4c-uuWtbk+bY9^pQIhvYLveh!h}dSB8AQ?Fw={13m#hel
zB0g1ZBfWvrrP}*R1Qjm-cIfk#yEHldwVCX-(>W8d&yYHu!LB=$rdg$bYdP-B6BX)f
zhFhm2?e#RWDB@cN^)0crQzGI!hV<z;yTXnvVv#05pntdmrkuq{PgBl<At^c61IZzJ
z8%2=x&d}S>bjnDk{Vx#O7v!+E6%$@SevWfbG4UKzzu|)LJ1+U~649rK{fUMBCx{KT
zwBy>oU%sL}!_rfH`YX}+aE*R%AVeNq!?182BP1mugHho&#z@M-EsP5}M1(A6g*@hk
zZN!B;SQS*P2?bmyyyKiiOgE5pIcbx%-A#~m+#QNN!>VU+*!?JWz)qB(;|o$8ah5?F
zJWuZqnDqjsE+E4i(rw^+8@NKUW%W4}4;*qcJw`_%_z~_R86uKRmxM0jHc7;#0Q^rd
z@e7@`QssIsEW21AeHC!aJ<H%W$t9{_6kEt)k}l#cs3aGV#~qRd;wzHeA^GL-2=+)O
UZcgGW!i5M|z+HSpr+d)<1I*vmkN^Mx

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskId$1.class b/server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskId$1.class
deleted file mode 100644
index ac4a0619266151f9cf2512d9087f67d9d9307815..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2505
zcmc&$U3U{z6y0|^VIYJyDM4wiS};P=&<=$Hg%mU`DNRXJmZfF+IGNn01IbL*%mmR#
zAN?b~;!APqTKevfQum#t5$mi%o_xrhbHC2rXP=LoKmPpXHvo6AZ9o$+J-=moUFinW
z^6djNw1O9b+4a59GoMngHlHXx*Vl8426TbTw%0LRp4V#2{?<ls-z+zR(6{XHiRA~<
z7dW-zxK8*$U@TwQ6VTVZrc7cCXHrPul)yyIab>;NX-NO6)o4qB$(m<d?LEtP)Oawd
zhX+m|uvi-rXh|U5RZxg0bgcHe?{x&e&)4FxD{RfG+wFxrp)ajYDRx)oRY;y3&;3fa
z96I}L%?V|xFd8!AN>*OkvK!J+U|>?<MjWK7`_gJVefDjyz1rK~m;Ufz5?Op;;DW&X
zNW7%*AubYuE5BLoIqjwj)ZP4uF60JBOG!*)#=u7cw?;y7WFUo)@rl5hj`UlyAD|!p
z_W&J%i@cjn;Sw$jq#BB?K`JpDN2QF$GRURyIj#s~0~zkR`z(*(KsL8z5Lhjy|Fd}4
z2kV1e8$DHcbslpD3WObZde>ET$_jD58-f|;Sqep56PUGvlk-vFHYtfSfAYDAmj%@k
zOo5B}+H>orWjdZ&-5x?H74{4)3Y?Ew6G%9!Y6Y&uUjCoD7RbosRV+}9Jse-|0!EYz
zs&ej(R{F!t5)h2{QtYko;7j0U?6DK0$ewc{mRf;xJE3L2*s{7&yEVXmor??OaV8CX
zDNu;p8B3dhjL+`lc1P>HQA)Hew`FcOo=ZDqIti?$Fpdc}xgD?P+j8AeZ%g{E$813z
zW82wrTCNrLd@k?ClKSr_ZDq7*mmZMziHd8ty})r>TQWTGn(QQ1*OmTS+X@27_Wziv
z`+mKXFKXWhX5g@QpRUUw-0*@Bv-Et74?ChSUs#R}j!a5HnV5Tn(?3zskmOe_Lo4Ad
z^;CZY<vEUoVvoDh)OC(B%8VGN*#u|GKjVCTzIg2rQ_p_H;yryzpFhN>hxqJwr61zz
zKf_;<`Fcu!gZZN=C12B!&TGeMSjlO2CnXEG&J_i1L4nfB(6u$3)gB_PRWPlsV@7*~
zg0_L8R>hLGi4x_CR#UsN5&2pkxImb=ft!(AWh~(q-O+I$xB0hcjE*I-jJuqfp~K6#
zN3BRS%P3J>p|wlU{~|!$fG}|1z!wH#Qq4RzkgprKKAA3ay?mS{T%~yx1Y=GywECLr
wTXYkT!m9C?z{5zZU_FwL=z*d;%WsvxX`0Dm6E#dlUT}(YS!{7!r><f1Z`}{mpa1{>

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskId$Builder.class b/server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskId$Builder.class
deleted file mode 100644
index f5716e6de1a6421819e54c1f7f92d92aa831d73f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 9996
zcmcgy349dg75{&mU4~5tNJ7G4Al#U2fG8j+0V+4aaL6fG4V%p*SqQsvcfz5FXhE&E
zwpCh%dbTR{Y7rrzwt`n}ZEL-2@7AlQM-SU-5&C~Kvzys4i3#+l{IYX>@4f$f@BiNS
z%{M-K^pVE^OjNlVd<tj86ZPfsCL@+K!ih*jxfxEbO_nz$;%2;jDbFiw7s>f>`+WHH
z=4fNBk<j2*7!!%FE3c2o>l+PQpr*O5e2x(_5@FM*oo^(Q;d*2FxK^2N3KP0yZehZ)
zr;uF}HD^bS#@f@W6;!2y7K_&!m9@OeuUZpcA1-eU$Lh-$)~qoiW`#mlR352$3O(u#
zbEc7uB%)1bJVDqcrBz<YTgN1ax1Lj#e+DfDk%!(I@)bsQ&IKI>C{&mnjhRLw7H+Ig
znqe~<sit&wYrLzicvoBTuC`-bUF!lns%ubtRYhaQg64HKMq+8WrqPh##3SLx<>5qB
zuAQ3$Q=sM;c2K89B1~62B{Zd-5P2lm%1MTJg@md|#{djen3=NFdH3ri%NZIKDm=r`
zIXD^yDU9x1(j1y+V+e+67^-lV7gIWASI2OSP#DC@YEBp#VM<oUqGmMQ7`@o2Rj4j;
z@pndJIGL<C?uIvGJB33CY&Jxb3KOfk6ogdWQb9MeIBHI1Rh5)3&qfx?bd;d9J4P!Y
z2!(Q;hirzcq_c@~3VTsFVZ_V|TkBZSdK%3&S$EkjPE4CZAkxToCU{Cu&}s4VOdV(7
zEQPV1F9*jh)&NPXLqm5to1!BJx<WxlE1J!E+tkDw?Qh+#3pY2Kl`*!7Sj0#_JH4wO
zRAi$V({;?i*{uHKH8VIh(!{fgYqpL#GEBGbFc-o~k+0M-59hFVMl-p}{I3$h`8pP0
zp~B#pv0+(E$l=i0>H4!aMvNvi8jmR~_NIh0u)>?!9qJT9CX6JbMdEcWy%g=S#0*E)
z&JQ<Py-=K8DzsasFwPsPN0p_rEVNZvq2oNPq-J*%N#n64T?A*VJ733VQOXG}9uqre
zkPyq|XNp3vx<q_kwR<WIt}_z##%$hJSnlmWYp74G{>8_Lj@4kZYUr|0U5i1w=}7(6
ziP3t6s!#IEt4U9*Nt%gp#B{t*D<=QrW`n`zFwnERq@pFvSgWHE3~Z2Pw7^<!u!dQX
zt?P{?W+ED^XU)ZNk%lIP+_ukjB&3qGXmZxNCUcVn)6~%{84ku{Ga9&RF<6Yn*q~!0
zHW40;RWj79wRtl75*?dyDeouk`;$uMop@6##$`IT;&K9|nPsuHvG|6VH92vDIJKQV
z=N`7iFzKzr=X7ktc6Jzxf9?@fbfI^`+@nO#iMpY1jkf_=sMS`+nwm}K#R#wSUN+3y
zXmV0!b6RZFM@f=RRZ-J82{75|ZkN>Xd4=8<1)}lt%7y7C8m?6+Zso>;=ElZFacgmu
z9+Qo0P?nAB@MR5OQW);V>b4&0_zJEkyXbB0(lBd<tf>?oJ9K<is9PvcY?dxIE^3Y@
zjAdrsnKI%=9XAQzf-<5qW=<F{HMdL0*KxB#9_Qes;m(-Cvj2b7D`h^p6}M}+jSbVw
z<I322u9WPzkVw37dUIW!kx0i(#~t_v(Kg36B*IOufGhM(6>4TCI0XcvLJ_XyJsUvV
z5K|z}XiFJ|GEZS|ZgB}#8;^0OSF4yIQ}U#EHQrN2#|~F$ctD}lD^i}eHGC(<Nb3b@
zX+t8uL0$zkJV-`*>6yOCG;GFXV-FtEu}_Gkn{oT5@P}R`j5-Bh4Xb^yryH$W7(m5g
z?$<P16McC!qhs1{Zwfur{Z_P4c4#}D$z?>a9@23bj}vPo-n2>PL>udP_X^uF?Y-`B
z=_BYG76+Sds`H=YspiDyRFaUiZYBwGtfgwoM$fc8$McomHRl3)qFq$xoM(0X2tQWn
z9=2Wphfh=(_Q?j9v*B2%Wtz$*Vt1QJN*8%v$8&grOCxV(?(z0S;KjoZ7G7LzHD}IU
zBRomi){tO(MP@Ey8`ch|oCSb2DacIsnvT!NB6(29<H_=N)+ud4cvJ8Ab;?%n;2qbW
zJU#bp2JNi2+gmD$_rI1k*p&*KKP@n>@VnM*8$V_9F4NmSEz@n%AOuXqkW{=bsR(mV
z#T!s+;o3QRiNd$!{dNMUvW}UZ0i^v^Vp{@>g+J+-iL>SGFVYdVb02R>yg9-5+o)_#
z<+^ql$H?M{4R=YjJ{C5)WukD0C$rmc3zJXqU1MrR*96nslB{{XGR6&0Yum=)^6&4A
zrdKa(liO5YHT;u}s1pM0xXw$bhJW+5w-X}nv}yQ|iR+}0hW{#ryau;!i@LW+HGItO
z_zB~g`BrI-lPgAgNgSVCO>viceCNid!fNj-aguOimb%W**oLz<05rv2Y0nI_;j^Z?
zD-?O*a0Y6M8(^L>b_Qf5L~%RFGiI*A+~=?hgfIT~Nt$__vKJUhb8b9o;&cWxi+=(B
z`ee(A+xtG*kF$>4c;c}P{m}zGIjR@0hVv-@`S&7s505_d;cqv&t45)(b%#&Uk5ab8
zG|K{zvlpl27w4-M3~m+7=TNAz$Wr5>sd3y09BV1jEi*Y7iBm0=+%k03O`%DFkP|w9
zP$+-YevEn08X`D)(iYU2{KW7uRZVI~)oG5Zxm4w&lpZQOfYZHoO+|pZa@5(Du0Hm7
z2NoqU4&$kfA44#~(R!}qZ(jnOxFVFbACqj=q2PW@4z>E;hhc}BK?5@hb{2BgY;OC{
zae?mZ7*d#;PQVz;oOc4|yJY=oSuQ~wXldDlnAVEJPTpcqS+-zDHq4_0t9Pgcv#QEk
zFn1TammNgap)ygGW%0mH=L))X9ycvlB2S&~id%07Qh?4Z!nstqn3CP0jv!Ctl2XZ*
zqGK*fjbg6oQ53IaB$rf$_F>XabPv(=a$;C@oY~a~sxTv1gZ?VwGF#-B4I;m-*+Mbv
zlRY@c?Bz5|3Sp>Nn=-(^WhZjVcs^!7E*KC<T}|GP3x#yH)2ERBQ1x`WfkcU-w^~aC
zjToY07K*{PMh69TJ17Deh-$j;v%<hnYDXyAgFrY{J8;5$C{gHF_Be`n3Q-TExCJ$P
zgt5j7i%jmwCs;&D5~&$|)OuG4`lXHcLj$7JE|F*D=UV1!9di$`8pYf^=5^ZL2!!@9
z*lSu4+lBt2vVFLK#THu0$oRJkt6Pxd^Yy_U7BZf-;NlgMpDiu8Vud_*0Srk~QI{}B
zo9X7IC{kPak>fIMW?hc4>Izh-ZJ4RHW3IZ=1$<r__&fqnQHJd*I4F<bin!D4Kp(}U
zv<094e))BErE4v9c0=(w>LkWja@18E>!;k+(%aOvJZCDgW7IRqc@)>IJb*78%9^?x
zYv|J#C-@8f_wgy5*jc9-#)EXr68`1#Z;GGeCrJ=)$OzVMjF6jOlNKNm3`hibBR5nw
zs?dJ`J9i=ApE_{ov72@yf5GS$+;V7AKqA;baL5UykKJZ7F5{Mmj_v%HqF)VrEz}L{
zc{^BhH=?JyiFLOVebp{ZRySj+x&_nJZKzbYV~M&0%hjE@P~C+FbvM?kd$3;Ji;a}o
ztoC55dXOuvy|_v}#9gO-xQ@r`)qX32Q|;KK6S4!}#GO{mci=AE&1m*S47>3y@~STx
zd=IJZ=Z0Yb_u@X@6ULPyTR%diM-Wo}f`X5rAEVYR4NAjx8t#|lt+O<In@vIXPx&j8
z&JHT)JYiMkm@3vnd>0B>3VY^{YQf$Gq0tQW=smm<Z*4_GWinHTSe1tvmM2&gk25S!
zvM`<^_nzh##%C<ILbhhdEvd=<Oei;Q80Honu&AWrARcyHu-er?4Ucflckw+3;nf@`
zePgin3Jc**<O`sKcx--1CaF<^Z%<o%&lBGZ#P>4sy~MhB5e4cMc8^zy@ihyd-8}}U
z@fA7v3OHRqVc|<R(IOkwlX%KO6(c68=OJY-LWjySh}ou0?Mdl%LVAPYdXq5T;z!W8
zEhzTvHzdt~A$Xc$N%s;dvF{%@4HkviOV~wHMstsDae9YqDzxW~cQ_5c%Le`)1Mt3O
z(XQH516OzkKX6=I@3=O??Hb$G4?A|x?$saCy^k32|I*kIy7w`LsiQ6zN2FaGK^G5X
zy2zb&2SYi7D?KN`q)&c;C$6^R>+W(O;OOJKFfMh3m(c-XOkrqHMo&oR!&YWR#+QeH
zFCV>pz0uoO-~w8h23km<5-o+Fq*G8u1A?!Q)p2q^wgPW0LQ<{SZKDV|z5&Sf4Mc&j
z*ag0iV<S)A!W{6j2oqujWghzJVX$>%dOyqsGMEM##EW=|D)Qt5fS0P5Jyex;q$+nB
zcUWF^RE^-#&PNM=)&>zDIEzzD<mX)#;l7U}GSczAoAmQ5Ix@2jzv!~eYW$M=Gv*~O
zfo-a2oGe=KtBy>r#&1qe{I@43{=1VCulI`A?>lz*jV{aZ%e*7wX3U!%nK=V*cU|NU
zT@{(>N##Fw1Z*a}sNA6lw^zMF_UDewJm*d24rS(edNZpdGjlw>X<vkM_g}5f^A6s%
zj_=`p9#`@InfM$2fe-va{0slFjvwI&j`F263&-SIDI8N--E<7$(a#Adz@^6r-GVBp
da^%SOf;=w9`!iC-_<+X%uY2;jtVevv`yav6*C_x1

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskId.class b/server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskId.class
deleted file mode 100644
index bcf3b1182724d669cf5ecc65dabe1d436d24e047..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 11288
zcmcIq33y!9b^h;YMo$_&$&$Pfc`z6w+tSFkY`j4v43Z_`akUua1!EF18a+v4k7mTo
z6JSVELYozm6iODHW`ow*lmuif3rq+hBx%wlZPV;a+caC#>`9xIK>vH+)y&h(ldN$P
zeV^wo_nve9v)+5p^QWJC{7C>i#cl&WfsLv3NONl3N@lERIyTyDM>EGV&Ex5mooe3C
z`^eBfd0+3`8}JLPi>1bzM^dSggyl>eoEUDt#!6c0sBI1PSeZ<8#5%auK&ilvqS*JP
z+b80QAuBCVow3sKXyTxi&csv61Cb5^u~(pScPg2&qe=T<G%;ZXsEGO#SlZjy(HZF&
z=!$f9cMS9%=xOh~jwF#1jtc=JnHsVpLjwY}-AALhM4J=Q<VbVh;881Pw+JlBqm)!M
zPDxx+EFZJRQt{iZp-3i@jN3#dAIQ9&FgrTC+75K@ABgn!?{Dkf-6_!AU6jt0Ub?UC
zx_$}w!fr3q?u({r49+X>kB=my_C(qe=viQDYmo?ck#|{ZED@)6yQp<T<3R!cZdxn|
zfz>81!78F`RpaG+b*YIJxWK?#YFm`D^;?3d$7;!=!NdztN7Hx5lUDD<*r1i(A013k
zwc74fjGm9u|9sXjw>EexTo`usI)qxJ5<7~eY7OrqVGt$QB-L&z!)5_UyqB3+f@*oU
z&BRia$-5mUmSH(<Wsk-)46?!5=-pf_Sb-IDwLU(c)x1bvQU$5NYJrNRb!$ZBON@5y
zU$ij}BquT!6F+_nGn(NS9kXmkV53*+luoG00#_{-=RDk*+#{CVVP#_J__&>74cOGs
z=*crTCsUuhZz)Fyx(sx(LM<*RO<aRL0*q^Fmy9L`SXu0NY=G1Qxso`bO5%Vji33g<
z92jz;+)xZgfmO58uCeT{xRn@ci^W(nQ?t>3<vdDzM0z2)vO%|r9`p)y%t~6kUc(-M
zT0Hez92^7t1hy~E8+wVE&EFud!+rz(0#|qy#YM?CaR96W7jt!E(VSzhxutxd!4=xO
z6VXhjrQn5kEG`O%tlf<5UbO}ZETfBai%`FvjweT24BWuwB>%O68wD=%GC=!r+j2;Q
zID!|O7{K)crk!$L9<YZmXDLrx!velR7N^yoZp?8ZM!{+B<xwMJV)on7*s-4IxGKg5
zM&=-OR#AbftcsE=d99fzlwCq4_G2az7$f#rYW#RtIyL5C-{$s-hT`o57e6X7C=ei$
z2v=yXWOC0CpX+SCrKycu({bC{pArar*G0Mh4fRdf;}bTeThTGKq69l{i&^6~_aqqu
zw{qX1JQhziNBXiOvicr3aXao%!X50LW8?O5ZYJDX>HSCJ4U*!eCSHcWWYJc@93p`$
z7Yi=p3aMGXT*zLIzcO%_z*?^uDp1kHU*i=5K?Na_w0CTyF&iR#<&r4yDig29Yv_BL
z_dxPkGIeWG<rH1LejZo5r}bMl7pA-MIs^A`58(wUZ@P&LZ0<Z#$_td@8N&ryFqCTu
zv0v>V<zB6yKPnm`a@GD@6ZfN%@ix1!lf%*jZ!+;_yoJPsMz8Dia)?(nco{e%4Sd4H
zTk&@^izZWcbEuT<IO%S@-NfJEUTzgK3QMVV^F%a}ky0Nt@lM<!?fds84&nMB4&y=j
z_-+#^j7#DN2|hJ=l)gyWqjGm#HX6;0O1-5%A29JjsZaH+K6~__Wb&|yHnayZj42cE
z$GwvKR1l|e#=tapoL*j_0%|=pF@wjnu<lfnS?_Py+o;r;;=RPc!Zt3qr!s8?x^!?S
znGZ54+b4#H)xM#q6@aDiBiwI!BfEvWZ|6u7OC=os*}SX3NAWQOPYbN{B6jxCCZ51E
z0*&)Q%~fEXMbvaCYDby6PKM<vCvdYjE6-T%yv^of#OiUKH4@L*>EqojLflvtXCSHQ
zr=%jE7TEtMknW*#jg^m7ps5Iz1g`b2T&`k$K5GB7RQq4J310+v54B!$PO>6&JRki3
zCh>nkfIAMa7<F04b9}z|@lbVZ!;$v$LHK2f@GCr!D0&aZz9a1dFXm`b2#b&KZ%82D
z6lg0}ln3V7$|M)+q-#YlGVx@+{!bI%!hdlWrwZSpxIOAx`UUoRJJu;adRJM1!YdSX
zBZZ4uATA+i3s4?)t^nl?{2ARN?eKkRhyND1qj-gjLbkANYLyo{tVDc_m2^n1LlWE%
zP5ekYY1Q1}Ja5UFKan%3#vyMt)aK%k4Vj-yQ~g39>Mdh7HoP?Tknc4u7cA>Mja$G*
z;4W`41v5SQ%~ywt%W`S|UrF2iTHqdUI7Qi}D5wjYv4*V^-AU@=*_`bd9z?mxElR=J
zvn;p00>3x$EPl()b&j)q{hW#C<?C`gm2G~GHWVkP*bRgWSD)~iqJ+mLl#f~I5xtQs
zSKSVqS_jc5J4q>T?|7VkwG#B3m9+mTU}fyUiE?RnPrsg9Hjn<L%zxrwtM2@G2<$A*
z6<O2rD9tlShcz6XNZ7e1+?HZvi1lA8!45DR0rQ-)bdm`4EjZzP`oi+8=djPFL0zF<
z*|AIK0if%X+U+vx#R^j_6;*7_EIgmezvz6u@9A)jBkLuJWu=MV2!5+*S{RGOK8J1<
z>15{4clOPf#gkN2_4?{}^7!kmmTUjlc+e1Q*hI<gW+I7%H4;s<rAH>l7}VKwk5r=G
z6l(<&b$M*miXF?biDaB^O0YjQk&dwkCOhoat}i>AB!3=;BT0V1QLQg4V~8-@B3=bD
z*KT#UUJbE<t~|$lR=ymyA)49W^`e+Rt=Y5D#l;Yp@dQvDHG^0cg337sidj0RE$B43
z#11xI7Rlbbo6YUB_kba;n5XxV7cPci@Q1uW=!u57lCihI1b4t1;;MN(q`Aq-tTaww
z@T-h-<N6?1)@x<#J*kY1EnF;0_%DDmtc1Z|E*|oO8G@*TiOTGA724%T6OPrP#`V6I
zbNLBH(eMKbuPfyTC3WRTA=0l@V<9wg)`eKbHy82Em86q@%g;g_K7)%-Va-|8^KRWK
ztbc?9J~Z;TitymuilDCr%Y3~Es}VWMFFO2nm~T)l6PzoVt_U}s!NzcH^J#1em!HPg
zu<tasOP(c)=L)I|svcl(y@GA2YP^)dFH^i%I2^E3sX$)199IzX3rS(}>bz;;okTFJ
z%wc6jAQV1>)_lRvb55m|C?%V%@Kbz{;+IhTGHjzN+Z6;yOh`lU(^9*%%~~l`Dp;m%
z_Au`qGnFc6EiM(xvMQ9}DqPL+I<R}BIn}HAfPV_R^SNA|HL@QO?9~))TE&Vf{6(#(
z?VHB6Il@{h19Wl99tP1hRIAISN`;2PjXAE@?CvLUNwX&WD7JJreH4cuKv~mMIQ%ew
zj`VDp#*2Ex8|lD}Qi|iZH7d;Z({Bgpi-Qcq!}Qzr^wA9nvH83jH!7)NhqIO%pqFl<
zkD11#ieiwGLqr+F5cyi<&Y*u5H3s`?0;7m)gs<j2`R#bM3t_E9ID?}-;SGegL1E3u
zH%xpZlysCb<4lcFI`<fjpP<yF!nfMto5dH>_?8h>QsK*@3OT6QJJhI}iAqLcfT*^9
zfH!Xc-|jMcK(nvG%}8tFqns_{r;fziTSNYLBH*74oj{;uGVEuH_$N8&&XGH*%gd?D
zU8rR@`2xH`32<_xE{lH|MJ%TXiJJcr;aQj>z(@9bDQ$u;{d~GbrRbf!mk2gVqt4*A
z6EK_n&izZIM&<WEz&A>{Y1|o}#w(kq@!DMKI=OQ<1MD7}_VuhMZ@^mIi;cL?1#Odt
zMme1G1`Umpm)7u}y<7gu8Z@QR?4juUT0_2fAP|}?Y0YA*3TbR_yh*-P=&C{r-3%VM
zsWl`4PUCGH4V}h)p`7_Pv9JJdqWRuT^F6>ac7mVC--=7|Hf+G#iT54E_%3GTgG`l&
zT-f(y&AOX&Wc_u5p+uT>#Zo@A!>sXtiuh%SMw-GWr7M|6;snZN`FqzSLsj$;;6u!%
zho<olj+>`(lFuh;X6bao=Mz<Uj~aFPe+NYa@1X+krBB~a1tuBCA7mUq%zS!;b##hK
zoMIK7V%a)H(2p|jPb)>7_>N?q5Frnle|6Z5_c4lmN+lBk!+aLY42a4l9A!gWtMv?(
zl0kBaHlJi!keA8o#@6bkq0t$9Xc~{))LOkZH0tMNduUYZIE_=zyFm8c$r(J#hgE6<
zReap>(xl5vj*^d4!L#(zhgpfAWRiXaYw#4B*_Yjcr&;(v#`^m-cH<fB!^c^AKH>7#
zA+6*R7QVAtZ*fI6xr{zRmbnCYQia@3zLEJ`IfeD%$MBSoqC~EcI(7UrN`kWvR8r<A
zNFdpLvVdK?HdU2m*Yp_vvBZnt=Us@aG(Wkt{u4e!Fp~3U3pnQi{hTMzFXsUr)Ik5W
zfL%V&&wB#>W*$(<Z!XX;7I4l3`Xx`G-^v5}RSooO1?=*He%%x3_w#^Cesh8TyNk0^
z`>x;{>3Xi9>%%knk2#JHauDoZ1@S`{)CznX-{E`dqVE<k?9k3PmGfutJr9n*WFh*6
z3#_R*%H7PY`+tCQg8d&4*1sXxUweZ6!6Lx^*n{Kq1pC}Mz&?SW78oMWvOg<i%>^ka
z{CQx1sV)1z1q|~o`+puBO;m`AJg|~u&ay(DDRoWT#H)0^e+IwHOLtN2!sXWmrCc_c
zH0^pt$+dL~Yo_sseDYdFF2jdJl;Nyx+o_a}Hc1qo7WrjHEO*JRpmpS?UC0iWW^tot
zu_{c#CsBD8eTUD8z`IeU?`D}gTL!gN7j-biN?gdR+^Rb@Y?W3@ZxCws8tg>*<w;#j
z>R}|yg{(p{ZaO23o((xIRceUUC>NI~p3d?zyQw6R2+|R<j`?so3$KqeD@B!N?b_+C
z$?;Tm*0(cfIkALp(8mc;qe``la(zDKwOL9bY6~c{&SqlfQyz5LW!Bk3Hc&KP7i|IF
zBZaipZKPeMY1i^9eIB4=mgfoPfId4Zk_(C>>7cV-ph?!zPBPj`!%fqoZUHf*33-UQ
zaAA^*iY0m8OG-hSkZV?dJTE+?EJRW!E@lK~7jtomijbVWXT+ts1D>;pXXT+ptfRSn
zV!deK^#%rPqi7Nv`9CH%acr}{Tx{WWYpKcqCRHM~@%?sQcQT1C7cUf>OUp&8*d?#j
ep+j8FeN;X9$iF^zi#GE)!1ryO*Uoo7bo@WBWKL=T

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskIdOrBuilder.class b/server/bin/main/org/opensearch/tasks/proto/TaskIdProto$TaskIdOrBuilder.class
deleted file mode 100644
index f7c79582456b3f3365b096733baa8e559073dbaa..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 429
zcma)2K~BRk5FEF(X+miW^aZFw?FHZ9z^zD#AZU@w2i#;aDIu<G2Z^t7-~l`ev1z4%
z5C;zSj=Vdw<N5e}dk1iaVSt9fsj*s`H5HDOO&+CJ?#aouHQva3#&LRA;n5b)?X=AD
zlx%<<fx$|>D4DB5%lUFei4V{g7$xReYGZUxTb*V3AaBVzrK#o%gqr-!q!gzD!|~+i
zTWjHMR_JqqUOh5>_2dMOc<wLts$H{M%&J72<H@x^v@oSj=rYTR4gdJjNwrX*8y5xH
zi(ENJF2KIP@&6JL=>N(@pfe-quZ;5?0~_Ge;;5S(Re%nv$U;P$x{Ger!5-fY^w8%T
P@jQFPK|93Z=6&!5QxbG#

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskIdProto.class b/server/bin/main/org/opensearch/tasks/proto/TaskIdProto.class
deleted file mode 100644
index f8bd0a36dbcd6d9ab5cfc57f139241fcf3b8c59c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2532
zcmb7Fe^=X77=CX0BW)U5?8GtDZO%GMVa*tBxD}@q#;kNODMJxGJ!yMaGDE^i0uJ@d
z_ziTNv!OfN@oztr$M+^(Q=~`eKY8!Xz0dRhe(&G^{P`NdEWVc^F<iBswr1~g%jLS$
z+}1qZ{lV3C9ow_Dby`<i55-zWlwtUZzOQShZnd@5#uMK380HMi<Bp}9b=T89qgf}q
zdPrCI>FPdRJ)o<%xZ8A$UC(wHrm9VQM{C=5+vI`L#@=IXv3tYKh3gW-;^5jI8{BNo
zH=EpbZD(C?n4F>1SL=OlaYy%f>jB->+k9gtw{!wbMku`wT<=R28toE?$-_P26LU?|
zung}mLnJ@3!4O@rTU<uwSb%GuV_5A3-ePc+^Fda6@=^3dnjNEX7sGHD{d>XLm7Ed}
z0NJz>w@5{$HOeltd@`#jlF=HKXdNjJl~X;mjkwP{BjX%H@wD6=cTGVSBP!m(d4`K`
z5>?(a%vLwD0<h%RI}H2zt!h|JfwQHpL4!FlC?E-j3o4RO6k5Hj;yt|2Fx2K=m?DN7
z`GJXr^Osay#s>@;qU+Sq`oS)D8L~v^d%NcurdBmvuav@v_((>MA$|Nr#Z`<`X%Gp+
zNWRiR_H<oI#sov*wCsc)39lzr#1NNpjp24bWH(3uSN#cS4Dl7emJ*m|kSZ+&Q<zcl
zF>cZkjRU{1%lT6?6PibPKT!%38^Y*W6*3YO(W+tbmA#z?f78O*s@>Gh4c#$BOLzJ@
z-RcgGMcvaG&h=qd5W%OyUX?n}+cqdY`Rdt*AT{rZ!`qZT?#!F!y{8_HO~bZ`qS)Wz
z?v*tk<{VTFkC#N#CjuhpfKt;pR{f!r_cLlDEuzMkRD6zkhVip05%aBP?>S8_dX*+p
z&u}P;EHS7Riw5O_sk<(BWmFk1^(&|_zZ4!N+)=?FpBpkB(lgYL;$%%yE1jIlGHMLh
z&X&Sl;188*u#iEyxHS-V)$xZKr{^mZko5dXt#Fr`UsNi^=354BAnx3>jPDq34hHJj
zgK5flgx>ZD#zeEzYE1MGNkxo2k}=w)pwhh|+WktWjO0S}71EoL>~L+l5P5~{5#Bz;
z=n=-A<6`6wT#@h>@`otA#MI_96k@^cVr?^;y<U5P8;7{{JJCq^guZu>rsWRel7%Em
zMRJjnJY+~_B?lwYkH|^;7?%z(DgA_^^fTt9rzlIm;5OlfaSAcrLCNQ&M(voZkrd{}
z3NJ7hDvbL-<t|uwc^9A2#iS_x4tSFG0?hskRC<66Wh``niyh!B$w2E7?uFpAAL$Go
zr4hw&4@rzj?)xP4xO7NzJ_QhchSA^XEC`ivxwP$LCHfn|7yelVUy>}4A9*a}0WQ$v
jvWyjyQ&`1UB-e;<o#Z2uU&oX9hVCn5#~L=Vg-8DaHG;#z

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$1.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$1.class
deleted file mode 100644
index 55ce49580f29e228ece1780fff9a6584ce16118c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2758
zcmd5;-*XdH6#i~|!$JscQ-ab`wP1v#p<N0UD=BDNQz%VRhC&%1Z#K8-(#>vW?+v1V
zi8H?F_ycu(z?b6448HqEspoFfsO?Uj&g8*|-Fxo2_n!UEcg{U$fB)mxR{-9_nuP&|
zau7D{pe=nRMd)nVTBvPhx5GdO_5+gdOBHlNN3Lt3)jgxm9#CgzEpUblPSCQOLD2N%
zu7P@I(=OGO4uzxdiBQRq;n;%fyZRQxU@pJGz?XuCOkxlxQb^z!!*Ip*Wv$by%kY7y
zdy-+a5;(%!5TR@4T_x9Bu41@d=?nZK!${izB$V0}-f|eU7(UNc;yf~l8!LXhqt|sP
zMXMOQtNc_Gr*7cimra)___X3`S<LqXFQHAApE|Ow$-J^K%5XIf=!*YDcy1#KniF`7
zoy|=d_6{bI!D|-IFf8?f!xUb}S;FPZPZm3_*D#@8%k{<GY}a5hiE&I=ILENs2gG}3
zQ+NY!GMs41uqk%~|K<NQ@OzLWCMHujj|&W`y5YN<xO5}>LppsTjcf|<;37jtN&V2@
zq>HPzWTPsT5>2|8kK$?Su6OhO=!r?6&SA<zo?$lb^h4iN5W1!AXFV{ztWKeT%M6o3
z9iIIR*NLb&^M{{{c$qP^%4Rs5t2`D@gzX0Q%32RXF~4D9mf>{F8biW0m4o48?8gt(
z7KXIkUr87Wv4`VJ4uchCh`Eu~ew3eH7BVo(g1J~M|G^@|wb)~a#+K^dnOMRZPEmVu
zwyUBYwFe8-U$Sw*-OsOu4;k`tJ7dXYknuUc-|o?RLX;?;@SFBp{jqd3B^g!a6oxQN
zC3QXOzss)ah35|R-l)3I7z<Rx*4?HrbSI>p+p+xqyBja`BOQvjC@#Zg-|+(F`pv4;
zTS0@$(u(iPaLE%&N$OFnbeWG_v?=)y_)F>BYcR)aQt3N^(wHQ|2I;Q`(VKoGXl~KW
zrjgN@n0kTZKa((kB)!ct_!l@ya%y)2ji+eF4C%CMgk(;$v@yem$ZUc%rC)HmHeI;9
zgRw`?FnfcK@#!7BwS%{RGx82D{XKn&^v7fT1*Z2@W_(VDIDK}A44ZMBN}U<=xI!xi
z+Kd6kzXIo9<0StEBm7&8^Y1XhpCQk`M}hx<IsPMxG%oO;%x>I?d@XfdAegv{Ymr+e
z%;8;fhvO!$(?8!JIhMpc-Y3ljIXsUWBozqFJc=YOkhSyRe-c1$fmyg|;RB0cl9*n#
zkgHj^GCESC_0oQpaEZ*DAXrm|p~dGU{)2A9W3Ud;lfXxjRK{{N-X;$W-5GkX&@)bE
XGPsKh#v(6BMY;^CG_R37fV+PIi*iJY

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$Builder.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$Builder.class
deleted file mode 100644
index a48f77690417aecfe3c163ed5637b55f5a34a616..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 14366
zcmcgy349dSdH+AnNF#}n5E2N4IAm@lfiMsZ$Q<I9In5btW3j9Tv9Q{ecSjsPh?`*7
zPU6OO96Mk)PV2__YKsY$z%&6|r*7=nNsshS+9Yn$=4_K*afqG&H#56CyBaAXUL*aa
z*?sfgcmBWceeauj?VXpt2;e$p8z@j%8&7mJ#k;In(h4QQ`<m=f@<6hwD-pNjO<VbS
zvz3f@C&JbiJ7gy}$?&8;!;_YEN22Xk!ho(YGaT=1>WIfXqLxc$Pxs!Y)mF?(glwyQ
zy_HOcI;`z;GHZ$y*5yHnjR{W*h0;9{dsW1Ww$Ex)P^}8(2~Ue{!kmNS)&)tqKGfwb
zYgQ=P66uJA?Cyl6aQ}dluV1%6bTHHu4aGW|w%CbCtfM&}>SS5j5xaRY<tpp2>=jlr
zoQQPU@dT|sZF-<|nK{Wxna?DkFORodB^ZV(1C<KbUa{p(495tC)sdKOC1RmyTaw6#
zgxg4{ErX*r2S;rVj@tSFrmfwlLgSSwFmzocW^L&1++!uShW141pUQRda45Pxl!(Z8
zZ?GyQ-)hTF`BmYXX|2KbN=<1lg+i@~F&L{b%10v=2aYQg>iV&JnvQ|-3Zpa7*xVhn
zBc0aD!(pq-j>KaIu2C47x$i>9gK#k>a&c?yU?>`Cuj>qT)$J8H*To#Q7uJ=c4wFqx
z!BmB!>m#v<y;xzyw7y83zFnqHH&KrUP7QT2(AyQph#C6fO$*dvhKZSIQYg0Lu3!qo
zsd4TS&K-xz1eLunl2llq7vOs~AXbZ9eTjNzpYQ?N)^qM?pJUc{+v4_=;l+Q~nV2vB
z8{c<YjvL4NW;mhW5)Ly%#Z%B))Q_73@>$>I%@StUn^**TXJd-fZxk<%`*UP#4vd?@
zNoHWF!tyJQ{j8)!pV-M#EW-)|%M}&`Wz<1QV`3#%(OcYum~XS}m~17sBaDLEEyA|V
zkMQNuP%_!<gQPnU9NvSHgNW0nNyKPqmEc-UrKSzm$R27pg%VcGZg#1x6Dl_l$6d~-
z!o1&%nnGbX%I%pbA|CVLwbbUz_|>r4#71mUm_2x`r$V%Z!M4qWf#Oo^z)k}nWNrz<
zK`J_h70o(4YZqI^a68h)L|)?z?+tZF?bcY*4#mP&`rhjNXikln;8qiDxP==>Uw$<8
z9w}xdjqEWImT9IlLeB~kWxZu$FFKf(BH8#PdTx@15fl4yfSW|jI<ze&>Dhy@SN)_n
z0fo)M0P`j`2cvmFnvyqJ?$Cw`EAs&s$7FGVa+kuKV0i=LD}@mW1%-r(Bq&jt-<Go!
z)=bNbh%S?ZCJqU_jCf4A+a>hX5fddS6?ooZ;!e3+))_irwRU#8`-Z~My@_~do4;f%
z>9i6Z)+!DwM1vL1I4Hm2sPJ1Rj^e`#59i4;`LJ(RzBncV-ov8(*I6bg5wz?{+KEuu
z_UxA?%(#o&`z)rov4J@<Wp4?;TJh#bMT(C}MHf6jRmux8mf!&szk^RGR50SV#SX;c
zhhok?!=hzsKWWcDZHr|y3KV|V#6$Qb6Ndv3{|pkcgC+6L5<2-#;0m8I@rVGsBpzG7
zkH-+%DnA=6j1>Rvt+B3dn`NC9>I|+SRvxyw7qdv+Y;{EFuOsUswv}hWc}h#C!K8r`
z3RO;Z8HqQwZcN`X@Hh`^nX+?3cQm>w?vzsLIi+|Et)+MZzi;5P3X_6hm#eplKfser
z6tqG6)(}%UQ+I0#K8KSAo>B<sBdD`V%@vljt*wmFnrq^6ST^xAp5f-w?z=O<!PHqv
z5I%=LGVpx=+pIIs#2@2NT(ooBN?M8ZHae~!w7b(t{|UTc;xs<5Fhq>w#ht?bU_g26
z0%Nd07zH`V<KqBL!uv%NJ?Le!X251De1&0@-+@E79f>xvtZ+<n&csVN&yA0>*IGw%
z4=Wq@?6<;pvw<(rCK)ifCmS*81rrx#eKFT>4@J8z1240($p;GjXJ6;+I0UcY&kcNu
zx@9S1;#K?wfymfYnD4K2J@I{|t~cU8ka<H=(7k5jb$o@k>Js1k^AB|jc4KaQTuEMN
zm7?cOe9gdDSwsdo*E`5M-J@_kx~zNeUMrD~UlV_czoN9=u|tVamoNBvK2CW%J1eln
zDU3)GQ<xHnygurXyp@~O6dD2-2g8<!-1c~kMXI`qPO>Fu3}u<+^v2w-lJuH*e{LYr
zflWY#s<WFItcSg`?)`!Eh<qo~uV(kjz`rU?4{~sz$qalumDHW)*w%fC_#wAr^Ra%i
zQ0ka)HMNp6%n?aB-!<_){5!+a>g=+Qq(o6z92_z!5A;)`r`9t+?ZEd<{6I(#;ejA^
zL&kq(;>U83D2XJ!BqyW)Y2v@6eW8crUCd=8n3S^ilI3ysl4Rn4oA@6|l9KjFRx-=~
znfQO%+4Llj%v>9e$Lvrfmdqm1Pp{~vVqE5)*vWR&0gEPi43mZAyC#9HD13^RlVP*E
zO{sh&p~0onlFLoAgt!!6IdYV)u(}dfSUSTBcc!8}mD{f-40!tVT6EhZ$p{-tEwNZ!
zI-BtrYrATnJ{gheTct`(HAI|Hm8%^+;vQ+Ubl#ZoN&$tJ{Yl>4jNY%-aej)<K6_a+
z@u7yAszME;=V<^YWWQ1=T==Z#4P^=+XTMe0k(YByUkND}0nKFX%8-H<;dp!Y$kheg
z$Xv8+OgQ;b;eg+O9xC21_Ze!m!h}qywnn2?M=08o=;-dWVs?6qE>$()W0Xp#3zY?D
zNf0{;{)E*TKWJs$QV6|os-&6=g1>7_H9_#lu7}9Ls)4rk(rJ!B6|5O@hRz1a_&z}~
zKVD3!UaY2a<B(*{rv%+pyU@E<QOTBQG)K={Jw4L_kY8yOzMRA0YQ|H3brDd_Fx5=O
z2OveRF^T;g_1NO&UB~3yA1abLeFfIxYL2O{Rdbozf(r<LVeU2tf=a6aI%_Ody0d#3
zlLKqTTt*_>e0DNKwu${!V(xQV?>wedvx%Ff7dn36`An<*w1sko2<~k5Z42EUY`i`d
zexT-ob!k5ZTYsG?+2fZ=v*}T(Py*THUl`wU*w-REe3jYzSRcDutaIET08EP^u2?Cq
z_>jViV1Yct_2c7QcnQHZ@=RhA4}$|EJ4=xMyM{p=_!ww6ZV_G^m=UCZSh~eIH?E4v
z<Lg>~(c(N*a}LTgWm{HwBM@=@XNBwYvU#O8nZ<c2NYk%oFg=*9F}@1oJgc*khT2NQ
z2c^9n7^EOzC}!P>gIK_GjHiR4Sf4ZvVu|0whPs(P9^@iJ?NX=@nw)v_!v7YAq1Y-I
z|7+$GB$?HQ+QZ5^XhmNj7>Y-!xr3XVGAp}yEcdvdcs5IYugrQF>og<`wXYu!<Urq0
z`-$x!IlPI6iuPk;Z$h?1V*S|6H<?|YKC#4AS(Q-VMr_V1?*)(1eJG_-%s$};D`~HZ
zCv9BI?t#X?LKN_q4?_8BRe?Nl;@A-9vx(WLK^e+9GL$2ec$FXhG%8N<T7YW)FOpGh
zA4WPOyo*s><*xXULmjxb_F3Kq@4%rUbgJrmF#6PajN5r0bvr93^kPzN52p2?u@|#0
zaDwKLuO<m-F$~wbP@^R<R!d?AufndHB9J(LXY(qb=1>h{h@W*74A=Sp1A`W3-e83}
zLSgQpFn3XyqZH<@K?}103q8xUIJO6doJMoyl1kNsmW)X&DL1rZ(6oDDX!oF$pG9BO
zG2ReQ-vW8i?~$9ss~EMgz87m=;0M<?rD7oMqtLaF`v?^J2;ATiSj?GX%%b{+UaZZf
z@E{7chkRNVrA=Oh_1NGr=T_v=Y9%Gt!@an1N4@qUw$j)0da%7dSI1A0@FUdkQ4G^Q
z?Gv%eW1w(T8h$e!Ho@@wjBl-;Udy`A6Dhs+EOupNaH0ET;9Bl`-r5kaVj2N#Xk9}O
z+E1Xk;VkxDXb@5^OkI~fO?94usXa?|p7+@+rA{H0iK3GP1)_xNWehX;kdM!8((EFn
zDC}y_W64gsGq$e&47MIeaXnezMj5*Muzdj~+G&i?K2K1d@v*J-EK!2WT(%>GZGk-5
z_O$HgH%-_Iw?$+0qsLL%AR+o94mX^^;U3&BsPG5nS!#O@L$sGrrJcuU?F$a;I+siu
zA+;XsLWb*I)VaXXou<DG9^sYLM4kvC-V@D7HC)1y<1p(RE@DX!?mi`${KyUmJbr6m
zVsN~S3hfnCYhUuIJu1z66z;`ule$=&xvs)t_hFCSy&MvDGw91*Pcd{(2})_?`+9JH
z{Z5)ezgwWok&pM_!5zH&uup~w)CJmWH2v!+)4oEFzs|hy2F7V`VygC4G-zM*$uuJ^
z(+tX#LI7owH?8<eh9^@auM#>1`t$PNmteo{5OXs?fk#Y?_b6w5nsaroJ1%LOsYGWw
z2Oe*H6+_PBv7Np6y$jmnlSojL&&<<D=+E&k7+J!>{i)@plz(+P=iSh78h_Y>XB&HP
z>LQ+7SSWVs!I_%E9-O_1Kb7kjFXGZU{F#Ow8B3i+MSVl#2)!3yK7m4g@z~?<K6nz9
z8)o$2jSCBl#C|nJ7d$f-Fq<8tbKd0j0se{xvYqV5XqxpKOj+M#Abktv+P7)i?_i|%
z7UpW-#XRkMSfG6$3$-7hh1XW?huEb32)lXRtNj>V+E0+weu|^o&u}-_9@Bn~`?R<5
zfc6V~Lc5GlYQMxIyq?hBaV)yVwN=_ZkK?cLH;xY;$Jg<<v`{$?;_vYHM9WA-@DFsm
zj#j>w_>Xvod((aV`zQP}?|y^Qi+|jE-{iQ!ZW>C=%Y3`|GA1Z}!P_w3<&LQtPzIhb
z@Go+GbEScANnr5RP5yT`-|skE?q<?+Q|TGJ^(so~n6vn|Q;gBKa&nJe1Vb-IscxWL
zFZF>Xm3zDxC?^NLVwl6{0SOOEyFe(vin4l#(SN*%w`8CPKRki*diUc`WH1vQ5)@g|
zOkoWHy`0hvMX_FiA-oRLD^aUgVTwKiv-E1r)kpdyT;LgBB;>X|Y&b>vDW2qisXDIX
zRYWTza7OpwXXo(03OUiCkM@x(OGn4g@wP`~mlx|}8mOGaMCC7f@k_y?kZd@IcM2Su
zZhCRHO??6lInkl())`~c7#X7ql-Mh6Ql)hC(#b4U_~STG716U!b)=-S5>1*sO&CwA
zBxe`W8+;n1HfSaN`IM(rkwav*N2J)3J(tdGAD!ZqC6uYkJWD)HOR%~?Q=la_%y4aS
z92NYe$_w~(`O-<~jl#waP-myp7tuINFhXC9YJI80vfd?|Hd2#kB(hSKs)}k<qecx^
zBYdIaj#P6*Oj!o4{4&NFcx9=9OFVRrRHHnppW+nRo#q5ey}r?v`ULZxs@d7AYA<la
zlRhK)Xht6NHI)1YO5RGz*D~R)!!&(^qk+3~%}Hx8$J3yikF-SYf^>+xBLWMNy95Q4
zyM}U8<}v9qXd@*S;MO?NQt{5wbRBf&oZ>^W++s+-k+HHFmHHNp)VKQFSd(_+I5plg
zNC$~a@*da6Ad;!6d|d%kv*_;IG4-3N`z_Rc7slwfIviYRk4x)3t}nDF4g%UsJzXoa
zGJ}Yc!KWKldzqp-e9Bd(m7Am{d&)gbYU1tr*~)Q0E0@@<Qd7L(b#!ga-G_W?yDpDY
z?JkVfZ^I-#fkr)vdAjX$`TVr{^V6W6uckSm^^#IK4?$|Ws;AN2@NRIT@c`u%H`Fj1
zJ;OH^z-NS958T1Lcqhtqo*DF`J`bdPOj2qVv8K{kb4RK<GE7=9o{1KbtuQWOZKP&j
zgv!|2scQ9)_=uOJ^(#>yQ1gV8ybTsa>bd|@_YXv>q6Igr1s*AJpg>+S+`=4*c*8p)
zI!ms<(j{#AdP}Bwy7R2Ux@;ge52;00yymEqvrtw^g{dAO4c0e3YRNz>kE)jUwtU%p
zTfY1~Eyq0p_EIYbR(RDFui;zU-Woq*Ru9BxqiVhKC8^Wxpt<Z0g!0;f1lz5GpghnL
zdA1T{vh@S7;hG>QtAW-a9Hb3G1F+$e0Br_X!lGv*1HM3Q^77)1YBRs@N1589wy7O@
ziTWVlJCf@y>Q=Rz-55=UobO>?ts)c4c-_mi*P$Y6M^TA7pgQHs^XV`Z=X`}FY6q{M
Y<F$*Y10D|5ZTw!y`w7lZ3V#gy70>7)Z~y=R

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$ResourceUsageDefaultEntryHolder.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$ResourceUsageDefaultEntryHolder.class
deleted file mode 100644
index 6d490a17634ffd44a6b360127ec6b104bfcc285d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1971
zcmcIlTT|0O6#g~^(w1-)l$)SfwICAlt_20T&lFS&IQr5F=~4nAshh11Kf#|PKFIjs
zlTZFA$CKsKA{iM*>`c0soOAZu^PTVH=dW+y0X)K_4voR~MbY$2+zYrR><v>|!B$|F
zgfD$_ndVD8@XNyHIcdq@Rk)oxv7I_JS_!NopW^FQ*_G3t6gzXiTi`-R4MX#$^}#Y-
z%PX2M*EYE=8H_@eDMN48_P5QV?-yOZk6^95ZZ23Q6)MA!$T>yNl4ZdeKK<2rG+Q|>
zCxzn`GuiXFX!X_AWi!tRSA5iV9nX=^7-H#xRfd{LzrYh{K$DI}hLJNLZJ-$~4DTFI
za^YESKA`kFcAf&|D`e#rS$RcPz8ab$D}Rg?mBW022exoZ(iaRvkr|vivItU@c_x7i
zXxGukkd7khjU)JsFSae2nsK;WSl%gd0~c|Lp)R+)G`~2@Fc^7WlxHT6P6mW$b{psk
zqv#9Mx!lC;bP~O|qN9&t<;+QqDBS9#DLxHcML$Dpk;{WRp7$vCo=qk9Ha+m4iYSQ`
zZs@qq&=Zy2LkSqTi8O)p_{S6AexxJQTcPk6osqVYR8$FRU$&Wl@g0bCKD-}Q8I_5F
zTGTN#WgU+%mbcfqShm(&%71Itw=H+o5>B{2*sL2>%1a^!)4**cNqus|2^jdfkabK%
zCtDk-Kbcbva>fZUc2`%FlA-FE!(lt3hBxndTui!F5b!|9L%MAg-_fM$c+Ajuiao)p
zc<Uf|y-^+&s;R3UDOLw{u*q}K6+_F3JP`I%a`}gs(jzt3MIOjGKajXX)e)ml7ehx_
zA~fo>(hyfq0!iAbr=8dIHvF~k!q`P?YsW6S_HcO**S=ujGriDoi~jq`5n2f`?LF!=
zfw&f+UXy6le6(oWXruX%vJO3{vJS$VG*Wj$?ci4oSHgvOplvA^W8Z)fkC0&ucU72s
rxKHCCp?g4|-zVs#{`M53;|Yw>r{X!S8O_GgMLli|6SRJz{2G1(AqQmi

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsage$1.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsage$1.class
deleted file mode 100644
index d24815257884bb9879fbd4e7482064beac268f54..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3039
zcmdT`|5F=96#wjT>9y$<2&GymT8gnvNa0G06&qR&7;H)sC;>YC!ErX1C0u*C%iL{h
zb;iHP8Gow&KpmaY-~FSkZ;uddxWQq@{9tBs@9o>&x9@%4m)$@9{N*<QA7jga#_+@s
znwH-dUMP5A?^}|G&qJ#n_|mtwiQf{T-wA9{lU#<IN}N6>eoL|w@}@{H7|<DJY`<kS
zeZT37LzVT;o>i!aGT^q{<UuF`hBM2K=g0>PLz(O@gTCrFL=r<dXCi?!3?pU76V*<u
zE`n`dcLl>(*|)j7%L7M^yFy*=J0Zi<@_-!5GmN&C$z->5xVskkEruU5<v1Ue4~>%7
z?#P-91aIYIR~27M!rk$`EzxuclyAz86#496JRtj%#h12dOFA$#Fvf5@&h(P^g1b&5
z3bpOKE1kVP5%e}DF^+c(Tw>T62+k(n#bvV86JM`%9Jiqogl7f>NxFMPK8Z<88Mwmm
z<v_eTI>^L(c%R{1O9V}Em_R@MZxZOpi3qJ}6W1`qVAfTXx+Ou?H>gn2p(&(Ie2D7|
z<Drl{-X67$a9=bkB2+DhT3I}l-T7{9oj&F1=nQ5JWEmFXcJFwqe^EzpzU>*)s}~bF
z++>*M;mLKyaF?KqQ-AWl2$y-)DJ_P}nesFKf?JMnl{R`N<g>d578owZ%rPV!)ukA&
z#~yyHk1?b~f7fEj#cqyoZwyA1Gpe$`8ceI}Whw)syjYC2?q6_axD&hW#As8Gy%ZY)
zh6{9o+RrPz9bH!j=)OzGg}Wbd1D`Qu<5tGP%OK*bpkMFlZlox6T<$fkjrucTOG-P2
zRTIM)p=Mo+UI=TBx|^>YdmThK$-L4)ov-FJJuW)|t^6()-?v`}%Y#Xf`~!;ANYS%h
zKXkliMaX@>LCvh>c_LVKc^C@1A=k;p|KK_>P@&FoYDH9O$Dr(!MNciNr`}C@wkksT
z&<`c1DLzB=%tQ30cNC2c8d*dc(ZuX)oc)m)4N3Z{X=p{9C*C|<K=cBQn2Is28YNz*
zQA(*{!=yGrlETlpSe?t=Jix@0@3C-CpU~$HaP<Hm{I2)|-1vL=D^gD<^w*d>5-IwM
z6zO#AFez4al6tM8S=^!-W!k(lN?V7nRd8ObVpQ9}q_&AE?J=_27IIn*i`q8wM3=Q)
zwHgm2UkhCq$V}YEoye^M7V#0eqvJmA(j$0?97|#epO9pV9A3gb;&Noo67s|?leTNn
z-;ja20cPO7flm!Gli1X{flSrFt+CMp%@_Jn!VOZdf?&)lgjQY=`wzIu9%ZXW{{%jd
sxFXgf`UQEQ;2x)MiT*RhKSCK*OpxpmHi)Vys^26@Hfj8rcn#&h0QeZG#sB~S

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsage$Builder.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsage$Builder.class
deleted file mode 100644
index ea84d3a032ee757f74e921aaca52911c59ab86a7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 9805
zcmcgxd3+Sr9sj<~ZiY=p$Uy=K5vqV;0|Z4;NJtwlT^f)QAcYp=WHU)tHZ$q&EQeaf
z)~m&%wV>irt!<@V6;T4!D%w`9Xtijow%W_H_WZPewy6ES+1btPX0j&LHTmqm**EWZ
z|9;>1n>UBwf9O#Fr{SLpd;%NIcz3<oryB`fi${9uEiJJrQQsFgEwg?NuUG2{GZ~NQ
zt(ImbR>|q9gQl}))+V%Wed?lQG}fud75D{aN6g;(Zqw|J=_$q?$*%e{bVHA8mfpES
zPe_V&a|dXO1<o#rT4%)_y#z`+qSmsg9_yUbE+E1JV<LUYHPK!@Y^>A_Ga+Y}3ykj7
zd(HT^u(4>HrOU}<x^-)bo`}SweU=%gakVpAyzCoTlbAYi-5}s!Y<B8Fl%YaFxxh&y
zHdI9=#tN*D8kQb6v{-wBp@~M?$*6rGknMIL+wDNM4~kgUj2*G|PM1+LM`qHPmZ+hx
zO!ju@@ikgUOc$tVF(X=RofePE-_B%BTH`bHl<S)#5eDB(6D=IVl^&^LM=p!JLAvx<
z6%#Q@Kub&dn0(VE6D3QWK!c}`hNr87;{?`@IPzI_W*21Ej2*`kOu_LAJ|!^UD=mkm
zpNbPORbVnfAsN@Re4PjzQ7fv&qUY(I0`0Xe=W3g^`j}>P*DsD~iA2Mo3Geb4mL9TN
zte$9sf?5jVtTg0MP;q0FmNf|!)y`N~f+B=eoQPVwv39tDcCclY7S|1{A;o2u<WfiW
zefF%ty#J4zKp+w$LNm8nC53f{w0^FNIXFe&<l)z(V?GO!R;o}iN?x6=B8U=swLnEF
zN(9DcA?Pxe|F%9t#squ1OH0PAut7*OB6{ZD`a;><P=XqKTE%Cukf1eK1G>FK?qns@
zf3b=sa+zw+Fv_wHB>gfKXW&e34bklCU?y#lgv(WY7A*o(41LR5L#CNiK+e{;bZbQK
zv!bRUu-ZG>oP`bEwUn2qOzpUypjQRj3X?b#aSYKYvT23ZXG6Vo%I9R_uNIi=ZIMU)
zr}IY^j=&lfYq5@;-QJ!fu%Wg<Mx?}kUd4J@^@?doeXJl&IbD7&V298ZH+$RNeM7KU
zk9X_KI4y9Yx1j@}D|FEcoTFkRG=YN!^HE`ZpMhbCJP~OG_m-9q^QYJL*4&Y>;#$OV
zyq;mqIyS8yo$y)XiNEP6$;|Ch5yiOz<%EO9Sv{e>IV_ji8B@^<)@ylU@S2X=<%LJ+
z8uY37l2o&dYOZiMsZzg$3QOu&M*VVb)?l-WE!di(Tx)DH%q@n!$8(=OaR|6~FKg8;
z!luA^D$d6RgiX5$+$+fFGVkcQS4lpFcN7a##YM8DgQl^#hmDGCT=sdZCtLH*u+f*a
zTCKRQ^?LVsOSf9=jEL8(_3kM1ZCgv!(hF`1A6YURMMA+>1uE^{D{9t<&&u3UaH+s?
z15Me=WGuGIwA<m#ni5=sPzkQU*A;wCV5(Ok<$6NJ4qQoCq*prEXx(-tge8xwRa_&}
zFevYY4Qt*hvWUN_;#z!*^})6$p}V8bzW3wzeOPX^yKudN>)5h**%LN4vuW+LA7CS9
zY*DhSOOIzfqT&YZrnX6AOI+)7xl>>qE5gIi-17oanJ5C&JrO0>fg~u`a}!6P&Xd?X
z!`KaXng&}Xv4Q@#WE2E{o#M$NzrhU(z9%rl%Tu1R72J`|H@nwg(-Swhq#pGGbZnAp
zRNDP%E?`#Jvsn<7LM3-jBxK6mqv9^y%O=G;J>2V4$l;}Yp0<LmL^2!frg=IpSCG{0
zehGEd?SvuV(b+z19FWlXpo&J>Do)P7o;fkZE|;r>cjGsBm)q{`yg|w6X}M?Qhv+$n
z+GwTqKaxB6c7Y2%DP>&lckTFFKVk7M(U*KuqI1F^6ELHO48@}|6lV)8@m46^_6#q*
zB*Vw$bKyzEt^AptrO422MQ#F12~VhK#zJ}ZltctJ7$vRt3FNY<JXxAJ=q$^|^w|=l
zxeK*MyA93asfED5Jd=EAglH^qbKBHV7y+3>O~Q#9Hh8RRpTy{F5}sqAykIgXZPF>D
z;FrX>VGytpaGur_yeLpV3=(%nDEKvVVwgk<UKR*>Egm>lbsw=R_zi*gL)J5?2B;Oh
z#$DWtVsNr3_&s;r;jK-(HFY4w{m1cH`gcXv$(sG-tl;$_B9K!m3f^Qbc<JFRRPgo?
zK6Vyl2jtH~_{_Cf!C!a?@-aNcvJ)Cq#5r^JQKrDL?sfKDCfNl>t<)3NnP$SmNd$``
zeggdV$%7}p-|)#}Cwt_f6UP~t02Rk@)oA{j%2EFL_hHOljy_cJyI9VOb5L#1@Giz-
zyhG7!O8`puVM0Ysh3LoR0m2F{h3G<&=z$`-dCJvgGf{0ZrI?24HcK8TI_&0hlqv*5
z2QcG)`=->OgqlFa_}0X5F$lOA)Hw{AxRPs89I88jnYkR|2nfsOP@P)kaF906M!hYZ
zIPUOT<=9qDWlnAj7465Vq2PX;Ccox~2F$Fchat9*_g0#?4P(T4d=qiLOVesc4v)t(
zzMgGM^Y-<{E?R$vmc5gsS%&r?ng;Yp#pyCnTJ9YVt;SJ$s4~=#MJ;vxSb8Hy)g46m
zP@QB|WQRNzxg9j=N~q#0zLB}c<+e&kr2vy=1y+*bS)?2VaTMhWj|#Z4X2eD9<O3!?
zjGFay<f@j?gE)0JMujN4l{&Ny61x*Yu?tn=I!qAPyTnd(#0F83E4E6C^~s|#$I6Q-
zwunj{FQqM<<iBt?O6z!i+J0=96iEM?zaL+aIg&E^SY`plO*Hyul!{wWDQ=|(xACRH
z?Y0(EQXCyE$lK8(K-piU`99kXe0_M7q_U*gV>s$)yeXYNzV30<?1mbudki)GXx}T-
zw4=>VCb#GBV7=@?nYa_x;x3m9#%F|&hmJ0Cm!4;lm)YWEY-Jr^&%%@98X4E7J6KJ7
z>Fn;{PFpgs`mw2vGiGMS>_@y!MkLvfZEcLomt86yFOfss$EfT@g}5IR#RGf~@*rlh
z+UJP_JOe!FQn4|kVk1>dCkHVoSYD2Dc_i#8Ig_KTb)Wwp`R#(5M{IT}l<+z1q&K&7
z)x})vC*4=1p<)NG88qyi`4mbY#wF_y;IczSO?z-IZMl4&zsi3%?*gm&k?A1+PT)sE
zVJ$yp{4Dfy{Q_zHRkFC(GhzJOS?hZ+&6%8UPX<zxWudy6RsI9`#*GO0n`(A{aKj!{
zten-4ore|#q~|6C4ml3=5n3<cDa$U7m-0WIXdQ%4h$jeVPqMn6#%OVv74{6qiD%I$
zo<oy(9?jwi!r}$AiWhm_`x3j=m(e3$!6xx4HjCGIP<5D1;Ol&#c!OsfZ{l+C7IuiY
zaW%(l#XGhKn^L~X1Y{>}#7(x(cj9K;LT`?Sfp6nh`eqz7+(y6n>E!^vgWEYLb87}l
z)T7k&C_=(NcI<zken7583WS0y6ns~XyOt{WKFePo5b|4QU_F_qfSfgVFDKmb{kJQ=
zX%H9k<j^5rOW877RiVjQ5y|9bidhPz{>yqjO3ZzaMfbid534d}S78r#5SeU0$Y6U5
z1xWp>?a-FJe_;mP)4A`G;R~SDSBx^Bg0a3)F69Ssoo9}Y@@~uL=UDEma1jq!&NE4e
zILmTZ+Id;-n}~pK62|yyQ0Y7FLoB~@D9hhVTRz`Y#xz<!otB?S%WGZAr!6m+&mxZU
z3mIgIIzb6)cRvQgMONH>vs_9BGvNv1hq#X{%H_GK7puJ<tmfupRo2XNhJ6mJX&h6T
z*pCNtG~x}Xsj*4+kCcR`9}dZM$9DD|M9_R<&PV@<X*S{j`DZ~NUn8Z8L?Isa<6u6K
z8}ZObBY*g#k^lIkk#~Ce>yi8h9~v<Y-|IRw?u>aXpO`uL$;e55I#QBm&s6?dKE;~h
zmCAWZc*yAGvM2M2xyw71^U^Hwv}RF0F-ttH8JdK9*w1a`c^Zf9@fkeJv4gwtFYr8$
z_=9)>zp}@d@Cts*N1!6SYXANn$3GOSn8NXooc|Nvz>(r0-oiWf_%1t!zjD3?@8WM9
U`Qi*mI0pFp?_Bo}TVC1!01HJU@&Et;

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsage.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsage.class
deleted file mode 100644
index db9b3548bd578c517a325f6acb3aaff04006ce3a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 11572
zcmd5?33yc175;BB$;<KxNg&uTq9_nTf&@WaN<_2b&?HcjfQTB0<dF;{GjZlcL|YYY
zt#+}tbt!gHTbI^iRg{2QtyWvtx>fDsR_oS9+qzq8ZU1}cW#-MBn?U>=zvla9-kW>x
zIrl&RIrrTA&ddED-f}yDL&P)#SpuDrXm3qq&<e+_V6?lh#tz0d#%czm5j#@T!TXg~
zEHV`Bw%YBW9a|xrXQnl$v~<RTy_Nx=Kt*?Cpr$tx>Fu}T3fB#-uUTq^t!U7;dRncR
z9Jy+tfn0&(GXi6Iw0<bm-(y7uiepwZ6zpGRMPs2zxHHfwAeISCXo!Skb}($O3ic0K
zIV48?3HTdUban(<n*wcZb#2SryP5+{Esb4movrmvD=8Yt<~SiRv3qc+BQ#(I!fnBD
zB-SM`wY8~r`N}ncw)!<4O{sEHhLjf#SObyh=0Lc9vu#O{GT9J1#p(&f0^yKNnDPf_
zsVDBnrslfNmX5AKTYE=cTSJq;>XwX<wOAl`McvAFY2V&0I^V4bM#&<_<+q1=!$Er}
zY6%RDF|;;ANS6>pUTt@Oh-@tp$gZ5TO2F3;>9GnRu&;^f*qheWs{VX7?QfzCQw+=`
zdl?~b=79y6fqms%vrX)UPcbxFLSd_IXkeWc?Fg>xCsm~_k#2@ykb%hGPUFH#ErIFl
zWTq3#i>0v#k5{U;Y6%4kkc|T*JyjBEjfsiKlXnN2D2?AOG%*R2$)?>GiU}C&Mi$Wg
z@xm0Cl4|ef!Gz7@)Fr`7==%y3hOJEjwPd@=X!{=1&>0?zSv@PFp_7<=7|6i^%VsRk
zY1t4wDOl4V4ENS7U$?>Pw&gMyQiBDK*i)RNXlH)uwd_VK)*THE+7YIqd6jdtI+J5!
zGn4m=^HGNe1Iz;ljyr5kG=kY;O(;x5!@>S8<~cjm-9<%R$%Nmf5`LFT_+4q4J*7ou
z_O2e6HFL*fi@>xIC`&E7Ib`+s)OB}r7l@3kkHbeHN3#~v#T8cp6U*=!f#AqYACuAR
zHE0)Wjo&k@23iG<8@EeSHrjT%Bd4?|2aTkO0xZX84XhA2Oqa{|2&ajaXlFv@>43RD
zh4a*%s;knqjvD%dvDo6Y27Tb~5e}}&5-y~Ml)YBveQx2!>}hrHs9bfSRCwGVj$tbq
z>)zNJ9CR|Tu_+p|t&WI5l|GHg4W(!KkUcnLx7$%GIG|E*LDR|I)}YN(M9jeP0+Un*
z2}NoG%M(2XI05Sn1O;a4$WK#jq8r@s3lyS2*gp6mft<>~GMTXj)|==>U)<8p@Wyat
zQ&{<e`FZvzOU6B{-LjcIH=y6ZMu8bRK%U_yj=@^y!HBY*vuHy-%?ig&?dqf@k1*~0
zQf>;!O(tq0h6w`Z$Z<z@OQwcQoP<rZkI=|94^t!{E~`igNc5XcL@>yWDW;U>S|<(#
z`^i9=JM^3sKIa&@TbyR%RD4bnc!r4%bjrIkO{|i48*mzdMb>SQyRv2r$cfl}^4OTy
z7mW2uL!|-dn)tFbpm@Z9qnu8u`Ku<D;D`d8hw}}5orAnuO?(N11^6Z|Fz_uNv2=c*
z<tkU3xDXdPv$sUTy)?UW*&M~g`Mj5)cnTYo=dtE!WI!P7un=Y(%422y(E9aid&@|U
zS#03D0t@sOoW$cRH(EX^bVvH*I1=lk5Z}jT1}^0>StlGnV4B#9%LV3)W|Eg!hMlh`
zXmhcZ#a-zkL13$1l{TuIPPUouxVl$by`h*L-Q2<?!E-`ph?Im}B@Mn>pyOjeso|!?
z@>(QNJr2_aHtW-)j5FrNP`Edv^lX##Tq|(U9-z>eKV5683%kG-yVb1K@ySQZ4U&rO
z0^DwO%g1GuwtqCh8rIfUuC32x%<qtv4D%5|&7%R3wU&q8v)MZ?OER}eZ;^m+6{s68
zB#mt&$y%Nn!mh(bhH{MD3vV~^bKD^?S?w9CLw29*v?8!VA5igp>>TCN(CR|asp>E#
z=Y*tbiJa__PUd7!$Nz!5C11akeEmw`)bSHDE(^xyuvB@g(drKka1-j0TfGE#pNadW
zGpD6?d%P+~J}5`hjMMdIs1w{L6@m{-N+02~nI6kXtmzoh;M5IE2498N32ABsuF-=@
z8>!VdT0YH87LxvaTyppX51V?}<Kl2!CXG#Z35zmLb*h<9^DOj8H)m-77<s_uGmXIS
zP5c4B<&#qqfoy)-#51xv-;N|Iz`H6llwUJ%XAAyl;(0tvg9fZ<uXE<lS4A6}Y!{$K
z*2XT@M}_7Q+aZPVVukHYo!(rIYQf90>i7za5g!#Ji=Mg6cf`x;r#5zXYbOs*nF)b}
zrF@!H1;6#dp?*7Ard*S$wZMH=lESLIz&@jt0-U5EuxZQznXJ{z5=|UNB0ZF+^OWeD
zF$z#8zpDo_xys)%@j6~*eQNCSB<Z-18g<%0b8sZQF0s64;z_*7C#$isNbD(c|CVyh
zRHGGgymK+twW}9$%^~?p!Jk&LRZrgY<f)UDmOz+q+f+TyiWx$%(xpq}$%3=H_-u%5
zQoEb+gp-su1mEP%(@BiJH2I3bNk)dq=R@B3q#0ByAxua~Xk3LUwMtd*GXyI)hwq_!
zeLbI#EBX#Y6pvC^^SI9trSzE&gfq|(eD^YYi~;TdGQ^ZoJmhGTgAKuVQ4Jr%k%Tqa
zv|#hJsRA@>JMM9+&GjNSug!|tM@3>b4&<`Q<|hYvm<og6+~4FYQWT&ZCMG0)7qN|R
zs@PYKVpn?!+xgx~$?&ZeuT$lFK6T|gILeo+zNwhQQGV>rmT7D`oO1H7>{f_1JF(A=
z*zZ=%;N7enQE>x1vQWwIBEmz~;V8&z!sM)@sYLe34_~11JFdK1soco1vahVFdMD;q
z<?p~e`8B^PYX=rcmDx(=6j}?M!S73G<(0JRI^y1<R8NU3z(L9as=^{1OvHy!!sIpH
zawzX4fDv2T6o<g%s+~AYGjH6K_`GMr$9eNPZxQF6gtOGVaov-hd42da7CSuEawch1
zp2O4iypQY4Rd~*I;m%9o&O<F3mfW)->S&s&#sj|XIMS=-yacg6G-IhFQRmoIxE)88
ziqe*0v?T>gX$Wuuhg`(KxsX&|;4-Dqfx?m+IvsU21THDesk#aCuJzb)xl1@FA<ROt
zMtHtgc$-GJ1gmkhBfP;Ov79q6sP+3ULym8o{}SY6Z>#b#IDFfP#vL8o867v$<2Nz3
zhxsmfr<x!h9pw(X97fG*e)xWm()>@34`7NM{$$~v^Bv1ZAAcREV)Jy~OE(@MZO^}8
zE6i%2yd6dtFZ1Iql9>6jWf)fVFha?gor+uv-^RGPorvz>I=T}xaTn&|ZWpox68=8`
z0|-0FIB{tS?^(L%w_JNW9572c--)&UtV@yO-<Dk~@kk&=eg$n8>=R_00$1c$;8dGm
z;v2@v?Dg-!iT)&c3rHDoFUh-)cMmYcA0&CdW*T@1`{NN*<55C>j7#cq9Em5;#En<3
z=s2-U6U5fz6qRBmv3bar#FkAWc)m+;On8_k$p7V7T3vOObY}IP5L{Mr<$r!#^&Jqc
z1bO;gerS+%^DwsX*OtUDi@#{ZSt<xz{$Ij;06aw#o~BQqr3uf`$Io*my+H0>#D2Wa
z;&nD&qB$?4hS!C>F2XA`=g-QV>2YWYZ!E<Z@I?YI$2^>^jFpC&$T7?hP-;L-n8;qf
znsAJJkn%EER+Ig6wjxhnwiVB*EuQ4>+l8+T<7+3>7SHnc`FL66?~|79!Z+e=If=F{
z@wRDd08PC(?yqxP{)!v>8V&tB;rx@Pzs}HlgT8tb6?lso_Dvf2HvRPuQ_{OkChwpD
z?_mZ0#fAC4%Xh0CV<+M$d^_PgZY?Hbb}KVpazT7Y#o!@qk;!1fc2rc|jPGSJszoxp
zsN}|e86ENDH~~Mv5BW=~yCO|py+c`%R9Ag7uFTfy%XJ|xa`eeP=12H3!AQ;5q-pj5
z{fQQ6p$F(s9iZ2xsq+H8UJJCu161lu1$tweW)IMtv_Q)|KzBMoccrQG0=-!a)b9Z*
z^`!#+nM-p#7aqnI>3VJ}6;-=%TZ-cg*a<Nm1!7+p)I#RFUr<E4=&m${jgIq8<@{Z^
zTcdF{3Pptrtm$Z!;Wgs^d$3!u_i9wnCD>{$*n9Q>>;oE&3ki0?ZoqD3UQI44Ewc}4
zR3ApLhkC$1>M;9QnnEwLztLzsl3<VUfR!4P%nJE@<>a<`yh`W$cHwv4<=*JR<#Q5B
zzAP>|va^*W_uB2)Zx~N`#haD5Oq^2aSx0CQjdG$*3Ncwe=M@aN<}JjZn4v)tR<9ft
z$2uyeRdM30FyU6T@Sys_)hKfAMwG^n5bDe-T49Jb{tsNMOZha%DCfXXvdm!B$S0p#
zotau0$#PpOl#02Rz0^842{yhoI*>0qmCpD!Gjh_R5VxPdP*FbNF2Y~=osYlaRY$e!
z__tqDr^>TgbuQ*!<6bawuKtHg)h@{jujJZ<q~QMHl}tFB3)3rkf{T|CXA4<OaPYch
z)9_m9vc+|jeZ!HR#jEsr4juERXJU3Z4-rb_?eU2;(pm2~A{FFGMq6$b4{Ps^HO-UU
zFXKlqH?sG~7WrVjBF|`N@h%f;P1^qqbhC^u!r=T5EzZJ+_%E;Pcrb&=5<Zmk<eM!F
zU%udZO%&vs{MV;!QOI_a*CMWiiK0Xpx%py}C{x$HP$$ZHBobmTF_qUD)F=O1*kbT^
O4%_`4zc<^mQ1?GFI9Xf(

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsageOrBuilder.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats$TaskResourceUsageOrBuilder.class
deleted file mode 100644
index c42b6b378115dd028da49ae230242f0637de4a4a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 537
zcmb`EKTiTd5XIl3a)2Ozv{73MZQNMdbBPfXzzDV`%Q>Flu}gOLO!#URegHp|aSj^^
zm5Ie>Chuit-~RUV>-_`36^<g56ds*VwOf*9GCq0H!SE~VrFX&UiS+lxF82wIg9&_B
z$lWb@LwR76(#ZGnS@uLe!mdJVZr+T}j7{}uI;SK=C@XXmx6r9`X+}TyP4j0xAl{f)
zXr~n7Wj>iLsBeeHI#$>@JHM5+;tXiv{Hkwzt3YDZ#_O=xvy2o@w}P(oUleH+>V0d;
z$C+U!j&Pt5{{xB$ErrWJFOp|&g;hBDt!;8us0@k2jpHCFg@~Lz`PP!)j!;2?y;@Xp
bYK4w{)TMT$YoLiXj%A{OPPvN1wcq>(S}3Dy

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStats.class
deleted file mode 100644
index 40849a2553a5088388e941e2c482474c29f92921..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 15186
zcmcgz3wTuJnSQ@B6HYEC+%JZJqJoA5h=`X$A{t155eS$N6j9@l9Fl>_Oq`jhcq!JF
zT5r9mtrc6_?L}P6b`>>1X}xs2YinC~w{GqBy0v?0x7}_pdug||y6<<+nVB<_lSq69
zd>%6Aod5s6|NSoi`+xs`jxW9Og=Ya=D36#h1gn#&zQ*LBok-i!R8N0nCYs)zZX8S{
zGs(s+yza2m$)Qw_-I<AI(wp`1{1J~$gav2yBnKM%lF7cf?TYUh+S$0)PS~kv#_ru{
zr_<3sd+Rb269gMdFzBY#s-alC*G>s0r|ncM8sBQC(y?TsE7B^EO9j=dlZkXDn#gR8
z#)s@O8twcinBCFVxv8sTbz4_w%i6Z?HIcRrt=;Wi8&|b;P%;u?HxW!sd8T(M@@~PY
z8-h&S7#&;_v*W!@f{M;qUm}_rO4))t$L!p^VOR9}Xk$E@=xglEq+*G_rc(H%AT$o_
zrj^7sW56Cr#%{8EBk4#YmZ7WkhNiBf?^@f|v~+FQ(j95<+|ts%x=qkl3Md?Q!seEa
zPIc*=KwoT*rWiN&>lvfDxg=QB3FXZ_@ffXNDG1dq+$spKPWIZBU|cPnhFaoncG@fW
z=yVG+Fw?}D^hODCb^g*yoPkqS^H~;V;S|B74Y7pXJ~XhyPHl<qh%;lRZb<epiK9$q
z-g^(1)df0d<h+{i&4wm5?Sk=2HP^4CU?oCWq|R8VNS9cchUxTErazVzm^-r5?VRyK
z63i^LZO>rNzH#bOpbGO;K~=)OA>vH%9(u3yxJ~X#45jVf&8gV+Bqk<dbimFq4;T8T
z<fa|F?4FFK@Q~A4aPjft97Q|XsL#%{+UcHDY%r4~X)UQ+7^pMfCp|xZ-Bf{QtTb_v
zVClFM(!#~KM6foNprMIqyqm0;iS=|-QFosDyB+H9cBsF51jl#x`miq=4|2h@?7(a7
zOqMP=$Lb=%9>{iKparcK+OS4&icd#&O>!7cFmDu3=Jc3YN7BzTZpTm}6C1GGZtSrK
zGh8uDaJ86~Z+98ln^5K0K;cN@da`Ekyn*Q8yq!w-^AgV7T`{i`5wz>1*+inP^CgkT
z>pHC>xXeNaI+;+>L9Vsr-Z^UhC_~cl2)Zn6#pUF!Ow!dPm`+2BMc8*O+Ns#Z!#v|k
z-Lspvdkiwy=QwAfYU%0WVw}v<&PAhmFMwi3iaTj}jfHMpE7+7B>22kg<JBT;O@VoK
ze8^1f5Ud~fTq#&W>B>wx%dC~?#ZD9Cn&m-tz;U6n(1(7(X)L!`B^3CxaB1%LXVU6;
zG@Wkph2DJ-JbR7{2dVAuQR1GRH7Bz~(dA~hg-MuPfdM2<Bv=)cB6I~z(Q5CE4#hKV
ziA-wGx}=tl76x&h!0Pq2j8W$~lALg944KGq4hQ8y)_)eR#|@m0_P}6fPxhf;W$-%1
z4zBj#pl0P6w;5bV3d~xaB%L`$O+=yHY~dE%N<v^iiV3D<Sz{;@i#PI7Qx*2&T_$cL
zI)_fO4Hj<49xnK4mWLduCz;4ZV~KRZXrqwal_uUx&*j;veJCE^oOBo=$Ft>lAM1z#
zQs{1bPbK!DU6I^v;U3(}^*lS?dYd2$sMK4J7hXv-DXO(nek6})S;`iBMo`&m52oxM
z-GK;hDR#ukOmRVtx9n_<rDH7cS`vw*F2mfTXnmBoClA?K06${kL5=6MV(XmX))YV8
zl=9MC@MS-TcwQ<+IbA@J?k;2D3DT?i@vw!D;p2=vO=bP;H!7PKKJR&tOngGnRSF96
zS3+LFk>v|#Un#i!1Q}10IahS6P%ul$0XG#sIk|Z}Yh=o8=}#reb-Vqs$(BDS$T=n+
z6P%HsHIaDS?u*7-Qhh@Mb|RDGoJt(f%|dmoaDC+#kYr-skcwsOElELrFfHpAv3Ju@
zW^gD&d+g|dv%RX!X-}JYf>YCh5lc2kHsxA$lXA$yQ+S$nn|nS%R&|}inX6;=9q*Wd
zRS=ap^+Rxt#8!7biD>;P7`AX2M_i8VO6*P~Z%8=O<esxfDFpo8I_(U}=nMFwiDQB@
zgVw#G?iLQ>FSrUN9p`bBKqE%_m+KYttJ68q(Nl^}{?YQ_1q)wBHP`CwS%x+!J$%K&
zU*m6BCo}4)Jp@|3;wknjd=)R5_*%h=#|8^u$2Ta;EZ{MfZp&sCED{m#ITgH&zccZ-
zTzc}8G23e4@9{0Jn+f|yj$T-$=lJL!vU!qSZRa}ys>G}KM-$%}y_#^kS@<r#N6Wb9
z_4XxeSiy52EvOqMe%Tbr)~~eT75u=$4;8Cc2V7@O{1bB`Ka1S_ti)^hXA?gW%nyom
zv0@AVf`6sTw4+k6!cPM^ias7q4#b~Y_?bd1Cq#!~70%Bs{6YsQ=ODR<zqIh5_?4i{
zIhq)ABj`?sO8f@@W#YGj1wn8|WTS=u#{V$n>`Vr*y+cgRJZh+m1g5mtX#-QLX<<b3
z=64o;kI#{9`lIP~rif0YKUjE9YppUTYgz6TGP;`^Wco>|f<s82Lf#hC^W?4ocLp2o
zQO?Q5GQqxXC>l?bZpE+!xR*7s7<94la66RTv8%9H^wN=zPiFe{?6{mk>DR!MWTeuP
zDkYi8S&~`jHIhQ5+QM?IsFX=E#gxef)5g_mNjdhAl4P1C)183F(rsG(E2Jq3X$na~
z$Kz4)pq_rNNhJpaS9$X#!4+iHo{YU}Xy;DnK&k}gOOq+Jf^&ni-8<57&h&edad*_*
z`c)-!<up^cbj}VEb`NhYIYs6P7LH~>o>+2z5BEkh(OkY4nJl;?SXE%cwcVKEKAHt|
zhus%Tll<K|SBiq8NzGrN=A9+jQUXi?o|r-^D8w&l7>A*w77&_4E|K$4vlKa`&S+3)
zEE1d-T(lI78DQ+ZK*M}eg8SZ5bD)kBodxHp;Y$TPkqMdzJ`)1lM}rsOqe$KMRiz8q
zd5ZgdEofA0z;MQPzW&LubzHbhl~2nR-U>m>cmV`hk|j{Bz!Sbwy(G!6E6YWetdxsc
z+BvL!c`VcKtMmn%gHyxhNblTk1h$}L@@faJ`(-gTB*&9Q(s`aNYB=ekRPVH^ciIFu
zkKYaB!aKIdraG}{wd1h?mR`NOv?{oDmP9mka|@e`VyHdWYfqXn5Nw819G;l;YF7tt
z5=4VX&gM~&{Q;<gy5$q=tU#BKP$T$gFqjcN1NDu@dZl0wja8?5Y>VKYV36bT*tiTB
z+qs*#6)S;>xgDF9otIm3g>>;KGr#rI$5&diT_0CulHP_;@IYNDMlVg#;Iknr*I3dm
zR}t)ho$B+d-U{bMV}@JUN<_grb6;>Q1KwwN1~basJ)Ho!y?mV~+~O^NyNLJ-eggT1
z==d%^Fu&f?D#6B51Tz-~ZiBd=_Rfa$ug%w%CS$o`slhzw;!A*0&Lg}@DX_=vP`WQZ
z^nHLkXzr{;kIRdEkZU`06j=TZz0SOpB}w77^0cx0(<N8G-TVnm84pJ;qKf5uo(l=z
zb2f~PMK?wTa(h&c>@nKeU-4L^pHAm9ur)FLRHfE`DDJ!@b#{?Uv^L`rT_nM;zMOZI
zcG{G^JY5Z<&HTp={tq2Yc^6&#7X6(UJK0YuOnDE#rU;T4eUkAo#v>6^?%<|oe9}xR
zXKGg$5D{ls!3$mI{kti53obfN^}*kcu!Ik8Fy;NDoW&M}&y)``W<emlj;7qlTo|K+
zKY>hnV3Y`X+O#t(*fu?n<&ouxT%mNqD@AWYI{n@EvPDwPYZp`Y3$7`}>gosNsP=tI
zIQzI8owWB!mbcsK%(`ScgQYyK4)I?ZCSW#9l=HfR-xM0CL=7xd=k6!+8DDzyeu~pR
zmG}JSir2IC`!na4UyJ41YtTq-vr)?@bJ%(j`|E!*jzP8^#@wec?-<VD)%>Th;7K+Z
zIGcYb5)Q)mqcZ$3riVX|I;TZj`KcHGx`Wp{D!1`ol~&a^97aRE@eCHLqEKEDT2N*j
zr7f!*MKj&*M5cHth;tkdoXcyAINc}9c%{Q-kvH>B+bZi1<GkD`KDbzoFh{9Ct22tL
zsnQ!IjPr4U=L6NGfXh7}Ji%*M&je?LOMNKIb12JkA>P6E8a>nVG|hMV(^H4gRIFuF
z&S_!Vzsi%?%NXm}OKTtJUocYqa@6}bt$rA*pE!oK+m0c!ZR+~N*jPJ^&BNGo7*{;U
zPOeL5QU&;>&vaZtFjrzOwqr4WHAb#$m*zk(#Wp8-u4G#n#`G}%ZpT#~m=-7L=<Y+f
zda6u~4x=Y;#Z-0$>#PuZn2|dey{ONxRo)PWerrXG+=PfZ3DH6IYSXm(r?KlrR31Y7
z2vSezovL@OaMT+&!!&M1rEv=;8hd@}r+MlXHz&qK>bntpJlGd{`m5Dn!?@`v-YI-{
zR1ietcAvItPn+P~c#o&#YU<TM%xQQL)yJ@J+tfP_<Id+il?_L6m*MDi(N=0-<1V7S
z+vn#wIX}<A`|$y4_Tl{?Zlwo5#3A5$=RVxeYt69-_^Y$A(X*tC!+tpLdM6Ey`+XLa
z<t*Tv{hYh+bCjIxDJl1`7wg&Y)00hSZr1P+<rKtY^n`}GG0+q3i(Owlgvolf-@x;D
z<N(5pbeOO+$K6nVmd-hV8OEcSX*}i(S?{XNIjPZelG^=A{29%d$prosK1~4Gx$i#t
z44<egs}Y*`I!-mQ_YxD25btO4sE7JdcG1tSmj$BUxX4AlA63V2fb{m~&*>8veIEI2
zMgztZM1F|KpCoefq46~8jA6%udF~K73zm5n%;cm~+=dUgKKTrvDDDav#9c$&4E^Ky
zoQHWAn>FWZI29H**M>idvhcy${U{3^tPhhm!<xjtNp5_Ry!j<q#<Q4eJdat%3l1uG
zk}I<-f0mI59_K$d`S^wY>#(GZw|tw*(LT>EVcz|v6YD6i6~T-KO%_hf@DV)8%V!#f
zaa38`<-t=q<6(RaV!T8IUq`v|4OAFkC6aGqy796P#f+S9X5dSBmIH~trs7|wmNd{B
zC95<Ie!jWZ_yo#o4~Ck(L_LbX5*)>gg7yPgzW6A<DNL?cHWJn_zP;!uzOVN`8pe-#
z{cn2x$T0qW82_;%TpO+-@?T%uOsW4B?0@qswQ9vM{_oo6`r2pke670DP0y8FFkyU)
zhP*-pzRh5N2aApGVwv$hTx@(F>y00vo%frKAL26ON7!b(iXFy}5jS4Lb;eJ8shrNa
zJi+gtbWvW6Mff9Lr`t9&=zqd>98*(SL*%x-k!yRCZJHc25z-L7$&0Ybik!ZF8C;%t
zg?nAc;Si-XyPF#7AJrsjcmc8>6<lFO4mLaw*{D8Tr2Ho#H-TtA@1Gf#uygOrr6pWp
zVf>U1_!;T;=XAg?7{y<r#`qQH8o$Qr{GHF=g~o5N-1x08^P6(fZIUukTB^YrVmjuj
zDOI$<dL7eg#w6nB%PbH7VdB?3>!^QPDjq_){v4dVuzB*d+WsSA4a-Ev$zyMs$^c^4
z<OQ|;;cJ^GpI_VWw8#wJ%yn*P)J!L?QsKnaog(#Il3@IfCjFjq{R1W$e?%>_zux#0
zmKtwhB^|gv#Ix3r;Y-*K&!kCMEwgfKBc~1R;F)~|&zNfn-J3Qt+nF{O@`<i!)rYX4
z{;14R5|kpI4V62ixMfGRoGxcjK-HZ&LftCHR=qP()ioTI`Jo_v6Md*Bdip3MXG<Ny
zsAjFi#spd)2y|Kz(8V6mB_q@o18ochT2lm6^%Vj=cZB95k1h)YI=2Yu1s+fpF0{KC
z=sN;|o>>G`^%Vkb%4_x*b2*=A=vgBzs6Qgj1%Y?Uf>0eQLudP-R>>vOLJ<wosu2oX
zz2I9;@Q=vq0F8~P3N7)0wLFcik8|N)BX0?IZGh_Y2zFT@*fqxi_R;{2O$58*Ex?{4
z8%8*y$g>**RJRc9B}HI2d!D^)gu-Iab_8f#N3d&)z^cZ)XGPCBJQ`cVUk!fvh-@vM
z?i+l#!XBwq=)tQed$uD9n1?WLShf|5w>#p>0xFcP$j{Gbn+nwr%hkn#m-)u6l55Gu
zAocQO*BkdLPsQAN4*aOrw$W{eC3*l8y{oKJmqneOUZ@LZXe;LMS9cLEht2hjQlck6
zPPx?N4j`<jN8U&qnaR3HvBZjQ<I2>t(J2bu62hGtSD_+wwWHH5rLx-w3dv6Cqav0{
zI7j;Vw?bmF%Tw*!Sj{VPK=?tQ=XOh+lFsHs1{|vPNiHasd@?5~k{BVG3pOWav7}oL
zx_-$9Tl7%R!|RhBf%lltr=INO7RnBKvJ3dDNybfpTvs$O8@#QzBa$AUNGpSt@kGv|
zpETPh)He*v&=|u|=7xY_ZX8?Wrg4feVS`2~o+i|qw|~0?jWW6j-}>B4iw(I&ZsqUo
zm@My<+vIlC$h+CLFI*w-<?s6@Sp5GqLUJdc-^Jg1m`AVSRoTakyjMOT`zBP#hva_!
z<>zpF<-`0HG|NY{7@}VNFUl#nkM{%oeUQg3+^fh(sgHXsd6@mn*#BeH^Ktey(ER^+
Ci&Dt|

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStatsOrBuilder.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto$TaskResourceStatsOrBuilder.class
deleted file mode 100644
index a980cc969a9ac79160a6ddc09a2d79fe434c1d05..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1364
zcmcIkOH&g;5dH=<OCl<7B;b=Al8alOJjAj}Ls?P<#v<Us+hl2$fn_E&GpiSW83zs=
z{ZW>kL4@pbp^6-)dZzp9=XCe)Kc{B^-l7p<LSW0-G&Td$j-*WvV=vvYiwD+t6YuhU
zhn&f6LOn0N`#NMdO6;!vn5%4`Y=nCPGe`1=j5DdzxZ6LX#7C$IG!k<Xr^ciiU0Cnu
z2k|yJCsX>bFR+-BzjV1blyyw5y})F%waL=NXfKs^BM{~{x2~M_yj41Fx4v^IMQZ}H
z&DI4r_bQ9G<)AH4+n|A^M0(m6sP<H<rOz!1{3?RqmHpgB0Y^$2(r&-!xK?&JcXdMF
zlvDkTK4@+D7nIRXVCh;USK+hLd@*Ovkxdo3UAsXCGS9fS=QmVuOj)(YWLIFhoZ#-E
zH9rN8Z%A)^anyQYTt2Cc`)9Q@Dq(_N51UnBdQ)q%olH7MF2brn=MIK3!c&1aw>HF+
zQ3^J~3xT~`n;Plnus23Hp}!06{_*Oi5U#C;sW0UGXX89?6J7{>?(-h2@WzQSh2iF@
zq88`_OtbtUOMypxCh!<DOe?H28xV7h5SKF6oX0}oFJg&tlUNQ~Pq4zY&hI+b@Qh#2
R`Sy~j;P<Oa73%@F_7^FWxqkov

diff --git a/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto.class b/server/bin/main/org/opensearch/tasks/proto/TaskResourceStatsProto.class
deleted file mode 100644
index 0f5dc962c8604b09352299f0e795da763f2d4c82..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4154
zcmcInOLG)e6#j1JCOzqN5*SDf0Rb_><l#&nYJl*}1Be+CWI`|?44s*qp+l!TcK1X^
zSy<(o1uOjrZWXEkwXiIgF5T!}E#L3=#`5%?$vm7vND($UJ@=mTo%cC6AN}+0`v3-U
zML`WipY5ch_L8t%p*zWoQBQX-xzQ!Z_U!01eV-JropF*P?&+R;!ar8P8P+Z6%X-w*
zt#ov1Zb2kHhNFh%3CGgSgiE|eGC|0RB630^CnR#B0y&WqZqhN9JlkRDi6!mDXxg^Z
zrpTExmzj@_7C79F;`b24)B`D=H-wowoJ<PWwVi2w&J+woRSh^QEaB*$NF66$JuPMi
zI*wEblRdK!WKU^mPWfueLZh!Sb~W$MJdlo+f|0h5S)P+Eb6{?*!K-<omR3`5)npbc
z$fYcrqWGIK7~GdM4a@KjFa*M#GYovhP6-7Y$_hX3Ifj)EqJ^=m>JC}ncWIf3tol$p
zbws4t5fLepyW8>Mn>FhC(%j323!PRQoqPw%fVQ#ifpA0rp~&5#A{8i+%AB+hmur*Y
zp;omixs;hU7R9(Vsav*7>R31sYEc^(#iH$G$F1S4C)~Cg|F}J)hANRm4Qk+$$V$oj
z(4<<steY7jB^vq<uFmdKPo#x=Yj(5Yw&B*&i{fOOtCMjaQ1A#t<X$tRJnJf2u}MQa
zHZyEpsnOw#VWtXg?+YAp>_vv<@Yz^#0Osmo=<I6itaG&j^<a2ZLnE40`r4*pJ04?b
zObf4Ay$t=~RRjCZKdzwzPcSqSTz<e!XP1P_5F$Y7ZN@XqXv}cEp$6<ir-Cp;Q~8aC
zE_74Z5C}s{cswszvM7cWJju{?uj~{(^1Y5~s70NEK88KjBnvtEztJ4T07a{;Vpa6w
zX${X{kfCm0zU7C*_e@ODI!b#*C3MdCHt*4(AgH1TLmKw^p>3k5ObVAah>WbybU;Hr
z>Vh~#w<Be(7sN1Gd%U#me1TC7DuVvk5e*H#=rIcSgvbW*EJN*#-)#PEOoN6Xr88z&
zVluNhCsvkQC}t;hb4GUzf7#_XUQ?>DT}O3KXV_51FBJit^rN+oCZc!IpxPLSt@`~y
z^R>khX(}V(95&6d%N{*G4BH~KNcG4USWZeYCmS<7G33wXU=GO1GIUo>T6IyXzx&ig
zTKrx+tKk$#->&;pLN2Ot`E2rM2E*p+^D5$34udvs(ZgcI)LmD&3g~28wHhzh97Rek
z{-Vk$A7u(i<<4plm2E=ZUHOJlaFJnT)rsw>@RFf&r75^X)wu@XQ;r<Zf*y?R6`D&f
z8~m1|KB5kw=-LcpYoNTNPr-`}6KesLcS8Z?HMtgmWg~7>%<CD`lP|GjwwV%+f(*l{
zwNO+VcDbJwyu@(&p+Nf)r#3(LaKH;Wc!lBoLs3zvNc7P_3DCb_3cWUHtI=1xzbPc8
zWgscdcu8r(OG>kxsOs;2qP6s^8S4mVJ-~L7G^5iu_#K311EG!aiLSsMwBAPB4Q#oM
ztv9hF@D6s?-~;sBK;%92&R$0(&)pxtg{N*{H=W$X-V(n3Ille1In;ykSspr^V;;#d
z^CIY2j(IH4eAH(i&oNKDO}5qGIQ?B9Pr*My9sd;dL{<Jd8u%AzCK}?Op@n~i4*n%}
z@o&)0za<;L!yx|}`}q%u@$WIke?px9j2Zq5Qv63O@ZXT-zv2r21F!Nw@f!aN*ZA*v
zo&SwV(x*{eR9wXrPDmSQbLC=&C{aIVwOzOHT+zTfd8ibG{ZPj-O^o&a0>}$@({Epx
z{Z~*e5u`rA^LfG9yx<_woYvboQxtBJ<<Lx5P2gnWis`=g(|AFG&{HoD(jg%zj@Pl}
zExOBvR$9(Kma;W;8o)VucOD6%U4+zw3z)+udg@(3l4vhdm?xShJcH;0QM0Zdi^RW?
S{7u8c5*&C~#$~*Wg?|A-ixPAI


From d5119305d1882aa317985ced7e3756ab624bb348 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Tue, 1 Aug 2023 01:39:18 +0000
Subject: [PATCH 24/37] Cleaning up more code

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../ProtobufClusterStateRequestBuilder.java   | 117 ------------------
 .../state/ProtobufClusterStateResponse.java   |  58 +++++++--
 .../ProtobufTransportClusterStateAction.java  |  68 +---------
 .../state/TransportClusterStateAction.java    |   4 +
 .../client/ProtobufClusterAdminClient.java    |   6 -
 .../support/ProtobufAbstractClient.java       |   6 -
 .../org/opensearch/rest/BaseRestHandler.java  |   4 +
 .../rest/ProtobufBaseRestHandler.java         |   4 +
 .../org/opensearch/tasks/ProtobufTaskId.java  |   2 +-
 .../opensearch/transport/OutboundHandler.java |   9 ++
 .../ProtobufRequestHandlerRegistry.java       |   3 +
 .../transport/RequestHandlerRegistry.java     |   3 +
 12 files changed, 83 insertions(+), 201 deletions(-)
 delete mode 100644 server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequestBuilder.java

diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequestBuilder.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequestBuilder.java
deleted file mode 100644
index bbfea70eda383..0000000000000
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequestBuilder.java
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.action.admin.cluster.state;
-
-import org.opensearch.action.support.IndicesOptions;
-import org.opensearch.action.support.clustermanager.ProtobufClusterManagerNodeReadOperationRequestBuilder;
-import org.opensearch.client.ProtobufOpenSearchClient;
-import org.opensearch.common.unit.TimeValue;
-
-/**
- * Transport request builder for obtaining cluster state
-*
-* @opensearch.internal
-*/
-public class ProtobufClusterStateRequestBuilder extends ProtobufClusterManagerNodeReadOperationRequestBuilder<
-    ProtobufClusterStateRequest,
-    ProtobufClusterStateResponse,
-    ProtobufClusterStateRequestBuilder> {
-
-    public ProtobufClusterStateRequestBuilder(ProtobufOpenSearchClient client, ProtobufClusterStateAction action) {
-        super(client, action, new ProtobufClusterStateRequest());
-    }
-
-    /**
-     * Include all data
-    */
-    public ProtobufClusterStateRequestBuilder all() {
-        request.all();
-        return this;
-    }
-
-    /**
-     * Do not include any data
-    */
-    public ProtobufClusterStateRequestBuilder clear() {
-        request.clear();
-        return this;
-    }
-
-    public ProtobufClusterStateRequestBuilder setBlocks(boolean filter) {
-        request.blocks(filter);
-        return this;
-    }
-
-    /**
-     * Should the cluster state result include the {@link org.opensearch.cluster.metadata.Metadata}. Defaults
-    * to {@code true}.
-    */
-    public ProtobufClusterStateRequestBuilder setMetadata(boolean filter) {
-        request.metadata(filter);
-        return this;
-    }
-
-    /**
-     * Should the cluster state result include the {@link org.opensearch.cluster.node.DiscoveryNodes}. Defaults
-    * to {@code true}.
-    */
-    public ProtobufClusterStateRequestBuilder setNodes(boolean filter) {
-        request.nodes(filter);
-        return this;
-    }
-
-    /**
-     * Should the cluster state result include the {@link org.opensearch.cluster.ClusterState.Custom}. Defaults
-    * to {@code true}.
-    */
-    public ProtobufClusterStateRequestBuilder setCustoms(boolean filter) {
-        request.customs(filter);
-        return this;
-    }
-
-    /**
-     * Should the cluster state result include the {@link org.opensearch.cluster.routing.RoutingTable}. Defaults
-    * to {@code true}.
-    */
-    public ProtobufClusterStateRequestBuilder setRoutingTable(boolean filter) {
-        request.routingTable(filter);
-        return this;
-    }
-
-    /**
-     * When {@link #setMetadata(boolean)} is set, which indices to return the {@link org.opensearch.cluster.metadata.IndexMetadata}
-    * for. Defaults to all indices.
-    */
-    public ProtobufClusterStateRequestBuilder setIndices(String... indices) {
-        request.indices(indices);
-        return this;
-    }
-
-    // public ProtobufClusterStateRequestBuilder setIndicesOptions(IndicesOptions indicesOptions) {
-    //     request.indicesOptions(indicesOptions);
-    //     return this;
-    // }
-
-    /**
-     * Causes the request to wait for the metadata version to advance to at least the given version.
-    * @param waitForMetadataVersion The metadata version for which to wait
-    */
-    public ProtobufClusterStateRequestBuilder setWaitForMetadataVersion(long waitForMetadataVersion) {
-        request.waitForMetadataVersion(waitForMetadataVersion);
-        return this;
-    }
-
-    /**
-     * If {@link ProtobufClusterStateRequest#waitForMetadataVersion()} is set then this determines how long to wait
-    */
-    public ProtobufClusterStateRequestBuilder setWaitForTimeOut(TimeValue waitForTimeout) {
-        request.waitForTimeout(waitForTimeout);
-        return this;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
index 714e7e5fc4427..d45e466543d21 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
@@ -25,9 +25,11 @@
 
 import java.io.IOException;
 import java.io.OutputStream;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
@@ -40,24 +42,59 @@ public class ProtobufClusterStateResponse extends ProtobufActionResponse impleme
 
     private ClusterStateResponseProto.ClusterStateRes clusterStateRes;
 
-    public ProtobufClusterStateResponse(ClusterName clusterName, ClusterState clusterState, boolean waitForTimedOut) {
+    // public ProtobufClusterStateResponse(ClusterName clusterName, ClusterState clusterState, boolean waitForTimedOut) {
+    //     ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Builder discoveryNodesBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.newBuilder();
+    //     DiscoveryNodes nodes = clusterState.getNodes();
+    //     ImmutableOpenMap<String, DiscoveryNode> allNodes = nodes.getNodes();
+
+    //     Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> allNodesMap = convertNodes(allNodes);
+    //     discoveryNodesBuilder.putAllAllNodes(allNodesMap).setClusterManagerNodeId(nodes.getClusterManagerNodeId()).setLocalNodeId(nodes.getLocalNodeId()).setMinNonClientNodeVersion(nodes.getSmallestNonClientNodeVersion().toString()).setMaxNonClientNodeVersion(nodes.getLargestNonClientNodeVersion().toString()).setMinNodeVersion(nodes.getMinNodeVersion().toString()).setMaxNodeVersion(nodes.getMaxNodeVersion().toString());
+
+    //     ClusterStateResponseProto.ClusterStateRes.ClusterState.Builder clusterStateBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.newBuilder();
+    //     clusterStateBuilder.setClusterName(clusterState.getClusterName().value())
+    //         .setVersion(clusterState.version())
+    //         .setStateUUID(clusterState.stateUUID())
+    //         .setNodes(discoveryNodesBuilder.build());
+    //     this.clusterStateRes = ClusterStateResponseProto.ClusterStateRes.newBuilder()
+    //                                         .setClusterName(clusterName.value())
+    //                                         .setClusterState(clusterStateBuilder.build())
+    //                                         .setWaitForTimedOut(waitForTimedOut)
+    //                                         .build();
+    // }
+
+    public ProtobufClusterStateResponse(String clusterName, DiscoveryNodes nodes, long version, String stateUUID, boolean waitForTimedOut) {
+        long startTime = System.nanoTime();
         ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Builder discoveryNodesBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.newBuilder();
-        DiscoveryNodes nodes = clusterState.getNodes();
-        ImmutableOpenMap<String, DiscoveryNode> allNodes = nodes.getNodes();
+        // ImmutableOpenMap<String, DiscoveryNode> allNodes = nodes.getNodes();
 
-        Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> allNodesMap = convertNodes(allNodes);
+        long startTime1 = System.nanoTime();
+        Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> allNodesMap = convertNodes(nodes.getNodes());
+        long endTime1 = System.nanoTime();
+        System.out.println("Time taken to convert nodes: " + (endTime1 - startTime1) + " ns");
+        long startTime2 = System.nanoTime();
         discoveryNodesBuilder.putAllAllNodes(allNodesMap).setClusterManagerNodeId(nodes.getClusterManagerNodeId()).setLocalNodeId(nodes.getLocalNodeId()).setMinNonClientNodeVersion(nodes.getSmallestNonClientNodeVersion().toString()).setMaxNonClientNodeVersion(nodes.getLargestNonClientNodeVersion().toString()).setMinNodeVersion(nodes.getMinNodeVersion().toString()).setMaxNodeVersion(nodes.getMaxNodeVersion().toString());
+        long endTime2 = System.nanoTime();
+        System.out.println("Time taken to discover nodes: " + (endTime2 - startTime2) + " ns");
 
+        long startTime3 = System.nanoTime();
         ClusterStateResponseProto.ClusterStateRes.ClusterState.Builder clusterStateBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.newBuilder();
-        clusterStateBuilder.setClusterName(clusterState.getClusterName().value())
-            .setVersion(clusterState.version())
-            .setStateUUID(clusterState.stateUUID())
+        clusterStateBuilder.setClusterName(clusterName)
+            .setVersion(version)
+            .setStateUUID(stateUUID)
             .setNodes(discoveryNodesBuilder.build());
+        long endTime3 = System.nanoTime();
+        System.out.println("Time taken to build cluster state: " + (endTime3 - startTime3) + " ns");
+
+        long startTime4 = System.nanoTime();
         this.clusterStateRes = ClusterStateResponseProto.ClusterStateRes.newBuilder()
-                                            .setClusterName(clusterName.value())
+                                            .setClusterName(clusterName)
                                             .setClusterState(clusterStateBuilder.build())
                                             .setWaitForTimedOut(waitForTimedOut)
                                             .build();
+        long endTime4 = System.nanoTime();
+        System.out.println("Time taken to build protobuf response: " + (endTime4 - startTime4) + " ns");
+        long endTime = System.nanoTime();
+        System.out.println("Time taken to build protobuf response: " + (endTime - startTime) + " ns");
     }
 
     private Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> convertNodes(ImmutableOpenMap<String, DiscoveryNode> nodes) {
@@ -65,11 +102,12 @@ private Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.Disco
         if (nodes.isEmpty()) {
             return convertedNodes;
         }
+        long startTime = System.nanoTime();
         Iterator<String> keysIt = nodes.keysIt();
         while(keysIt.hasNext()) {
             String key = keysIt.next();
             DiscoveryNode node = nodes.get(key);
-            Set<ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole> nodeRoles = new HashSet<>();
+            List<ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole> nodeRoles = new ArrayList<>();
             node.getRoles().forEach(role -> {
                 ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole.Builder nodeRoleBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole.newBuilder();
                 nodeRoleBuilder.setIsKnownRole(role.isKnownRole()).setIsDynamicRole(role.isDynamicRole()).setRoleName(role.roleName()).setRoleNameAbbreviation(role.roleNameAbbreviation()).setCanContainData(role.canContainData()).build();
@@ -80,6 +118,8 @@ private Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.Disco
             .setHostAddress(node.getHostAddress()).setTransportAddress(node.getAddress().toString()).putAllAttributes(node.getAttributes()).addAllRoles(nodeRoles).setVersion(node.getVersion().toString()).build();
             convertedNodes.put(key, nodeBuilder.build());
         }
+        long endTime = System.nanoTime();
+        System.out.println("Time taken to convert nodes in method: " + (endTime - startTime) + " ns");
         return convertedNodes;
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
index ec9698d755956..88b9da7dff8e3 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
@@ -103,7 +103,10 @@ protected void clusterManagerOperation(
             : acceptableClusterStatePredicate.or(clusterState -> clusterState.nodes().isLocalNodeElectedClusterManager() == false);
 
         if (acceptableClusterStatePredicate.test(state)) {
+            long startTime = System.nanoTime();
             ActionListener.completeWith(listener, () -> buildResponse(request, state));
+            long endTime = System.nanoTime();
+            System.out.println("Time taken to build response: " + (endTime - startTime));
         } else {
             assert acceptableClusterStateOrNotMasterPredicate.test(state) == false;
             new ClusterStateObserver(state, clusterService, request.waitForTimeout(), logger, threadPool.getThreadContext())
@@ -130,7 +133,7 @@ public void onClusterServiceClose() {
                     @Override
                     public void onTimeout(TimeValue timeout) {
                         try {
-                            listener.onResponse(new ProtobufClusterStateResponse(state.getClusterName(), null, true));
+                            listener.onResponse(new ProtobufClusterStateResponse(state.getClusterName().value(), null, 1, null, true));
                         } catch (Exception e) {
                             listener.onFailure(e);
                         }
@@ -140,68 +143,9 @@ public void onTimeout(TimeValue timeout) {
     }
 
     private ProtobufClusterStateResponse buildResponse(final ProtobufClusterStateRequest request, final ClusterState currentState) {
+        System.out.println("Coming in build response for cluster state");
         logger.trace("Serving cluster state request using version {}", currentState.version());
-        ClusterState.Builder builder = ClusterState.builder(currentState.getClusterName());
-        builder.version(currentState.version());
-        builder.stateUUID(currentState.stateUUID());
-
-        if (request.nodes()) {
-            builder.nodes(currentState.nodes());
-        }
-        if (request.routingTable()) {
-            if (request.indices().length > 0) {
-                RoutingTable.Builder routingTableBuilder = RoutingTable.builder();
-                String[] indices = indexNameExpressionResolver.concreteIndexNames(currentState, request);
-                for (String filteredIndex : indices) {
-                    if (currentState.routingTable().getIndicesRouting().containsKey(filteredIndex)) {
-                        routingTableBuilder.add(currentState.routingTable().getIndicesRouting().get(filteredIndex));
-                    }
-                }
-                builder.routingTable(routingTableBuilder.build());
-            } else {
-                builder.routingTable(currentState.routingTable());
-            }
-        }
-        if (request.blocks()) {
-            builder.blocks(currentState.blocks());
-        }
-
-        Metadata.Builder mdBuilder = Metadata.builder();
-        mdBuilder.clusterUUID(currentState.metadata().clusterUUID());
-        mdBuilder.coordinationMetadata(currentState.coordinationMetadata());
-
-        if (request.metadata()) {
-            if (request.indices().length > 0) {
-                mdBuilder.version(currentState.metadata().version());
-                String[] indices = indexNameExpressionResolver.concreteIndexNames(currentState, request);
-                for (String filteredIndex : indices) {
-                    IndexMetadata indexMetadata = currentState.metadata().index(filteredIndex);
-                    if (indexMetadata != null) {
-                        mdBuilder.put(indexMetadata, false);
-                    }
-                }
-            } else {
-                mdBuilder = Metadata.builder(currentState.metadata());
-            }
-
-            // filter out metadata that shouldn't be returned by the API
-            for (final Map.Entry<String, Custom> custom : currentState.metadata().customs().entrySet()) {
-                if (custom.getValue().context().contains(Metadata.XContentContext.API) == false) {
-                    mdBuilder.removeCustom(custom.getKey());
-                }
-            }
-        }
-        builder.metadata(mdBuilder);
-
-        if (request.customs()) {
-            for (ObjectObjectCursor<String, ClusterState.Custom> custom : currentState.customs()) {
-                if (custom.value.isPrivate() == false) {
-                    builder.putCustom(custom.key, custom.value);
-                }
-            }
-        }
-
-        return new ProtobufClusterStateResponse(currentState.getClusterName(), builder.build(), false);
+        return new ProtobufClusterStateResponse(currentState.getClusterName().value(), currentState.nodes(), currentState.version(), currentState.stateUUID(), false);
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
index 05e817b4e9339..e4232767d1246 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
@@ -129,7 +129,10 @@ protected void clusterManagerOperation(
             : acceptableClusterStatePredicate.or(clusterState -> clusterState.nodes().isLocalNodeElectedClusterManager() == false);
 
         if (acceptableClusterStatePredicate.test(state)) {
+            long startTime = System.nanoTime();
             ActionListener.completeWith(listener, () -> buildResponse(request, state));
+            long endTime = System.nanoTime();
+            System.out.println("Time taken to build response: " + (endTime - startTime));
         } else {
             assert acceptableClusterStateOrNotMasterPredicate.test(state) == false;
             new ClusterStateObserver(state, clusterService, request.waitForTimeout(), logger, threadPool.getThreadContext())
@@ -166,6 +169,7 @@ public void onTimeout(TimeValue timeout) {
     }
 
     private ClusterStateResponse buildResponse(final ClusterStateRequest request, final ClusterState currentState) {
+        System.out.println("Coming in build response for cluster state");
         logger.trace("Serving cluster state request using version {}", currentState.version());
         ClusterState.Builder builder = ClusterState.builder(currentState.getClusterName());
         builder.version(currentState.version());
diff --git a/server/src/main/java/org/opensearch/client/ProtobufClusterAdminClient.java b/server/src/main/java/org/opensearch/client/ProtobufClusterAdminClient.java
index 5f8fdcbfdcfd1..d3977cc74a6d5 100644
--- a/server/src/main/java/org/opensearch/client/ProtobufClusterAdminClient.java
+++ b/server/src/main/java/org/opensearch/client/ProtobufClusterAdminClient.java
@@ -15,7 +15,6 @@
 import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsRequest;
 import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsResponse;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
-import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequestBuilder;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
 
 /**
@@ -45,11 +44,6 @@ public interface ProtobufClusterAdminClient extends ProtobufOpenSearchClient {
     */
     void state(ProtobufClusterStateRequest request, ActionListener<ProtobufClusterStateResponse> listener);
 
-    /**
-     * The state of the cluster.
-    */
-    ProtobufClusterStateRequestBuilder prepareState();
-
     /**
      * Nodes info of the cluster.
     *
diff --git a/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java b/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
index bd8ca5e79178a..740b28d6a894c 100644
--- a/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
+++ b/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
@@ -22,7 +22,6 @@
 import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsRequest;
 import org.opensearch.action.admin.cluster.node.stats.ProtobufNodesStatsResponse;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateAction;
-import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequestBuilder;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
 import org.opensearch.action.support.PlainActionFuture;
@@ -151,11 +150,6 @@ public void state(final ProtobufClusterStateRequest request, final ActionListene
             execute(ProtobufClusterStateAction.INSTANCE, request, listener);
         }
 
-        @Override
-        public ProtobufClusterStateRequestBuilder prepareState() {
-            return new ProtobufClusterStateRequestBuilder(this, ProtobufClusterStateAction.INSTANCE);
-        }
-
         @Override
         public ActionFuture<ProtobufNodesInfoResponse> nodesInfo(final ProtobufNodesInfoRequest request) {
             return execute(ProtobufNodesInfoAction.INSTANCE, request);
diff --git a/server/src/main/java/org/opensearch/rest/BaseRestHandler.java b/server/src/main/java/org/opensearch/rest/BaseRestHandler.java
index bcfff383f5199..c93025ecf9728 100644
--- a/server/src/main/java/org/opensearch/rest/BaseRestHandler.java
+++ b/server/src/main/java/org/opensearch/rest/BaseRestHandler.java
@@ -105,8 +105,12 @@ public final long getUsageCount() {
     public final void handleRequest(RestRequest request, RestChannel channel, NodeClient client) throws Exception {
         logger.info("BaseRestHandler.handleRequest {}", request);
         // prepare the request for execution; has the side effect of touching the request parameters
+        long startTime = System.nanoTime();
         final RestChannelConsumer action = prepareRequest(request, client);
+        long endTime = System.nanoTime();
+        System.out.println("Preparing request took: " + (endTime-startTime));
         logger.info("BaseRestHandler.handleRequest action: {}", action);
+        System.out.println("Action: " + action);
 
         // validate unconsumed params, but we must exclude params used to format the response
         // use a sorted set so the unconsumed parameters appear in a reliable sorted order
diff --git a/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java b/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java
index 6bc78abee594b..dbf9c03887144 100644
--- a/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java
+++ b/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java
@@ -79,8 +79,12 @@ public final long getUsageCount() {
     public final void handleRequest(RestRequest request, RestChannel channel, ProtobufNodeClient client) throws Exception {
         logger.info("ProtobufBaseRestHandler.handleRequest {}", request);
         // prepare the request for execution; has the side effect of touching the request parameters
+        long startTime = System.nanoTime();
         final RestChannelConsumer action = prepareRequest(request, client);
+        long endTime = System.nanoTime();
+        System.out.println("Preparing request took: " + (endTime-startTime));
         logger.info("ProtobufBaseRestHandler.handleRequest action: {}", action.getClass().getName());
+        System.out.println("Action: " + action);
 
         // validate unconsumed params, but we must exclude params used to format the response
         // use a sorted set so the unconsumed parameters appear in a reliable sorted order
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
index e34629d223aa6..40b815c884ce3 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
@@ -62,7 +62,7 @@ public ProtobufTaskId(String taskId) {
 
     /**
      * Read a {@linkplain ProtobufTaskId} from a stream. {@linkplain ProtobufTaskId} has this rather than the usual constructor that takes a
-    * {@linkplain CodedInputStream} so we can return the {@link #EMPTY_TASK_ID} without allocating.
+    * {@linkplain byte[]} so we can return the {@link #EMPTY_TASK_ID} without allocating.
     */
     public ProtobufTaskId(byte[] in) throws IOException {
         this.taskId = TaskIdProto.TaskId.parseFrom(in);
diff --git a/server/src/main/java/org/opensearch/transport/OutboundHandler.java b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
index f2d019424fe50..3d56ae1f67178 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
@@ -136,6 +136,7 @@ void sendRequest(
         );
 
         ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onRequestSent(node, requestId, action, request, options));
+        long startTime = System.nanoTime();
         if (request.getClass().getCanonicalName().contains("ProtobufClusterState")) {
             // ExampleProtoRequest exampleProtoRequest = new ExampleProtoRequest(1, "message");
             ProtobufClusterStateRequest protobufClusterStateRequest = (ProtobufClusterStateRequest) request;
@@ -143,20 +144,28 @@ void sendRequest(
             bytes[0] = 0;
             ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufClusterStateRequest.request(), features, action);
             sendProtobufMessage(channel, protobufMessage, listener);
+            long endTime = System.nanoTime();
+            System.out.println("Time for sending protobuf cluster state req: " + (endTime-startTime));
         } else if (request.getClass().getCanonicalName().contains("ProtobufTransportNodesInfo")) {
             NodeInfoRequest protobufNodesInfoRequest = (NodeInfoRequest) request;
             byte[] bytes = new byte[1];
             bytes[0] = 0;
             ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufNodesInfoRequest.request().request(), features, action);
             sendProtobufMessage(channel, protobufMessage, listener);
+            long endTime = System.nanoTime();
+            System.out.println("Time for sending protobuf node info req: " + (endTime-startTime));
         } else if (request.getClass().getCanonicalName().contains("ProtobufTransportNodesStats")) {
             NodeStatsRequest protobufNodesStatsRequest = (NodeStatsRequest) request;
             byte[] bytes = new byte[1];
             bytes[0] = 0;
             ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufNodesStatsRequest.request().request(), features, action);
             sendProtobufMessage(channel, protobufMessage, listener);
+            long endTime = System.nanoTime();
+            System.out.println("Time for sending protobuf node stats req: " + (endTime-startTime));
         } else {
             sendMessage(channel, message, listener);
+            long endTime = System.nanoTime();
+            System.out.println("Time for sending normal req: " + (endTime-startTime));
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
index d6ca419277637..451acd1aa21d9 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
@@ -61,8 +61,11 @@ public Request newRequest(byte[] in) throws IOException {
     }
 
     public void processMessageReceived(Request request, TransportChannel channel) throws Exception {
+        long startTime = System.nanoTime();
         final ProtobufTask task = taskManager.registerProtobuf(channel.getChannelType(), action, request);
         ThreadContext.StoredContext contextToRestore = taskManager.protobufTaskExecutionStarted(task);
+        long endTime = System.nanoTime();
+        System.out.println("taskManager.registerProtobuf: " + (endTime - startTime));
 
         Releasable unregisterTask = () -> taskManager.unregisterProtobufTask(task);
         try {
diff --git a/server/src/main/java/org/opensearch/transport/RequestHandlerRegistry.java b/server/src/main/java/org/opensearch/transport/RequestHandlerRegistry.java
index bd1ccda2cbe30..5a3bbc80c0266 100644
--- a/server/src/main/java/org/opensearch/transport/RequestHandlerRegistry.java
+++ b/server/src/main/java/org/opensearch/transport/RequestHandlerRegistry.java
@@ -86,8 +86,11 @@ public Request newRequest(StreamInput in) throws IOException {
     }
 
     public void processMessageReceived(Request request, TransportChannel channel) throws Exception {
+        long startTime = System.nanoTime();
         final Task task = taskManager.register(channel.getChannelType(), action, request);
         ThreadContext.StoredContext contextToRestore = taskManager.taskExecutionStarted(task);
+        long endTime = System.nanoTime();
+        System.out.println("processMessageReceived: " + (endTime - startTime));
 
         Releasable unregisterTask = () -> taskManager.unregister(task);
         try {

From 562e6c37689bbbc91443249b3d0d828f839e6c77 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Tue, 1 Aug 2023 21:56:33 +0000
Subject: [PATCH 25/37] Cleaning up CodedInputStream, CodedOutputStream and
 TryWriteable

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../src/main/java/org/opensearch/Build.java   |  26 ---
 .../src/main/java/org/opensearch/Version.java |   5 -
 .../common/bytes/AbstractBytesReference.java  |   9 -
 .../core/common/bytes/BytesArray.java         |   6 -
 .../core/common/bytes/BytesReference.java     |   7 -
 .../org/opensearch/core/rest/RestStatus.java  |  10 -
 ...ProtobufActionListenerResponseHandler.java |   9 +-
 .../action/ProtobufActionResponse.java        |   1 -
 .../opensearch/action/ProtobufActionType.java |   8 +-
 .../cluster/node/info/ProtobufNodeInfo.java   |   3 +-
 .../node/info/ProtobufNodesInfoRequest.java   |   3 +-
 .../node/info/ProtobufNodesInfoResponse.java  |   6 +-
 .../ProtobufTransportNodesInfoAction.java     |   6 +-
 .../cluster/node/stats/ProtobufNodeStats.java |   5 +-
 .../node/stats/ProtobufNodesStatsRequest.java |   5 +-
 .../stats/ProtobufNodesStatsResponse.java     |   7 +-
 .../ProtobufTransportNodesStatsAction.java    |   7 +-
 .../state/ProtobufClusterStateRequest.java    |   5 +-
 .../state/ProtobufClusterStateResponse.java   |  70 ++----
 .../ProtobufTransportClusterStateAction.java  |   4 -
 .../state/TransportClusterStateAction.java    |   3 -
 .../datastream/GetDataStreamAction.java       |   2 -
 .../admin/indices/rollover/RolloverInfo.java  |   2 -
 ...TransportFieldCapabilitiesIndexAction.java |   1 -
 .../action/main/ProtobufMainResponse.java     |   2 -
 .../TransportResyncReplicationAction.java     |   2 -
 .../opensearch/action/search/PitService.java  |   1 -
 .../action/support/IndicesOptions.java        |   2 -
 .../broadcast/TransportBroadcastAction.java   |   2 -
 .../node/TransportBroadcastByNodeAction.java  |   2 -
 ...obufTransportClusterManagerNodeAction.java |   1 -
 .../nodes/ProtobufBaseNodesRequest.java       |   2 -
 .../nodes/ProtobufBaseNodesResponse.java      |   3 -
 .../nodes/ProtobufTransportNodesAction.java   |   1 -
 .../support/nodes/TransportNodesAction.java   |   2 -
 .../TransportReplicationAction.java           |   2 -
 ...ransportInstanceSingleOperationAction.java |   2 -
 .../shard/TransportSingleShardAction.java     |   2 -
 .../support/tasks/TransportTasksAction.java   |   2 -
 .../opensearch/cluster/AbstractDiffable.java  |   4 -
 .../org/opensearch/cluster/ClusterName.java   |   6 -
 .../cluster/block/ClusterBlocks.java          |   1 -
 .../coordination/FollowersChecker.java        |   2 -
 .../cluster/coordination/JoinHelper.java      |   2 -
 .../cluster/coordination/LeaderChecker.java   |   2 -
 .../coordination/PreVoteCollector.java        |   2 -
 .../PublicationTransportHandler.java          |   2 -
 .../decommission/DecommissionController.java  |   2 -
 .../cluster/metadata/AliasMetadata.java       |   2 -
 .../cluster/metadata/ComponentTemplate.java   |   2 -
 .../metadata/ComposableIndexTemplate.java     |   2 -
 .../cluster/metadata/DataStream.java          |   2 -
 .../metadata/IndexTemplateMetadata.java       |   1 -
 .../opensearch/cluster/metadata/Metadata.java |  26 ---
 .../opensearch/cluster/metadata/Template.java |   2 -
 .../cluster/node/DiscoveryNode.java           |   4 -
 .../cluster/routing/AllocationId.java         |   4 -
 .../cluster/routing/RoutingTable.java         |   1 -
 .../cluster/routing/ShardRouting.java         |   4 -
 .../cluster/routing/UnassignedInfo.java       |  25 ---
 .../bytes/ReleasableBytesReference.java       |   7 -
 .../common/io/stream/TryWriteable.java        |   7 +-
 .../opensearch/common/settings/Settings.java  |  29 ---
 .../transport/BoundTransportAddress.java      |   4 -
 .../common/util/concurrent/ThreadContext.java |   3 -
 .../org/opensearch/discovery/PeerFinder.java  |   1 -
 .../example/proto/ExampleProtoRequest.java    |   1 -
 .../extensions/ExtensionsManager.java         |   2 -
 .../UpdateSettingsResponseHandler.java        |   2 -
 .../ExtensionTransportActionsHandler.java     |   2 -
 .../rest/RestSendToExtensionAction.java       |   2 -
 .../RetentionLeaseBackgroundSyncAction.java   |   2 -
 .../index/seqno/RetentionLeaseSyncAction.java |   2 -
 .../recovery/PeerRecoveryTargetService.java   |   2 -
 .../checkpoint/PublishCheckpointAction.java   |   2 -
 .../indices/store/IndicesStore.java           |   2 -
 .../ingest/PipelineConfiguration.java         |   2 -
 .../org/opensearch/monitor/jvm/JvmInfo.java   |   5 -
 .../org/opensearch/rest/BaseRestHandler.java  |   4 -
 .../rest/ProtobufBaseRestHandler.java         |   4 -
 .../org/opensearch/rest/RestController.java   |   5 -
 .../action/cat/ProtobufRestNodesAction.java   |   2 +-
 .../opensearch/script/StoredScriptSource.java |   2 -
 .../pipeline/PipelineConfiguration.java       |   2 -
 .../snapshots/SnapshotShardsService.java      |   1 -
 .../ProtobufTaskCancellationService.java      |   2 -
 .../org/opensearch/tasks/ProtobufTaskId.java  |   2 -
 .../opensearch/tasks/ProtobufTaskInfo.java    |   3 -
 .../opensearch/tasks/ProtobufTaskResult.java  |   2 -
 .../EmptyTransportResponseHandler.java        |   2 -
 .../opensearch/transport/InboundHandler.java  |   9 +-
 .../opensearch/transport/OutboundHandler.java |  24 +--
 .../ProtobufRequestHandlerRegistry.java       |   4 -
 .../transport/RemoteClusterConnection.java    |   2 -
 .../transport/RequestHandlerRegistry.java     |   3 -
 .../transport/SniffConnectionStrategy.java    |   2 -
 .../org/opensearch/transport/TcpHeader.java   |  18 --
 .../transport/TransportActionProxy.java       |   2 -
 .../transport/TransportHandshaker.java        |   2 -
 .../transport/TransportMessage.java           |   4 +-
 .../transport/TransportRequest.java           |   3 -
 .../transport/TransportResponse.java          |   3 -
 .../transport/TransportResponseHandler.java   |   3 +-
 .../transport/TransportService.java           |   4 -
 .../server/ClusterStateResponseProto.proto    |   2 +-
 ...tAddVotingConfigExclusionsActionTests.java |  10 +-
 ...learVotingConfigExclusionsActionTests.java |  10 +-
 ...ReplicationAllPermitsAcquisitionTests.java |  10 +-
 .../coordination/CoordinatorTests.java        |   8 -
 .../coordination/FollowersCheckerTests.java   |  32 +--
 .../coordination/LeaderCheckerTests.java      |  10 +-
 .../coordination/PreVoteCollectorTests.java   |  10 +-
 .../cluster/serialization/DiffableTests.java  |   7 -
 .../opensearch/discovery/PeerFinderTests.java |  10 +-
 .../SegmentReplicationSourceServiceTests.java |  17 +-
 .../transport/InboundHandlerTests.java        |  37 +---
 .../transport/TransportActionProxyTests.java  |  16 +-
 ...ortServiceDeserializationFailureTests.java |  16 +-
 .../AbstractSimpleTransportTestCase.java      | 199 +++---------------
 .../DisruptableMockTransportTests.java        |  24 +--
 .../test/disruption/NetworkDisruptionIT.java  |   5 +-
 121 files changed, 101 insertions(+), 849 deletions(-)

diff --git a/libs/core/src/main/java/org/opensearch/Build.java b/libs/core/src/main/java/org/opensearch/Build.java
index 8a2d3e94bc0ec..dd238e8684c87 100644
--- a/libs/core/src/main/java/org/opensearch/Build.java
+++ b/libs/core/src/main/java/org/opensearch/Build.java
@@ -32,8 +32,6 @@
 
 package org.opensearch;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import org.opensearch.common.Booleans;
 import org.opensearch.core.util.FileSystemUtils;
 
@@ -220,18 +218,6 @@ public static Build readBuild(StreamInput in) throws IOException {
         return new Build(type, hash, date, snapshot, version, distribution);
     }
 
-    public static Build readBuildProtobuf(CodedInputStream in) throws IOException {
-        // the following is new for opensearch: we write the distribution to support any "forks"
-        final String distribution = in.readString();
-        // be lenient when reading on the wire, the enumeration values from other versions might be different than what we know
-        final Type type = Type.fromDisplayName(in.readString(), false);
-        String hash = in.readString();
-        String date = in.readString();
-        boolean snapshot = in.readBool();
-        final String version = in.readString();
-        return new Build(type, hash, date, snapshot, version, distribution);
-    }
-
     public static void writeBuild(Build build, StreamOutput out) throws IOException {
         // the following is new for opensearch: we write the distribution name to support any "forks" of the code
         out.writeString(build.distribution);
@@ -244,18 +230,6 @@ public static void writeBuild(Build build, StreamOutput out) throws IOException
         out.writeString(build.getQualifiedVersion());
     }
 
-    public static void writeBuildProtobuf(Build build, CodedOutputStream out) throws IOException {
-        // the following is new for opensearch: we write the distribution name to support any "forks" of the code
-        out.writeStringNoTag(build.distribution);
-
-        final Type buildType = build.type();
-        out.writeStringNoTag(buildType.displayName());
-        out.writeStringNoTag(build.hash());
-        out.writeStringNoTag(build.date());
-        out.writeBoolNoTag(build.isSnapshot());
-        out.writeStringNoTag(build.getQualifiedVersion());
-    }
-
     /**
      * Get the distribution name (expected to be OpenSearch; empty if legacy; something else if forked)
      * @return distribution name as a string
diff --git a/libs/core/src/main/java/org/opensearch/Version.java b/libs/core/src/main/java/org/opensearch/Version.java
index b1cba4f2b69fc..3f83282245fd8 100644
--- a/libs/core/src/main/java/org/opensearch/Version.java
+++ b/libs/core/src/main/java/org/opensearch/Version.java
@@ -32,7 +32,6 @@
 
 package org.opensearch;
 
-import com.google.protobuf.CodedInputStream;
 import org.opensearch.common.SuppressForbidden;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
@@ -96,10 +95,6 @@ public class Version implements Comparable<Version>, ToXContentFragment {
     public static final Version V_3_0_0 = new Version(3000099, org.apache.lucene.util.Version.LUCENE_9_8_0);
     public static final Version CURRENT = V_3_0_0;
 
-    public static Version readVersionProtobuf(CodedInputStream in) throws IOException {
-        return fromId(in.readInt32());
-    }
-
     public static Version fromId(int id) {
         final Version known = LegacyESVersion.idToVersion.get(id);
         if (known != null) {
diff --git a/libs/core/src/main/java/org/opensearch/core/common/bytes/AbstractBytesReference.java b/libs/core/src/main/java/org/opensearch/core/common/bytes/AbstractBytesReference.java
index 3ff94bca580c1..e054776d67fdc 100644
--- a/libs/core/src/main/java/org/opensearch/core/common/bytes/AbstractBytesReference.java
+++ b/libs/core/src/main/java/org/opensearch/core/common/bytes/AbstractBytesReference.java
@@ -37,8 +37,6 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.xcontent.XContentBuilder;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.EOFException;
 import java.io.IOException;
 import java.io.OutputStream;
@@ -75,13 +73,6 @@ public StreamInput streamInput() throws IOException {
         return new BytesReferenceStreamInput();
     }
 
-    @Override
-    public CodedInputStream protobufInput() throws IOException {
-        return CodedInputStream.newInstance(streamInput());
-        // TODO Auto-generated method stub
-        // throw new UnsupportedOperationException("Unimplemented method 'protobufInput'");
-    }
-
     @Override
     public void writeTo(OutputStream os) throws IOException {
         final BytesRefIterator iterator = iterator();
diff --git a/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesArray.java b/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesArray.java
index 6b8939a59c79b..39447b63f9730 100644
--- a/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesArray.java
+++ b/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesArray.java
@@ -35,8 +35,6 @@
 import org.apache.lucene.util.BytesRef;
 import org.opensearch.core.common.io.stream.StreamInput;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.Arrays;
@@ -146,8 +144,4 @@ public void writeTo(OutputStream os) throws IOException {
         os.write(bytes, offset, length);
     }
 
-    @Override
-    public CodedInputStream protobufInput() throws IOException {
-        return CodedInputStream.newInstance(bytes, offset, length);
-    }
 }
diff --git a/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesReference.java b/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesReference.java
index 3d236a42bc834..fc8e62c914e27 100644
--- a/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesReference.java
+++ b/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesReference.java
@@ -41,8 +41,6 @@
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
@@ -185,11 +183,6 @@ static BytesReference fromByteArray(ByteArray byteArray, int length) {
      */
     StreamInput streamInput() throws IOException;
 
-    /**
-     * A stream input of the bytes.
-     */
-    CodedInputStream protobufInput() throws IOException;
-
     /**
      * Writes the bytes directly to the output stream.
      */
diff --git a/libs/core/src/main/java/org/opensearch/core/rest/RestStatus.java b/libs/core/src/main/java/org/opensearch/core/rest/RestStatus.java
index 466d550938505..ae4f4c65b28d2 100644
--- a/libs/core/src/main/java/org/opensearch/core/rest/RestStatus.java
+++ b/libs/core/src/main/java/org/opensearch/core/rest/RestStatus.java
@@ -32,8 +32,6 @@
 
 package org.opensearch.core.rest;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import org.opensearch.core.action.ShardOperationFailedException;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
@@ -535,14 +533,6 @@ public static void writeTo(StreamOutput out, RestStatus status) throws IOExcepti
         out.writeString(status.name());
     }
 
-    public static RestStatus readFromProtobuf(CodedInputStream in) throws IOException {
-        return RestStatus.valueOf(in.readString());
-    }
-
-    public static void writeToProtobuf(CodedOutputStream out, RestStatus status) throws IOException {
-        out.writeStringNoTag(status.name());
-    }
-
     public static RestStatus status(int successfulShards, int totalShards, ShardOperationFailedException... failures) {
         if (failures.length == 0) {
             if (successfulShards == 0 && totalShards > 0) {
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java b/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
index b9282dee63996..9fe65474a028e 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
@@ -8,9 +8,8 @@
 
 package org.opensearch.action;
 
-import com.google.protobuf.CodedInputStream;
 import org.opensearch.common.io.stream.StreamInput;
-import org.opensearch.common.io.stream.TryWriteable;
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportException;
@@ -30,12 +29,12 @@ public class ProtobufActionListenerResponseHandler<Response extends TransportRes
         TransportResponseHandler<Response> {
 
     private final ActionListener<? super Response> listener;
-    private final TryWriteable.Reader<Response> reader;
+    private final ProtobufWriteable.Reader<Response> reader;
     private final String executor;
 
     public ProtobufActionListenerResponseHandler(
         ActionListener<? super Response> listener,
-        TryWriteable.Reader<Response> reader,
+        ProtobufWriteable.Reader<Response> reader,
         String executor
     ) {
         this.listener = Objects.requireNonNull(listener);
@@ -43,7 +42,7 @@ public ProtobufActionListenerResponseHandler(
         this.executor = Objects.requireNonNull(executor);
     }
 
-    public ProtobufActionListenerResponseHandler(ActionListener<? super Response> listener, TryWriteable.Reader<Response> reader) {
+    public ProtobufActionListenerResponseHandler(ActionListener<? super Response> listener, ProtobufWriteable.Reader<Response> reader) {
         this(listener, reader, ThreadPool.Names.SAME);
     }
 
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java b/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java
index 8a3a0d4ff1cc6..324ad41ebdea9 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java
@@ -13,7 +13,6 @@
 
 package org.opensearch.action;
 
-import com.google.protobuf.CodedInputStream;
 import org.opensearch.transport.TransportResponse;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionType.java b/server/src/main/java/org/opensearch/action/ProtobufActionType.java
index ed8297fa3b176..b28ce7575c765 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionType.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionType.java
@@ -8,7 +8,7 @@
 
 package org.opensearch.action;
 
-import org.opensearch.common.io.stream.TryWriteable;
+import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.transport.TransportRequestOptions;
 
@@ -20,13 +20,13 @@
 public class ProtobufActionType<Response extends ProtobufActionResponse> {
 
     private final String name;
-    private final TryWriteable.Reader<Response> responseReader;
+    private final ProtobufWriteable.Reader<Response> responseReader;
 
     /**
      * @param name The name of the action, must be unique across actions.
     * @param responseReader A reader for the response type
     */
-    public ProtobufActionType(String name, TryWriteable.Reader<Response> responseReader) {
+    public ProtobufActionType(String name, ProtobufWriteable.Reader<Response> responseReader) {
         this.name = name;
         this.responseReader = responseReader;
     }
@@ -41,7 +41,7 @@ public String name() {
     /**
      * Get a reader that can create a new instance of the class from a {@link org.opensearch.common.io.stream.StreamInput}
     */
-    public TryWriteable.Reader<Response> getResponseReaderTry() {
+    public ProtobufWriteable.Reader<Response> getResponseReaderTry() {
         return responseReader;
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
index 248b218af57da..8a60d01dbf8ec 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
@@ -20,7 +20,6 @@
 import org.opensearch.action.support.nodes.ProtobufBaseNodeResponse;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.Nullable;
-import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.ByteSizeValue;
 import org.opensearch.http.HttpInfo;
@@ -45,7 +44,7 @@
 *
 * @opensearch.internal
 */
-public class ProtobufNodeInfo extends ProtobufBaseNodeResponse implements TryWriteable {
+public class ProtobufNodeInfo extends ProtobufBaseNodeResponse {
 
     private Version version;
     private Build build;
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
index 1529711d947e5..5d47ec213dc29 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
@@ -14,7 +14,6 @@
 package org.opensearch.action.admin.cluster.node.info;
 
 import org.opensearch.action.support.nodes.ProtobufBaseNodesRequest;
-import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.server.proto.NodesInfoRequestProto.NodesInfoReq;
 import org.opensearch.server.proto.NodesInfoRequestProto;
@@ -33,7 +32,7 @@
  *
  * @opensearch.internal
  */
-public class ProtobufNodesInfoRequest extends ProtobufBaseNodesRequest<ProtobufNodesInfoRequest> implements TryWriteable {
+public class ProtobufNodesInfoRequest extends ProtobufBaseNodesRequest<ProtobufNodesInfoRequest> {
 
     private NodesInfoRequestProto.NodesInfoReq nodesInfoRequest;
     private final TimeValue DEFAULT_TIMEOUT_SECS = TimeValue.timeValueSeconds(30);
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
index 923d33a656f27..400ed014fb679 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
@@ -32,21 +32,17 @@
 
 package org.opensearch.action.admin.cluster.node.info;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 
 import org.opensearch.action.FailedNodeException;
 import org.opensearch.action.support.nodes.ProtobufBaseNodesResponse;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.common.Strings;
-import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.xcontent.XContentFactory;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.server.proto.NodesInfoResponseProto;
-import org.opensearch.server.proto.ClusterStateResponseProto;
 import org.opensearch.server.proto.NodesInfoProto.NodesInfo;
 import java.io.IOException;
 import java.io.OutputStream;
@@ -60,7 +56,7 @@
 *
 * @opensearch.internal
 */
-public class ProtobufNodesInfoResponse extends ProtobufBaseNodesResponse<ProtobufNodeInfo> implements ToXContentFragment, TryWriteable {
+public class ProtobufNodesInfoResponse extends ProtobufBaseNodesResponse<ProtobufNodeInfo> implements ToXContentFragment {
 
     private NodesInfoResponseProto.NodesInfoRes nodesInfoRes;
     private Map<String, NodesInfo> nodesMap = new HashMap<>();
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
index 62525c3326b07..a420d4fe65486 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufTransportNodesInfoAction.java
@@ -8,16 +8,12 @@
 
 package org.opensearch.action.admin.cluster.node.info;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import org.opensearch.action.FailedNodeException;
 import org.opensearch.action.support.ProtobufActionFilters;
 import org.opensearch.action.support.nodes.ProtobufTransportNodesAction;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.inject.Inject;
-import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.node.ProtobufNodeService;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportRequest;
@@ -103,7 +99,7 @@ protected ProtobufNodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
     *
     * @opensearch.internal
     */
-    public static class NodeInfoRequest extends TransportRequest implements TryWriteable {
+    public static class NodeInfoRequest extends TransportRequest {
 
         ProtobufNodesInfoRequest request;
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
index 4a0fd77285979..3e6073f380e27 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
@@ -8,15 +8,12 @@
 
 package org.opensearch.action.admin.cluster.node.stats;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import com.google.protobuf.InvalidProtocolBufferException;
 
 import org.opensearch.action.support.nodes.ProtobufBaseNodeResponse;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.common.Nullable;
-import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.discovery.DiscoveryStats;
@@ -46,7 +43,7 @@
 *
 * @opensearch.internal
 */
-public class ProtobufNodeStats extends ProtobufBaseNodeResponse implements ToXContentFragment, TryWriteable {
+public class ProtobufNodeStats extends ProtobufBaseNodeResponse implements ToXContentFragment {
 
     private long timestamp;
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
index ff83416d94c3b..89543c2c2ca85 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
@@ -8,11 +8,8 @@
 
 package org.opensearch.action.admin.cluster.node.stats;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
 import org.opensearch.action.support.nodes.ProtobufBaseNodesRequest;
-import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.server.proto.NodesStatsRequestProto.NodesStatsReq;
 import org.opensearch.server.proto.NodesStatsRequestProto;
 
@@ -30,7 +27,7 @@
 *
 * @opensearch.internal
 */
-public class ProtobufNodesStatsRequest extends ProtobufBaseNodesRequest<ProtobufNodesStatsRequest> implements TryWriteable {
+public class ProtobufNodesStatsRequest extends ProtobufBaseNodesRequest<ProtobufNodesStatsRequest> {
 
     private CommonStatsFlags indices = new CommonStatsFlags();
     private final Set<String> requestedMetrics = new HashSet<>();
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
index ca4d8270d6115..23808c8a04e13 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
@@ -8,18 +8,13 @@
 
 package org.opensearch.action.admin.cluster.node.stats;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import org.opensearch.action.FailedNodeException;
 import org.opensearch.action.support.nodes.ProtobufBaseNodesResponse;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.common.Strings;
-import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.server.proto.NodesStatsResponseProto;
-import org.opensearch.server.proto.NodesInfoResponseProto;
 import org.opensearch.server.proto.NodesStatsProto.NodesStats;
 import org.opensearch.common.xcontent.XContentFactory;
 
@@ -35,7 +30,7 @@
 *
 * @opensearch.internal
 */
-public class ProtobufNodesStatsResponse extends ProtobufBaseNodesResponse<ProtobufNodeStats> implements ToXContentFragment, TryWriteable {
+public class ProtobufNodesStatsResponse extends ProtobufBaseNodesResponse<ProtobufNodeStats> implements ToXContentFragment {
 
     private NodesStatsResponseProto.NodesStatsRes nodesStatsRes;
     private Map<String, NodesStats> nodesMap = new HashMap<>();
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
index 0b84839346635..0fd8b758e4c22 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufTransportNodesStatsAction.java
@@ -8,17 +8,12 @@
 
 package org.opensearch.action.admin.cluster.node.stats;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import org.opensearch.action.FailedNodeException;
-import org.opensearch.action.admin.cluster.node.info.ProtobufNodeInfo;
 import org.opensearch.action.support.ProtobufActionFilters;
 import org.opensearch.action.support.nodes.ProtobufTransportNodesAction;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.inject.Inject;
-import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.node.ProtobufNodeService;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportRequest;
@@ -112,7 +107,7 @@ protected ProtobufNodeStats nodeOperation(NodeStatsRequest nodeStatsRequest) {
     *
     * @opensearch.internal
     */
-    public static class NodeStatsRequest extends TransportRequest implements TryWriteable {
+    public static class NodeStatsRequest extends TransportRequest {
 
         ProtobufNodesStatsRequest request;
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
index c915c77c54ccb..dee9b934b51fe 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
@@ -13,14 +13,11 @@
 
 package org.opensearch.action.admin.cluster.state;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import org.opensearch.action.ActionRequestValidationException;
 import org.opensearch.action.IndicesRequest;
 import org.opensearch.action.support.IndicesOptions;
 import org.opensearch.action.support.clustermanager.ProtobufClusterManagerNodeReadRequest;
 import org.opensearch.common.Strings;
-import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.server.proto.ClusterStateRequestProto;
 import org.opensearch.server.proto.ClusterStateRequestProto.ClusterStateReq;
@@ -37,7 +34,7 @@
 */
 public class ProtobufClusterStateRequest extends ProtobufClusterManagerNodeReadRequest<ProtobufClusterStateRequest>
     implements
-        IndicesRequest.Replaceable, TryWriteable {
+        IndicesRequest.Replaceable {
 
     public static final TimeValue DEFAULT_WAIT_FOR_NODE_TIMEOUT = TimeValue.timeValueMinutes(1);
     private ClusterStateRequestProto.ClusterStateReq clusterStateRequest;
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
index d45e466543d21..d580e30575b77 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
@@ -13,13 +13,15 @@
 
 package org.opensearch.action.admin.cluster.state;
 
+import com.carrotsearch.hppc.cursors.ObjectCursor;
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.AliasMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.RoutingNode;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.common.collect.ImmutableOpenMap;
-import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.server.proto.ClusterStateResponseProto;
 import org.opensearch.server.proto.ClusterStateResponseProto.ClusterStateRes;
 
@@ -38,88 +40,44 @@
 *
 * @opensearch.internal
 */
-public class ProtobufClusterStateResponse extends ProtobufActionResponse implements TryWriteable {
+public class ProtobufClusterStateResponse extends ProtobufActionResponse {
 
     private ClusterStateResponseProto.ClusterStateRes clusterStateRes;
 
-    // public ProtobufClusterStateResponse(ClusterName clusterName, ClusterState clusterState, boolean waitForTimedOut) {
-    //     ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Builder discoveryNodesBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.newBuilder();
-    //     DiscoveryNodes nodes = clusterState.getNodes();
-    //     ImmutableOpenMap<String, DiscoveryNode> allNodes = nodes.getNodes();
-
-    //     Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> allNodesMap = convertNodes(allNodes);
-    //     discoveryNodesBuilder.putAllAllNodes(allNodesMap).setClusterManagerNodeId(nodes.getClusterManagerNodeId()).setLocalNodeId(nodes.getLocalNodeId()).setMinNonClientNodeVersion(nodes.getSmallestNonClientNodeVersion().toString()).setMaxNonClientNodeVersion(nodes.getLargestNonClientNodeVersion().toString()).setMinNodeVersion(nodes.getMinNodeVersion().toString()).setMaxNodeVersion(nodes.getMaxNodeVersion().toString());
-
-    //     ClusterStateResponseProto.ClusterStateRes.ClusterState.Builder clusterStateBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.newBuilder();
-    //     clusterStateBuilder.setClusterName(clusterState.getClusterName().value())
-    //         .setVersion(clusterState.version())
-    //         .setStateUUID(clusterState.stateUUID())
-    //         .setNodes(discoveryNodesBuilder.build());
-    //     this.clusterStateRes = ClusterStateResponseProto.ClusterStateRes.newBuilder()
-    //                                         .setClusterName(clusterName.value())
-    //                                         .setClusterState(clusterStateBuilder.build())
-    //                                         .setWaitForTimedOut(waitForTimedOut)
-    //                                         .build();
-    // }
-
     public ProtobufClusterStateResponse(String clusterName, DiscoveryNodes nodes, long version, String stateUUID, boolean waitForTimedOut) {
-        long startTime = System.nanoTime();
         ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Builder discoveryNodesBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.newBuilder();
-        // ImmutableOpenMap<String, DiscoveryNode> allNodes = nodes.getNodes();
 
-        long startTime1 = System.nanoTime();
-        Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> allNodesMap = convertNodes(nodes.getNodes());
-        long endTime1 = System.nanoTime();
-        System.out.println("Time taken to convert nodes: " + (endTime1 - startTime1) + " ns");
-        long startTime2 = System.nanoTime();
-        discoveryNodesBuilder.putAllAllNodes(allNodesMap).setClusterManagerNodeId(nodes.getClusterManagerNodeId()).setLocalNodeId(nodes.getLocalNodeId()).setMinNonClientNodeVersion(nodes.getSmallestNonClientNodeVersion().toString()).setMaxNonClientNodeVersion(nodes.getLargestNonClientNodeVersion().toString()).setMinNodeVersion(nodes.getMinNodeVersion().toString()).setMaxNodeVersion(nodes.getMaxNodeVersion().toString());
-        long endTime2 = System.nanoTime();
-        System.out.println("Time taken to discover nodes: " + (endTime2 - startTime2) + " ns");
-
-        long startTime3 = System.nanoTime();
+        List<ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> allNodes = convertNodes(nodes);
+        discoveryNodesBuilder.addAllAllNodes(allNodes).setClusterManagerNodeId(nodes.getClusterManagerNodeId()).setLocalNodeId(nodes.getLocalNodeId()).setMinNonClientNodeVersion(nodes.getSmallestNonClientNodeVersion().toString()).setMaxNonClientNodeVersion(nodes.getLargestNonClientNodeVersion().toString()).setMinNodeVersion(nodes.getMinNodeVersion().toString()).setMaxNodeVersion(nodes.getMaxNodeVersion().toString());
         ClusterStateResponseProto.ClusterStateRes.ClusterState.Builder clusterStateBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.newBuilder();
         clusterStateBuilder.setClusterName(clusterName)
             .setVersion(version)
             .setStateUUID(stateUUID)
             .setNodes(discoveryNodesBuilder.build());
-        long endTime3 = System.nanoTime();
-        System.out.println("Time taken to build cluster state: " + (endTime3 - startTime3) + " ns");
-
-        long startTime4 = System.nanoTime();
         this.clusterStateRes = ClusterStateResponseProto.ClusterStateRes.newBuilder()
                                             .setClusterName(clusterName)
                                             .setClusterState(clusterStateBuilder.build())
                                             .setWaitForTimedOut(waitForTimedOut)
                                             .build();
-        long endTime4 = System.nanoTime();
-        System.out.println("Time taken to build protobuf response: " + (endTime4 - startTime4) + " ns");
-        long endTime = System.nanoTime();
-        System.out.println("Time taken to build protobuf response: " + (endTime - startTime) + " ns");
     }
 
-    private Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> convertNodes(ImmutableOpenMap<String, DiscoveryNode> nodes) {
-        Map<String, ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> convertedNodes = new HashMap<>();
-        if (nodes.isEmpty()) {
+    private List<ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> convertNodes(DiscoveryNodes nodes) {
+        List<ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> convertedNodes = new ArrayList<>();
+        if (nodes.getNodes().isEmpty()) {
             return convertedNodes;
         }
-        long startTime = System.nanoTime();
-        Iterator<String> keysIt = nodes.keysIt();
-        while(keysIt.hasNext()) {
-            String key = keysIt.next();
-            DiscoveryNode node = nodes.get(key);
+        for (ObjectCursor<DiscoveryNode> node : nodes.getNodes().values()) {
             List<ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole> nodeRoles = new ArrayList<>();
-            node.getRoles().forEach(role -> {
+            node.value.getRoles().forEach(role -> {
                 ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole.Builder nodeRoleBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole.newBuilder();
                 nodeRoleBuilder.setIsKnownRole(role.isKnownRole()).setIsDynamicRole(role.isDynamicRole()).setRoleName(role.roleName()).setRoleNameAbbreviation(role.roleNameAbbreviation()).setCanContainData(role.canContainData()).build();
                 nodeRoles.add(nodeRoleBuilder.build());
             });
             ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.Builder nodeBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.newBuilder();
-            nodeBuilder.setNodeName(node.getName()).setNodeId(node.getId()).setEphemeralId(node.getEphemeralId()).setHostName(node.getHostName())
-            .setHostAddress(node.getHostAddress()).setTransportAddress(node.getAddress().toString()).putAllAttributes(node.getAttributes()).addAllRoles(nodeRoles).setVersion(node.getVersion().toString()).build();
-            convertedNodes.put(key, nodeBuilder.build());
+            nodeBuilder.setNodeName(node.value.getName()).setNodeId(node.value.getId()).setEphemeralId(node.value.getEphemeralId()).setHostName(node.value.getHostName())
+            .setHostAddress(node.value.getHostAddress()).setTransportAddress(node.value.getAddress().toString()).putAllAttributes(node.value.getAttributes()).addAllRoles(nodeRoles).setVersion(node.value.getVersion().toString()).build();
+            convertedNodes.add(nodeBuilder.build());
         }
-        long endTime = System.nanoTime();
-        System.out.println("Time taken to convert nodes in method: " + (endTime - startTime) + " ns");
         return convertedNodes;
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
index 88b9da7dff8e3..855685297e1c8 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
@@ -8,7 +8,6 @@
 
 package org.opensearch.action.admin.cluster.state;
 
-import com.google.protobuf.CodedInputStream;
 import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -103,10 +102,7 @@ protected void clusterManagerOperation(
             : acceptableClusterStatePredicate.or(clusterState -> clusterState.nodes().isLocalNodeElectedClusterManager() == false);
 
         if (acceptableClusterStatePredicate.test(state)) {
-            long startTime = System.nanoTime();
             ActionListener.completeWith(listener, () -> buildResponse(request, state));
-            long endTime = System.nanoTime();
-            System.out.println("Time taken to build response: " + (endTime - startTime));
         } else {
             assert acceptableClusterStateOrNotMasterPredicate.test(state) == false;
             new ClusterStateObserver(state, clusterService, request.waitForTimeout(), logger, threadPool.getThreadContext())
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
index e4232767d1246..ac8d93cc55fcd 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
@@ -129,10 +129,7 @@ protected void clusterManagerOperation(
             : acceptableClusterStatePredicate.or(clusterState -> clusterState.nodes().isLocalNodeElectedClusterManager() == false);
 
         if (acceptableClusterStatePredicate.test(state)) {
-            long startTime = System.nanoTime();
             ActionListener.completeWith(listener, () -> buildResponse(request, state));
-            long endTime = System.nanoTime();
-            System.out.println("Time taken to build response: " + (endTime - startTime));
         } else {
             assert acceptableClusterStateOrNotMasterPredicate.test(state) == false;
             new ClusterStateObserver(state, clusterService, request.waitForTimeout(), logger, threadPool.getThreadContext())
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/datastream/GetDataStreamAction.java b/server/src/main/java/org/opensearch/action/admin/indices/datastream/GetDataStreamAction.java
index 6516a099446f9..2013a50fb084f 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/datastream/GetDataStreamAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/datastream/GetDataStreamAction.java
@@ -64,8 +64,6 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverInfo.java b/server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverInfo.java
index 927421bf6ff31..e64a3ff5a4de0 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverInfo.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverInfo.java
@@ -45,8 +45,6 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
 
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.util.List;
 import java.util.Objects;
diff --git a/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java b/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java
index 185209040ca48..954092219e95a 100644
--- a/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java
+++ b/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java
@@ -75,7 +75,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
 
 import java.io.IOException;
 import java.util.Collections;
diff --git a/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java b/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java
index d9d45a337e84f..aae1d9fe398db 100644
--- a/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java
+++ b/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java
@@ -8,8 +8,6 @@
 
 package org.opensearch.action.main;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import org.opensearch.Build;
 import org.opensearch.Version;
 import org.opensearch.action.ProtobufActionResponse;
diff --git a/server/src/main/java/org/opensearch/action/resync/TransportResyncReplicationAction.java b/server/src/main/java/org/opensearch/action/resync/TransportResyncReplicationAction.java
index ea51274758911..47aef641b16a0 100644
--- a/server/src/main/java/org/opensearch/action/resync/TransportResyncReplicationAction.java
+++ b/server/src/main/java/org/opensearch/action/resync/TransportResyncReplicationAction.java
@@ -60,8 +60,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.function.Function;
 import java.util.stream.Stream;
diff --git a/server/src/main/java/org/opensearch/action/search/PitService.java b/server/src/main/java/org/opensearch/action/search/PitService.java
index b42b2734374a4..8550c2b3be829 100644
--- a/server/src/main/java/org/opensearch/action/search/PitService.java
+++ b/server/src/main/java/org/opensearch/action/search/PitService.java
@@ -8,7 +8,6 @@
 
 package org.opensearch.action.search;
 
-import com.google.protobuf.CodedInputStream;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
diff --git a/server/src/main/java/org/opensearch/action/support/IndicesOptions.java b/server/src/main/java/org/opensearch/action/support/IndicesOptions.java
index 3f58dbbaff12c..d30ee7e11bdfa 100644
--- a/server/src/main/java/org/opensearch/action/support/IndicesOptions.java
+++ b/server/src/main/java/org/opensearch/action/support/IndicesOptions.java
@@ -31,8 +31,6 @@
 
 package org.opensearch.action.support;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import org.opensearch.OpenSearchParseException;
 import org.opensearch.core.ParseField;
 import org.opensearch.core.common.io.stream.StreamInput;
diff --git a/server/src/main/java/org/opensearch/action/support/broadcast/TransportBroadcastAction.java b/server/src/main/java/org/opensearch/action/support/broadcast/TransportBroadcastAction.java
index 1305bf0b7750b..712ca6273163b 100644
--- a/server/src/main/java/org/opensearch/action/support/broadcast/TransportBroadcastAction.java
+++ b/server/src/main/java/org/opensearch/action/support/broadcast/TransportBroadcastAction.java
@@ -60,8 +60,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReferenceArray;
diff --git a/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java b/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
index 5bef519190427..0656b841133d9 100644
--- a/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
@@ -67,8 +67,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import org.opensearch.transport.TransportRequestOptions;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
index 42eca86ba39e7..4c28131a9cc7e 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
@@ -8,7 +8,6 @@
 
 package org.opensearch.action.support.clustermanager;
 
-import com.google.protobuf.CodedInputStream;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
index 6e1fddfece0bb..12828aa0288ea 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
@@ -13,8 +13,6 @@
 
 package org.opensearch.action.support.nodes;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import org.opensearch.action.ActionRequestValidationException;
 import org.opensearch.action.ProtobufActionRequest;
 import org.opensearch.cluster.node.DiscoveryNodes;
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java
index 85f4d87ba1649..29ead82d728e2 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java
@@ -13,9 +13,6 @@
 
 package org.opensearch.action.support.nodes;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import org.opensearch.action.FailedNodeException;
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.cluster.ClusterName;
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
index ae2562f21d35b..ffa64a81330d2 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
@@ -8,7 +8,6 @@
 
 package org.opensearch.action.support.nodes;
 
-import com.google.protobuf.CodedInputStream;
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.action.ActionListener;
 import org.opensearch.action.ActionRunnable;
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java b/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
index f2d8f59f90d0c..0049e5d54a23c 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
@@ -54,8 +54,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
diff --git a/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java b/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java
index 8f5268b33632f..713c32f5f52c9 100644
--- a/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java
+++ b/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java
@@ -92,8 +92,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.Map;
 import java.util.Objects;
diff --git a/server/src/main/java/org/opensearch/action/support/single/instance/TransportInstanceSingleOperationAction.java b/server/src/main/java/org/opensearch/action/support/single/instance/TransportInstanceSingleOperationAction.java
index 3282e1ff0d847..22543b153ab30 100644
--- a/server/src/main/java/org/opensearch/action/support/single/instance/TransportInstanceSingleOperationAction.java
+++ b/server/src/main/java/org/opensearch/action/support/single/instance/TransportInstanceSingleOperationAction.java
@@ -65,8 +65,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 
 import static org.opensearch.cluster.metadata.IndexNameExpressionResolver.EXCLUDED_DATA_STREAMS_KEY;
diff --git a/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java b/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java
index cf7c9bdbc8273..81f6f276483f5 100644
--- a/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java
+++ b/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java
@@ -64,8 +64,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 
 import static org.opensearch.action.support.TransportActions.isShardNotAvailableException;
diff --git a/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java b/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java
index b872d467a63ef..7a94b5cfc29f7 100644
--- a/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java
+++ b/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java
@@ -61,8 +61,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
diff --git a/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java b/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java
index 186d4af944b33..6350b888e503f 100644
--- a/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java
+++ b/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java
@@ -33,13 +33,9 @@
 package org.opensearch.cluster;
 
 import org.opensearch.common.Nullable;
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 
 /**
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterName.java b/server/src/main/java/org/opensearch/cluster/ClusterName.java
index 3404470846971..ba3620973bf7b 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterName.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterName.java
@@ -39,8 +39,6 @@
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.Objects;
 import java.util.function.Predicate;
@@ -70,10 +68,6 @@ public ClusterName(StreamInput input) throws IOException {
         this(input.readString());
     }
 
-    public ClusterName(CodedInputStream input) throws IOException {
-        this(input.readString());
-    }
-
     public ClusterName(String value) {
         this.value = value.intern();
     }
diff --git a/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java b/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java
index b7cc92ee8d539..d2eb0aa6f6a6a 100644
--- a/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java
+++ b/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.cluster.block;
 
-import com.google.protobuf.CodedOutputStream;
 
 import org.opensearch.cluster.AbstractDiffable;
 import org.opensearch.cluster.Diff;
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java b/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java
index 1a2d990195259..1500cf8803cd8 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java
@@ -59,8 +59,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.HashSet;
 import java.util.Map;
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java b/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java
index 299262928ac42..8955c2d9f806a 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java
@@ -72,8 +72,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.Collection;
 import java.util.Collections;
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java b/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java
index 80a1b3c5eccda..b684269af8265 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java
@@ -61,8 +61,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicBoolean;
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/PreVoteCollector.java b/server/src/main/java/org/opensearch/cluster/coordination/PreVoteCollector.java
index 621c8a645bb8a..819622d684d9e 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/PreVoteCollector.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/PreVoteCollector.java
@@ -49,8 +49,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicBoolean;
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java b/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
index 92230d161049d..87a5ca8d53f5c 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
@@ -56,8 +56,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
diff --git a/server/src/main/java/org/opensearch/cluster/decommission/DecommissionController.java b/server/src/main/java/org/opensearch/cluster/decommission/DecommissionController.java
index 9a19d4d4ee944..5ed0a72eb1556 100644
--- a/server/src/main/java/org/opensearch/cluster/decommission/DecommissionController.java
+++ b/server/src/main/java/org/opensearch/cluster/decommission/DecommissionController.java
@@ -35,8 +35,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.HashMap;
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/AliasMetadata.java b/server/src/main/java/org/opensearch/cluster/metadata/AliasMetadata.java
index 7721bd4e148f7..78a4b34c18318 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/AliasMetadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/AliasMetadata.java
@@ -51,8 +51,6 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
 
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.util.Collections;
 import java.util.Map;
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/ComponentTemplate.java b/server/src/main/java/org/opensearch/cluster/metadata/ComponentTemplate.java
index 42e13ff65dcd9..00babadfc351a 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/ComponentTemplate.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/ComponentTemplate.java
@@ -45,8 +45,6 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
 
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.util.Map;
 import java.util.Objects;
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java b/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java
index 823601058cf87..37294b3f8ce46 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java
@@ -49,8 +49,6 @@
 import org.opensearch.index.mapper.DataStreamFieldMapper;
 import org.opensearch.index.mapper.MapperService;
 
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/DataStream.java b/server/src/main/java/org/opensearch/cluster/metadata/DataStream.java
index 95aa0a935345d..edf5d65fea2ad 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/DataStream.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/DataStream.java
@@ -47,8 +47,6 @@
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.core.index.Index;
 
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java b/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java
index 95cbc8e108baf..3e3d5fd458a27 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java
@@ -31,7 +31,6 @@
 
 package org.opensearch.cluster.metadata;
 
-import com.google.protobuf.CodedOutputStream;
 
 import org.opensearch.OpenSearchParseException;
 import org.opensearch.cluster.AbstractDiffable;
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java b/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java
index 7e77821521faf..aa8d8af0f01a3 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.cluster.metadata;
 
-import com.google.protobuf.CodedInputStream;
 
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.LogManager;
@@ -1065,31 +1064,6 @@ public static Metadata readFrom(StreamInput in) throws IOException {
         return builder.build();
     }
 
-    public static Metadata readFrom(CodedInputStream in) throws IOException {
-        Builder builder = new Builder();
-        builder.version = in.readInt64();
-        builder.clusterUUID = in.readString();
-        builder.clusterUUIDCommitted = in.readBool();
-        // builder.coordinationMetadata(new CoordinationMetadata(in));
-        builder.transientSettings(readSettingsFromStreamProtobuf(in));
-        builder.persistentSettings(readSettingsFromStreamProtobuf(in));
-        // builder.hashesOfConsistentSettings(DiffableStringMap.readFrom(in));
-        int size = in.readInt32();
-        // for (int i = 0; i < size; i++) {
-        // builder.put(IndexMetadata.readFrom(in), false);
-        // }
-        size = in.readInt32();
-        // for (int i = 0; i < size; i++) {
-        // builder.put(IndexTemplateMetadata.readFrom(in));
-        // }
-        int customSize = in.readInt32();
-        // for (int i = 0; i < customSize; i++) {
-        // Custom customIndexMetadata = in.readNamedWriteable(Custom.class);
-        // builder.putCustom(customIndexMetadata.getWriteableName(), customIndexMetadata);
-        // }
-        return builder.build();
-    }
-
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         out.writeLong(version);
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/Template.java b/server/src/main/java/org/opensearch/cluster/metadata/Template.java
index 9db260e9bb481..f48dc1ab2a9ef 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/Template.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/Template.java
@@ -49,8 +49,6 @@
 import org.opensearch.common.xcontent.XContentType;
 import org.opensearch.index.mapper.MapperService;
 
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
diff --git a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
index 2fa1ef93db94c..4fca11bd88447 100644
--- a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
+++ b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
@@ -34,7 +34,6 @@
 
 import org.opensearch.Version;
 import org.opensearch.common.UUIDs;
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
@@ -45,9 +44,6 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.node.Node;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.util.Collections;
 import java.util.HashMap;
diff --git a/server/src/main/java/org/opensearch/cluster/routing/AllocationId.java b/server/src/main/java/org/opensearch/cluster/routing/AllocationId.java
index 5cb8a8e04613a..0bc434090b719 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/AllocationId.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/AllocationId.java
@@ -38,15 +38,11 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.xcontent.ObjectParser;
 import org.opensearch.core.xcontent.ToXContentObject;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.util.Objects;
 
diff --git a/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java b/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java
index 5502317c51d2b..1e91dafe0ede3 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.cluster.routing;
 
-import com.google.protobuf.CodedInputStream;
 
 import org.opensearch.cluster.Diff;
 import org.opensearch.cluster.Diffable;
diff --git a/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java b/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java
index 18d093ad78708..aa893ec735bac 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java
@@ -36,7 +36,6 @@
 import org.opensearch.cluster.routing.RecoverySource.PeerRecoverySource;
 import org.opensearch.cluster.routing.allocation.allocator.BalancedShardsAllocator;
 import org.opensearch.common.Nullable;
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
@@ -45,9 +44,6 @@
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
diff --git a/server/src/main/java/org/opensearch/cluster/routing/UnassignedInfo.java b/server/src/main/java/org/opensearch/cluster/routing/UnassignedInfo.java
index 80a2470ac53ea..a4ecbadc34702 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/UnassignedInfo.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/UnassignedInfo.java
@@ -38,7 +38,6 @@
 import org.opensearch.cluster.routing.allocation.RoutingAllocation;
 import org.opensearch.cluster.routing.allocation.decider.Decision;
 import org.opensearch.common.Nullable;
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
@@ -50,14 +49,10 @@
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.time.Instant;
 import java.time.ZoneOffset;
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
@@ -222,26 +217,6 @@ public static AllocationStatus readFrom(StreamInput in) throws IOException {
             }
         }
 
-        public static AllocationStatus readFrom(CodedInputStream in) throws IOException {
-            byte id = in.readRawByte();
-            switch (id) {
-                case 0:
-                    return DECIDERS_NO;
-                case 1:
-                    return NO_VALID_SHARD_COPY;
-                case 2:
-                    return DECIDERS_THROTTLED;
-                case 3:
-                    return FETCHING_SHARD_DATA;
-                case 4:
-                    return DELAYED_ALLOCATION;
-                case 5:
-                    return NO_ATTEMPT;
-                default:
-                    throw new IllegalArgumentException("Unknown AllocationStatus value [" + id + "]");
-            }
-        }
-
         public static AllocationStatus fromDecision(Decision.Type decision) {
             Objects.requireNonNull(decision);
             switch (decision) {
diff --git a/server/src/main/java/org/opensearch/common/bytes/ReleasableBytesReference.java b/server/src/main/java/org/opensearch/common/bytes/ReleasableBytesReference.java
index 463b7abc0e0c2..e0bc97f282e09 100644
--- a/server/src/main/java/org/opensearch/common/bytes/ReleasableBytesReference.java
+++ b/server/src/main/java/org/opensearch/common/bytes/ReleasableBytesReference.java
@@ -40,8 +40,6 @@
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.core.xcontent.XContentBuilder;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.io.OutputStream;
 
@@ -125,11 +123,6 @@ public StreamInput streamInput() throws IOException {
         return delegate.streamInput();
     }
 
-    @Override
-    public CodedInputStream protobufInput() throws IOException {
-        return delegate.protobufInput();
-    }
-
     @Override
     public void writeTo(OutputStream os) throws IOException {
         delegate.writeTo(os);
diff --git a/server/src/main/java/org/opensearch/common/io/stream/TryWriteable.java b/server/src/main/java/org/opensearch/common/io/stream/TryWriteable.java
index 4815bf04e73e8..16ff465335d24 100644
--- a/server/src/main/java/org/opensearch/common/io/stream/TryWriteable.java
+++ b/server/src/main/java/org/opensearch/common/io/stream/TryWriteable.java
@@ -16,9 +16,6 @@
 import java.io.IOException;
 import java.io.OutputStream;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 /**
  * Implementers can be written to write to output and read from input using Protobuf.
 *
@@ -36,7 +33,7 @@ public interface TryWriteable {
      * Most classes should implement {@link TryWriteable} and the {@link TryWriteable#writeTo(OutputStream)} method should <em>use</em>
      * {@link OutputStream} methods directly or this indirectly:
      * <pre><code>
-     * public void writeTo(CodedOutputStream out) throws IOException {
+     * public void writeTo(OutputStream out) throws IOException {
      *     out.writeVInt(someValue);
      * }
      * </code></pre>
@@ -58,7 +55,7 @@ interface Writer<V> {
      * Reference to a method that can read some object from a stream. By convention this is a constructor that takes
      * {@linkplain byte[]} as an argument for most classes and a static method for things like enums.
      * <pre><code>
-     * public MyClass(final CodedInputStream in) throws IOException {
+     * public MyClass(final byte[] in) throws IOException {
      *     this.someValue = in.readVInt();
      * }
      * </code></pre>
diff --git a/server/src/main/java/org/opensearch/common/settings/Settings.java b/server/src/main/java/org/opensearch/common/settings/Settings.java
index 1ed86bf045726..cd80e9727e0df 100644
--- a/server/src/main/java/org/opensearch/common/settings/Settings.java
+++ b/server/src/main/java/org/opensearch/common/settings/Settings.java
@@ -32,8 +32,6 @@
 
 package org.opensearch.common.settings;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import org.apache.logging.log4j.Level;
 import org.opensearch.OpenSearchGenerationException;
 import org.opensearch.OpenSearchParseException;
@@ -577,23 +575,6 @@ public static Settings readSettingsFromStream(StreamInput in) throws IOException
         return builder.build();
     }
 
-    public static Settings readSettingsFromStreamProtobuf(CodedInputStream in) throws IOException {
-        Builder builder = new Builder();
-        int numberOfSettings = in.readInt32();
-        for (int i = 0; i < numberOfSettings; i++) {
-            String key = in.readString();
-            Object value = in.readString();
-            if (value == null) {
-                builder.putNull(key);
-            } else if (value instanceof List) {
-                builder.putList(key, (List<String>) value);
-            } else {
-                builder.put(key, value.toString());
-            }
-        }
-        return builder.build();
-    }
-
     public static void writeSettingsToStream(Settings settings, StreamOutput out) throws IOException {
         // pull settings to exclude secure settings in size()
         Set<Map.Entry<String, Object>> entries = settings.settings.entrySet();
@@ -604,16 +585,6 @@ public static void writeSettingsToStream(Settings settings, StreamOutput out) th
         }
     }
 
-    public static void writeSettingsToStreamProtobuf(Settings settings, CodedOutputStream out) throws IOException {
-        // pull settings to exclude secure settings in size()
-        Set<Map.Entry<String, Object>> entries = settings.settings.entrySet();
-        out.writeInt32NoTag(entries.size());
-        for (Map.Entry<String, Object> entry : entries) {
-            out.writeStringNoTag(entry.getKey());
-            out.writeStringNoTag(entry.getValue().toString());
-        }
-    }
-
     /**
      * Returns a builder to be used in order to build settings.
      */
diff --git a/server/src/main/java/org/opensearch/common/transport/BoundTransportAddress.java b/server/src/main/java/org/opensearch/common/transport/BoundTransportAddress.java
index 3f1a74402640e..3a9c337f2d950 100644
--- a/server/src/main/java/org/opensearch/common/transport/BoundTransportAddress.java
+++ b/server/src/main/java/org/opensearch/common/transport/BoundTransportAddress.java
@@ -32,15 +32,11 @@
 
 package org.opensearch.common.transport;
 
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.common.network.InetAddresses;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 
 /**
diff --git a/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java b/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
index ffb21270d6977..b52109e93b22b 100644
--- a/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
+++ b/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
@@ -31,15 +31,12 @@
 
 package org.opensearch.common.util.concurrent;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.opensearch.action.support.ContextPreservingActionListener;
 import org.opensearch.client.OriginSettingClient;
 import org.opensearch.common.collect.MapBuilder;
 import org.opensearch.common.collect.Tuple;
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
diff --git a/server/src/main/java/org/opensearch/discovery/PeerFinder.java b/server/src/main/java/org/opensearch/discovery/PeerFinder.java
index d2877d3d035e7..87613624a360c 100644
--- a/server/src/main/java/org/opensearch/discovery/PeerFinder.java
+++ b/server/src/main/java/org/opensearch/discovery/PeerFinder.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.discovery;
 
-import com.google.protobuf.CodedInputStream;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
diff --git a/server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java b/server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java
index 17b01dc898964..1b538da573531 100644
--- a/server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java
+++ b/server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java
@@ -13,7 +13,6 @@
 
 package org.opensearch.example.proto;
 
-import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.InvalidProtocolBufferException;
 
 import org.opensearch.common.io.stream.TryWriteable;
diff --git a/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java b/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
index 6962a60b18d5e..edef4d0b13605 100644
--- a/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
+++ b/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
@@ -56,8 +56,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import org.opensearch.env.EnvironmentSettingsResponse;
 
 /**
diff --git a/server/src/main/java/org/opensearch/extensions/UpdateSettingsResponseHandler.java b/server/src/main/java/org/opensearch/extensions/UpdateSettingsResponseHandler.java
index f003af99d8afc..b4c790d9239b8 100644
--- a/server/src/main/java/org/opensearch/extensions/UpdateSettingsResponseHandler.java
+++ b/server/src/main/java/org/opensearch/extensions/UpdateSettingsResponseHandler.java
@@ -17,8 +17,6 @@
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 
-import com.google.protobuf.CodedInputStream;
-
 /**
  * Response handler for {@link UpdateSettingsRequest}
  *
diff --git a/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java b/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java
index ce240c0c005e8..bd8b80be9fd3b 100644
--- a/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java
+++ b/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java
@@ -26,8 +26,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
diff --git a/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java b/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java
index 10f89ea1886a2..eb7b4ce81a59e 100644
--- a/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java
+++ b/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java
@@ -28,8 +28,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import org.opensearch.http.HttpRequest;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java
index bb861caa3f62c..a39c02104745a 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java
@@ -64,8 +64,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.Map;
 import java.util.Objects;
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java
index 0f89a1dfff1b7..bb8d86aaaa498 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java
@@ -67,8 +67,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.Map;
 import java.util.Objects;
diff --git a/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java b/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
index 5f56341eb0901..a1376d7318832 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
@@ -78,8 +78,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
diff --git a/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java b/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
index 41d5e557a043e..b3b32fbe9bfb9 100644
--- a/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
+++ b/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
@@ -38,8 +38,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.Objects;
 
diff --git a/server/src/main/java/org/opensearch/indices/store/IndicesStore.java b/server/src/main/java/org/opensearch/indices/store/IndicesStore.java
index 60691a07f7158..eb5ae01c5261c 100644
--- a/server/src/main/java/org/opensearch/indices/store/IndicesStore.java
+++ b/server/src/main/java/org/opensearch/indices/store/IndicesStore.java
@@ -73,8 +73,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.Closeable;
 import java.io.IOException;
 import java.util.ArrayList;
diff --git a/server/src/main/java/org/opensearch/ingest/PipelineConfiguration.java b/server/src/main/java/org/opensearch/ingest/PipelineConfiguration.java
index ff9c38c259d36..40a78bce2bf02 100644
--- a/server/src/main/java/org/opensearch/ingest/PipelineConfiguration.java
+++ b/server/src/main/java/org/opensearch/ingest/PipelineConfiguration.java
@@ -46,8 +46,6 @@
 import org.opensearch.core.xcontent.ToXContentObject;
 import org.opensearch.core.xcontent.XContentBuilder;
 
-import com.google.protobuf.CodedOutputStream;
-
 import org.opensearch.common.xcontent.XContentHelper;
 import org.opensearch.common.xcontent.XContentType;
 
diff --git a/server/src/main/java/org/opensearch/monitor/jvm/JvmInfo.java b/server/src/main/java/org/opensearch/monitor/jvm/JvmInfo.java
index 747c96073c04a..9eafd80203a87 100644
--- a/server/src/main/java/org/opensearch/monitor/jvm/JvmInfo.java
+++ b/server/src/main/java/org/opensearch/monitor/jvm/JvmInfo.java
@@ -36,18 +36,13 @@
 import org.opensearch.common.Booleans;
 import org.opensearch.common.SuppressForbidden;
 import org.opensearch.common.io.PathUtils;
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.node.ReportingService;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.lang.management.GarbageCollectorMXBean;
 import java.lang.management.ManagementFactory;
diff --git a/server/src/main/java/org/opensearch/rest/BaseRestHandler.java b/server/src/main/java/org/opensearch/rest/BaseRestHandler.java
index c93025ecf9728..bcfff383f5199 100644
--- a/server/src/main/java/org/opensearch/rest/BaseRestHandler.java
+++ b/server/src/main/java/org/opensearch/rest/BaseRestHandler.java
@@ -105,12 +105,8 @@ public final long getUsageCount() {
     public final void handleRequest(RestRequest request, RestChannel channel, NodeClient client) throws Exception {
         logger.info("BaseRestHandler.handleRequest {}", request);
         // prepare the request for execution; has the side effect of touching the request parameters
-        long startTime = System.nanoTime();
         final RestChannelConsumer action = prepareRequest(request, client);
-        long endTime = System.nanoTime();
-        System.out.println("Preparing request took: " + (endTime-startTime));
         logger.info("BaseRestHandler.handleRequest action: {}", action);
-        System.out.println("Action: " + action);
 
         // validate unconsumed params, but we must exclude params used to format the response
         // use a sorted set so the unconsumed parameters appear in a reliable sorted order
diff --git a/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java b/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java
index dbf9c03887144..6bc78abee594b 100644
--- a/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java
+++ b/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java
@@ -79,12 +79,8 @@ public final long getUsageCount() {
     public final void handleRequest(RestRequest request, RestChannel channel, ProtobufNodeClient client) throws Exception {
         logger.info("ProtobufBaseRestHandler.handleRequest {}", request);
         // prepare the request for execution; has the side effect of touching the request parameters
-        long startTime = System.nanoTime();
         final RestChannelConsumer action = prepareRequest(request, client);
-        long endTime = System.nanoTime();
-        System.out.println("Preparing request took: " + (endTime-startTime));
         logger.info("ProtobufBaseRestHandler.handleRequest action: {}", action.getClass().getName());
-        System.out.println("Action: " + action);
 
         // validate unconsumed params, but we must exclude params used to format the response
         // use a sorted set so the unconsumed parameters appear in a reliable sorted order
diff --git a/server/src/main/java/org/opensearch/rest/RestController.java b/server/src/main/java/org/opensearch/rest/RestController.java
index 67300188b817a..172152ac9cfab 100644
--- a/server/src/main/java/org/opensearch/rest/RestController.java
+++ b/server/src/main/java/org/opensearch/rest/RestController.java
@@ -576,10 +576,7 @@ private void tryAllHandlers(final RestRequest request, final RestChannel channel
                     }
                 } else {
                     if (rawPath.contains("protobuf")) {
-                        long startTime = System.nanoTime();
                         dispatchProtobufRequest(request, channel, protobufHandler);
-                        long endTime = System.nanoTime();      
-                        System.out.println("Elapsed Time in nano seconds for protobuf: "+ (endTime-startTime));
                     } else {
                     if (FeatureFlags.isEnabled(FeatureFlags.IDENTITY)) {
                         if (!handleAuthenticateUser(request, channel)) {
@@ -588,8 +585,6 @@ private void tryAllHandlers(final RestRequest request, final RestChannel channel
                     }
                         long startTime = System.nanoTime();
                         dispatchRequest(request, channel, handler);
-                        long endTime = System.nanoTime();      
-                        System.out.println("Elapsed Time in nano seconds for original: "+ (endTime-startTime));
                     }
                     return;
                 }
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
index a30ed675d1efc..be0286ed73074 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
@@ -323,7 +323,7 @@ Table buildTable(
         ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes nodes = state.response().getClusterState().getNodes();
         String clusterManagerId = nodes.getClusterManagerNodeId();
         Table table = getTableWithHeader(req);
-        for (ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node node : nodes.getAllNodesMap().values()) {
+        for (ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node node : nodes.getAllNodesList()) {
             NodesInfo info = nodesInfo.nodesMap().get(node.getNodeId());
             NodesStats stats = nodesStats.nodesMap().get(node.getNodeId());
 
diff --git a/server/src/main/java/org/opensearch/script/StoredScriptSource.java b/server/src/main/java/org/opensearch/script/StoredScriptSource.java
index 1390bb5cdca07..e335545c2f0e7 100644
--- a/server/src/main/java/org/opensearch/script/StoredScriptSource.java
+++ b/server/src/main/java/org/opensearch/script/StoredScriptSource.java
@@ -54,8 +54,6 @@
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.core.xcontent.XContentParser.Token;
 
-import com.google.protobuf.CodedOutputStream;
-
 import org.opensearch.common.xcontent.XContentType;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java b/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java
index 5438f1e8a459e..9aa8786b5185f 100644
--- a/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java
+++ b/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java
@@ -24,8 +24,6 @@
 import org.opensearch.core.xcontent.ToXContentObject;
 import org.opensearch.core.xcontent.XContentBuilder;
 
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.util.Map;
 import java.util.Objects;
diff --git a/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java b/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java
index 812d858e03354..87f68a2716937 100644
--- a/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java
+++ b/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.snapshots;
 
-import com.google.protobuf.CodedInputStream;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
index d3f2a26622ce7..09b6566239dc5 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
@@ -8,8 +8,6 @@
 
 package org.opensearch.tasks;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.opensearch.ExceptionsHelper;
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
index 40b815c884ce3..d908eca24cbe7 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
@@ -11,8 +11,6 @@
 
 package org.opensearch.tasks;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import org.opensearch.common.Strings;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.tasks.proto.TaskIdProto;
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
index a02b26afc8ba5..1c07fb9292a16 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
@@ -11,9 +11,6 @@
 
 package org.opensearch.tasks;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-import org.opensearch.Version;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.xcontent.ToXContentFragment;
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
index 57e114591b20d..7e7d1cb184ba1 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
@@ -11,8 +11,6 @@
 
 package org.opensearch.tasks;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
 import org.opensearch.OpenSearchException;
 import org.opensearch.client.Requests;
 import org.opensearch.common.Nullable;
diff --git a/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java
index 14bb560228895..45232d3cb58a7 100644
--- a/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java
+++ b/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java
@@ -38,8 +38,6 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportResponse.Empty;
 
-import com.google.protobuf.CodedInputStream;
-
 /**
  * Handler for empty transport response
  *
diff --git a/server/src/main/java/org/opensearch/transport/InboundHandler.java b/server/src/main/java/org/opensearch/transport/InboundHandler.java
index c4e7a283bfdef..c96d26f3f4c7a 100644
--- a/server/src/main/java/org/opensearch/transport/InboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/InboundHandler.java
@@ -66,9 +66,6 @@
 import org.opensearch.server.proto.OutboundMessageProto.OutboundMsg;
 import org.opensearch.threadpool.ThreadPool;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.InvalidProtocolBufferException;
-
 import java.io.EOFException;
 import java.io.IOException;
 import java.net.InetSocketAddress;
@@ -162,8 +159,6 @@ void inboundMessageProtobuf(TcpChannel channel, BytesReference message) throws I
     // Empty stream constant to avoid instantiating a new stream for empty messages.
     private static final StreamInput EMPTY_STREAM_INPUT = new ByteBufferStreamInput(ByteBuffer.wrap(BytesRef.EMPTY_BYTES));
 
-    private static final CodedInputStream EMPTY_CODED_INPUT_STREAM = CodedInputStream.newInstance(BytesRef.EMPTY_BYTES);
-
     private void messageReceivedProtobuf(TcpChannel channel, ProtobufOutboundMessage message, long startTime) throws IOException {
         final InetSocketAddress remoteAddress = channel.getRemoteAddress();
         final org.opensearch.server.proto.OutboundMessageProto.OutboundMsg.Header header = message.getHeader();
@@ -183,9 +178,9 @@ private void messageReceivedProtobuf(TcpChannel channel, ProtobufOutboundMessage
                     messageListener
                 );
                 if (handler != null) {
-                    if (handler.toString().contains("Protobuf")) {
+                    // if (handler.toString().contains("Protobuf")) {
                         handleProtobufResponse(requestId, remoteAddress, message, handler);
-                    }
+                    // }
                 }
             }
         } finally {
diff --git a/server/src/main/java/org/opensearch/transport/OutboundHandler.java b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
index 3d56ae1f67178..7ebab0672b39e 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
@@ -136,36 +136,27 @@ void sendRequest(
         );
 
         ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onRequestSent(node, requestId, action, request, options));
-        long startTime = System.nanoTime();
-        if (request.getClass().getCanonicalName().contains("ProtobufClusterState")) {
-            // ExampleProtoRequest exampleProtoRequest = new ExampleProtoRequest(1, "message");
+        String canonicalName = request.getClass().getCanonicalName();
+        if (canonicalName.contains("ProtobufClusterState")) {
             ProtobufClusterStateRequest protobufClusterStateRequest = (ProtobufClusterStateRequest) request;
             byte[] bytes = new byte[1];
             bytes[0] = 0;
             ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufClusterStateRequest.request(), features, action);
             sendProtobufMessage(channel, protobufMessage, listener);
-            long endTime = System.nanoTime();
-            System.out.println("Time for sending protobuf cluster state req: " + (endTime-startTime));
-        } else if (request.getClass().getCanonicalName().contains("ProtobufTransportNodesInfo")) {
+        } else if (canonicalName.contains("ProtobufTransportNodesInfo")) {
             NodeInfoRequest protobufNodesInfoRequest = (NodeInfoRequest) request;
             byte[] bytes = new byte[1];
             bytes[0] = 0;
             ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufNodesInfoRequest.request().request(), features, action);
             sendProtobufMessage(channel, protobufMessage, listener);
-            long endTime = System.nanoTime();
-            System.out.println("Time for sending protobuf node info req: " + (endTime-startTime));
-        } else if (request.getClass().getCanonicalName().contains("ProtobufTransportNodesStats")) {
+        } else if (canonicalName.contains("ProtobufTransportNodesStats")) {
             NodeStatsRequest protobufNodesStatsRequest = (NodeStatsRequest) request;
             byte[] bytes = new byte[1];
             bytes[0] = 0;
             ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufNodesStatsRequest.request().request(), features, action);
             sendProtobufMessage(channel, protobufMessage, listener);
-            long endTime = System.nanoTime();
-            System.out.println("Time for sending protobuf node stats req: " + (endTime-startTime));
         } else {
             sendMessage(channel, message, listener);
-            long endTime = System.nanoTime();
-            System.out.println("Time for sending normal req: " + (endTime-startTime));
         }
     }
 
@@ -223,20 +214,21 @@ void sendResponse(
             compress
         );
         ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onResponseSent(requestId, action, response));
-        if (response.getClass().getCanonicalName().contains("ProtobufClusterState")) {
+        String canonicalName = response.getClass().getCanonicalName();
+        if (canonicalName.contains("ProtobufClusterState")) {
             // ExampleProtoRequest exampleProtoRequest = new ExampleProtoRequest(1, "message");
             ProtobufClusterStateResponse protobufClusterStateResponse = (ProtobufClusterStateResponse) response;
             byte[] bytes = new byte[1];
             bytes[0] = 1;
             ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufClusterStateResponse.response(), features, action);
             sendProtobufMessage(channel, protobufMessage, listener);
-        } else if (response.getClass().getCanonicalName().contains("ProtobufNodeInfo")) {
+        } else if (canonicalName.contains("ProtobufNodeInfo")) {
             ProtobufNodeInfo protobufNodeInfo = (ProtobufNodeInfo) response;
             byte[] bytes = new byte[1];
             bytes[0] = 1;
             ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufNodeInfo.response(), features, action);
             sendProtobufMessage(channel, protobufMessage, listener);
-        } else if (response.getClass().getCanonicalName().contains("ProtobufNodeStats")) {
+        } else if (canonicalName.contains("ProtobufNodeStats")) {
             ProtobufNodeStats protobufNodeStats = (ProtobufNodeStats) response;
             byte[] bytes = new byte[1];
             bytes[0] = 1;
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
index 451acd1aa21d9..df6a34c37226c 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
@@ -8,7 +8,6 @@
 
 package org.opensearch.transport;
 
-import com.google.protobuf.CodedInputStream;
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.lease.Releasables;
@@ -61,11 +60,8 @@ public Request newRequest(byte[] in) throws IOException {
     }
 
     public void processMessageReceived(Request request, TransportChannel channel) throws Exception {
-        long startTime = System.nanoTime();
         final ProtobufTask task = taskManager.registerProtobuf(channel.getChannelType(), action, request);
         ThreadContext.StoredContext contextToRestore = taskManager.protobufTaskExecutionStarted(task);
-        long endTime = System.nanoTime();
-        System.out.println("taskManager.registerProtobuf: " + (endTime - startTime));
 
         Releasable unregisterTask = () -> taskManager.unregisterProtobufTask(task);
         try {
diff --git a/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java b/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java
index a694ebc186b7d..f4232bf36e6fc 100644
--- a/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java
+++ b/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java
@@ -45,8 +45,6 @@
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.threadpool.ThreadPool;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.Closeable;
 import java.io.IOException;
 import java.util.function.Function;
diff --git a/server/src/main/java/org/opensearch/transport/RequestHandlerRegistry.java b/server/src/main/java/org/opensearch/transport/RequestHandlerRegistry.java
index 5a3bbc80c0266..bd1ccda2cbe30 100644
--- a/server/src/main/java/org/opensearch/transport/RequestHandlerRegistry.java
+++ b/server/src/main/java/org/opensearch/transport/RequestHandlerRegistry.java
@@ -86,11 +86,8 @@ public Request newRequest(StreamInput in) throws IOException {
     }
 
     public void processMessageReceived(Request request, TransportChannel channel) throws Exception {
-        long startTime = System.nanoTime();
         final Task task = taskManager.register(channel.getChannelType(), action, request);
         ThreadContext.StoredContext contextToRestore = taskManager.taskExecutionStarted(task);
-        long endTime = System.nanoTime();
-        System.out.println("processMessageReceived: " + (endTime - startTime));
 
         Releasable unregisterTask = () -> taskManager.unregister(task);
         try {
diff --git a/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java
index 05783f7d7b23d..8d879ce45b2a7 100644
--- a/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java
+++ b/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java
@@ -57,8 +57,6 @@
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.threadpool.ThreadPool;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.util.Arrays;
diff --git a/server/src/main/java/org/opensearch/transport/TcpHeader.java b/server/src/main/java/org/opensearch/transport/TcpHeader.java
index 7e991bfddd53e..a52d577b624b5 100644
--- a/server/src/main/java/org/opensearch/transport/TcpHeader.java
+++ b/server/src/main/java/org/opensearch/transport/TcpHeader.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.transport;
 
-import com.google.protobuf.CodedOutputStream;
 import org.opensearch.Version;
 import org.opensearch.core.common.io.stream.StreamOutput;
 
@@ -93,21 +92,4 @@ public static void writeHeader(
         output.writeInt(variableHeaderSize);
     }
 
-    public static void writeHeaderProtobuf(
-        CodedOutputStream output,
-        long requestId,
-        byte status,
-        Version version,
-        int contentSize,
-        int variableHeaderSize
-    ) throws IOException {
-        output.writeByteArrayNoTag(PREFIX);
-        // write the size, the size indicates the remaining message size, not including the size int
-        output.writeInt32NoTag(contentSize + REQUEST_ID_SIZE + STATUS_SIZE + VERSION_ID_SIZE + VARIABLE_HEADER_SIZE);
-        output.writeInt64NoTag(requestId);
-        output.writeRawByte(status);
-        output.writeInt32NoTag(version.id);
-        assert variableHeaderSize != -1 : "Variable header size not set";
-        output.writeInt32NoTag(variableHeaderSize);
-    }
 }
diff --git a/server/src/main/java/org/opensearch/transport/TransportActionProxy.java b/server/src/main/java/org/opensearch/transport/TransportActionProxy.java
index 295fab1cf3554..2609648cbff23 100644
--- a/server/src/main/java/org/opensearch/transport/TransportActionProxy.java
+++ b/server/src/main/java/org/opensearch/transport/TransportActionProxy.java
@@ -38,8 +38,6 @@
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.util.function.Function;
diff --git a/server/src/main/java/org/opensearch/transport/TransportHandshaker.java b/server/src/main/java/org/opensearch/transport/TransportHandshaker.java
index 71eef9b00b1d8..1bdee8e1fca29 100644
--- a/server/src/main/java/org/opensearch/transport/TransportHandshaker.java
+++ b/server/src/main/java/org/opensearch/transport/TransportHandshaker.java
@@ -42,8 +42,6 @@
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.threadpool.ThreadPool;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.EOFException;
 import java.io.IOException;
 import java.util.concurrent.ConcurrentHashMap;
diff --git a/server/src/main/java/org/opensearch/transport/TransportMessage.java b/server/src/main/java/org/opensearch/transport/TransportMessage.java
index 6698bc7c31c47..7e080c4b8dcf3 100644
--- a/server/src/main/java/org/opensearch/transport/TransportMessage.java
+++ b/server/src/main/java/org/opensearch/transport/TransportMessage.java
@@ -37,8 +37,6 @@
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.common.transport.TransportAddress;
 
-import com.google.protobuf.CodedInputStream;
-
 /**
  * Message over the transport interface
  *
@@ -68,7 +66,7 @@ public TransportMessage() {}
     public TransportMessage(StreamInput in) {}
 
      /**
-     * Constructs a new transport message with the data from the {@link CodedInputStream}. This is
+     * Constructs a new transport message with the data from the {@link byte[]}. This is
     * currently a no-op
     */
     public TransportMessage(byte[] in) {}
diff --git a/server/src/main/java/org/opensearch/transport/TransportRequest.java b/server/src/main/java/org/opensearch/transport/TransportRequest.java
index 940bbc7006b14..7a81a03e62a21 100644
--- a/server/src/main/java/org/opensearch/transport/TransportRequest.java
+++ b/server/src/main/java/org/opensearch/transport/TransportRequest.java
@@ -42,9 +42,6 @@
 import org.opensearch.tasks.TaskAwareRequest;
 import org.opensearch.tasks.TaskId;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.io.OutputStream;
 
diff --git a/server/src/main/java/org/opensearch/transport/TransportResponse.java b/server/src/main/java/org/opensearch/transport/TransportResponse.java
index e9d56fcb57cc2..52f00a0b1abef 100644
--- a/server/src/main/java/org/opensearch/transport/TransportResponse.java
+++ b/server/src/main/java/org/opensearch/transport/TransportResponse.java
@@ -35,9 +35,6 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.io.OutputStream;
 
diff --git a/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java
index 228605bf8820b..dd52b15e1eee5 100644
--- a/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java
+++ b/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java
@@ -34,7 +34,6 @@
 
 import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
-import org.opensearch.common.io.stream.TryWriteable;
 import org.opensearch.core.common.io.stream.Writeable;
 
 import java.io.IOException;
@@ -86,7 +85,7 @@ public Q read(byte[] in) throws IOException {
 
     default <Q extends TransportResponse> TransportResponseHandler<Q> wrapProtobuf(
         Function<Q, T> converter,
-        TryWriteable.Reader<Q> reader
+        ProtobufWriteable.Reader<Q> reader
     ) {
         final TransportResponseHandler<T> self = this;
         return new TransportResponseHandler<Q>() {
diff --git a/server/src/main/java/org/opensearch/transport/TransportService.java b/server/src/main/java/org/opensearch/transport/TransportService.java
index 53d25182cbda1..8255786bb15e6 100644
--- a/server/src/main/java/org/opensearch/transport/TransportService.java
+++ b/server/src/main/java/org/opensearch/transport/TransportService.java
@@ -64,16 +64,12 @@
 import org.opensearch.core.common.Strings;
 import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
 import org.opensearch.node.NodeClosedException;
-import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.node.ReportingService;
 import org.opensearch.tasks.Task;
 import org.opensearch.tasks.TaskManager;
 import org.opensearch.threadpool.Scheduler;
 import org.opensearch.threadpool.ThreadPool;
 
-import com.google.protobuf.CodedInputStream;
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.net.UnknownHostException;
diff --git a/server/src/main/proto/server/ClusterStateResponseProto.proto b/server/src/main/proto/server/ClusterStateResponseProto.proto
index 686790a166bab..2894dff625b8f 100644
--- a/server/src/main/proto/server/ClusterStateResponseProto.proto
+++ b/server/src/main/proto/server/ClusterStateResponseProto.proto
@@ -26,7 +26,7 @@ message ClusterStateRes {
     DiscoveryNodes nodes = 4;
 
     message DiscoveryNodes {
-        map<string, Node> allNodes = 1;
+        repeated Node allNodes = 1;
         string clusterManagerNodeId = 2;
         string localNodeId = 3;
         string minNonClientNodeVersion = 4;
diff --git a/server/src/test/java/org/opensearch/action/admin/cluster/configuration/TransportAddVotingConfigExclusionsActionTests.java b/server/src/test/java/org/opensearch/action/admin/cluster/configuration/TransportAddVotingConfigExclusionsActionTests.java
index 149e85c50b36c..22f9fef0356b7 100644
--- a/server/src/test/java/org/opensearch/action/admin/cluster/configuration/TransportAddVotingConfigExclusionsActionTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/cluster/configuration/TransportAddVotingConfigExclusionsActionTests.java
@@ -60,13 +60,10 @@
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.threadpool.ThreadPool.Names;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
@@ -689,16 +686,11 @@ public AddVotingConfigExclusionsResponse read(StreamInput in) throws IOException
             }
 
             @Override
-            public AddVotingConfigExclusionsResponse read(CodedInputStream in) throws IOException {
+            public AddVotingConfigExclusionsResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         };
     }
 
diff --git a/server/src/test/java/org/opensearch/action/admin/cluster/configuration/TransportClearVotingConfigExclusionsActionTests.java b/server/src/test/java/org/opensearch/action/admin/cluster/configuration/TransportClearVotingConfigExclusionsActionTests.java
index a4366e8061e0f..dd43aa63f9aa8 100644
--- a/server/src/test/java/org/opensearch/action/admin/cluster/configuration/TransportClearVotingConfigExclusionsActionTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/cluster/configuration/TransportClearVotingConfigExclusionsActionTests.java
@@ -54,13 +54,10 @@
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.threadpool.ThreadPool.Names;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
@@ -256,16 +253,11 @@ public ClearVotingConfigExclusionsResponse read(StreamInput in) throws IOExcepti
             }
 
             @Override
-            public ClearVotingConfigExclusionsResponse read(CodedInputStream in) throws IOException {
+            public ClearVotingConfigExclusionsResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         };
     }
 }
diff --git a/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationAllPermitsAcquisitionTests.java b/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationAllPermitsAcquisitionTests.java
index b65dc2cf3ed77..be43223505a9a 100644
--- a/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationAllPermitsAcquisitionTests.java
+++ b/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationAllPermitsAcquisitionTests.java
@@ -68,15 +68,12 @@
 import org.opensearch.core.rest.RestStatus;
 import org.opensearch.test.transport.MockTransport;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportMessageListener;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import org.junit.After;
 import org.junit.Before;
 
@@ -229,16 +226,11 @@ public String executor() {
                         }
 
                         @Override
-                        public ReplicaResponse read(CodedInputStream in) throws IOException {
+                        public ReplicaResponse read(byte[] in) throws IOException {
                             // TODO Auto-generated method stub
                             throw new UnsupportedOperationException("Unimplemented method 'read'");
                         }
 
-                        @Override
-                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                            // TODO Auto-generated method stub
-                            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                        }
                     }
                 );
             }
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/CoordinatorTests.java b/server/src/test/java/org/opensearch/cluster/coordination/CoordinatorTests.java
index 0ee0e71a85b10..da0e20fb0010e 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/CoordinatorTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/CoordinatorTests.java
@@ -58,8 +58,6 @@
 import org.opensearch.monitor.StatusInfo;
 import org.opensearch.test.MockLogAppender;
 
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.HashSet;
@@ -1469,12 +1467,6 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
             return builder;
         }
 
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
-        }
-
     }
 
     public void testClusterRecoversAfterExceptionDuringSerialization() {
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/FollowersCheckerTests.java b/server/src/test/java/org/opensearch/cluster/coordination/FollowersCheckerTests.java
index 42b914307153f..0b84eaf1ae6db 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/FollowersCheckerTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/FollowersCheckerTests.java
@@ -51,7 +51,6 @@
 import org.opensearch.test.transport.MockTransport;
 import org.opensearch.threadpool.ThreadPool.Names;
 import org.opensearch.transport.ConnectTransportException;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportResponse;
@@ -59,8 +58,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -526,16 +523,11 @@ public String executor() {
                 }
 
                 @Override
-                public Empty read(CodedInputStream in) throws IOException {
+                public Empty read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         );
         deterministicTaskQueue.runAllTasks();
@@ -624,16 +616,11 @@ public String executor() {
                     }
 
                     @Override
-                    public Empty read(CodedInputStream in) throws IOException {
+                    public Empty read(byte[] in) throws IOException {
                         // TODO Auto-generated method stub
                         throw new UnsupportedOperationException("Unimplemented method 'read'");
                     }
 
-                    @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                    }
                 }
             );
             deterministicTaskQueue.runAllTasks();
@@ -708,16 +695,11 @@ public String executor() {
                     }
 
                     @Override
-                    public Empty read(CodedInputStream in) throws IOException {
+                    public Empty read(byte[] in) throws IOException {
                         // TODO Auto-generated method stub
                         throw new UnsupportedOperationException("Unimplemented method 'read'");
                     }
 
-                    @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                    }
                 }
             );
             deterministicTaskQueue.runAllTasks();
@@ -820,16 +802,10 @@ public TransportResponse.Empty read(StreamInput in) {
         }
 
         @Override
-        public Empty read(CodedInputStream in) throws IOException {
+        public Empty read(byte[] in) throws IOException {
             // TODO Auto-generated method stub
             throw new UnsupportedOperationException("Unimplemented method 'read'");
         }
 
-        @Override
-        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-        }
-
     }
 }
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/LeaderCheckerTests.java b/server/src/test/java/org/opensearch/cluster/coordination/LeaderCheckerTests.java
index 46cf8d67a78f1..cf3cab116716a 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/LeaderCheckerTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/LeaderCheckerTests.java
@@ -48,7 +48,6 @@
 import org.opensearch.test.transport.MockTransport;
 import org.opensearch.threadpool.ThreadPool.Names;
 import org.opensearch.transport.ConnectTransportException;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportResponse;
@@ -56,8 +55,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
@@ -544,16 +541,11 @@ public TransportResponse.Empty read(StreamInput in) {
         }
 
         @Override
-        public Empty read(CodedInputStream in) throws IOException {
+        public Empty read(byte[] in) throws IOException {
             // TODO Auto-generated method stub
             throw new UnsupportedOperationException("Unimplemented method 'read'");
         }
 
-        @Override
-        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-        }
     }
 
     public void testLeaderCheckRequestEqualsHashcodeSerialization() {
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/PreVoteCollectorTests.java b/server/src/test/java/org/opensearch/cluster/coordination/PreVoteCollectorTests.java
index 5d362c9de7cb4..15e5c8ed978fc 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/PreVoteCollectorTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/PreVoteCollectorTests.java
@@ -43,15 +43,12 @@
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.transport.MockTransport;
 import org.opensearch.transport.ConnectTransportException;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.RemoteTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import org.junit.Before;
 
 import java.io.IOException;
@@ -355,16 +352,11 @@ public String executor() {
                 }
 
                 @Override
-                public PreVoteResponse read(CodedInputStream in) throws IOException {
+                public PreVoteResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         );
 
diff --git a/server/src/test/java/org/opensearch/cluster/serialization/DiffableTests.java b/server/src/test/java/org/opensearch/cluster/serialization/DiffableTests.java
index 19e2566abb38f..326c0fe55163c 100644
--- a/server/src/test/java/org/opensearch/cluster/serialization/DiffableTests.java
+++ b/server/src/test/java/org/opensearch/cluster/serialization/DiffableTests.java
@@ -42,8 +42,6 @@
 import org.opensearch.common.util.set.Sets;
 import org.opensearch.test.OpenSearchTestCase;
 
-import com.google.protobuf.CodedOutputStream;
-
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -340,11 +338,6 @@ public int hashCode() {
             return value != null ? value.hashCode() : 0;
         }
 
-        @Override
-        public void writeTo(CodedOutputStream out) throws IOException {
-            // TODO Auto-generated method stub
-            throw new UnsupportedOperationException("Unimplemented method 'writeTo'");
-        }
     }
 
 }
diff --git a/server/src/test/java/org/opensearch/discovery/PeerFinderTests.java b/server/src/test/java/org/opensearch/discovery/PeerFinderTests.java
index 876d23c35bc2b..d0273bca3b31f 100644
--- a/server/src/test/java/org/opensearch/discovery/PeerFinderTests.java
+++ b/server/src/test/java/org/opensearch/discovery/PeerFinderTests.java
@@ -51,13 +51,10 @@
 import org.opensearch.threadpool.ThreadPool.Names;
 import org.opensearch.transport.ClusterConnectionManager;
 import org.opensearch.transport.ConnectionManager;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import org.junit.After;
 import org.junit.Before;
 
@@ -551,16 +548,11 @@ public String executor() {
                 }
 
                 @Override
-                public PeersResponse read(CodedInputStream in) throws IOException {
+                public PeersResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         );
 
diff --git a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationSourceServiceTests.java b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationSourceServiceTests.java
index 460ba1e02be70..85252473365f7 100644
--- a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationSourceServiceTests.java
+++ b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationSourceServiceTests.java
@@ -33,14 +33,11 @@
 import org.opensearch.test.transport.CapturingTransport;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
@@ -223,16 +220,11 @@ public CheckpointInfoResponse read(StreamInput in) throws IOException {
                 }
 
                 @Override
-                public CheckpointInfoResponse read(CodedInputStream in) throws IOException {
+                public CheckpointInfoResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         );
     }
@@ -264,16 +256,11 @@ public GetSegmentFilesResponse read(StreamInput in) throws IOException {
                 }
 
                 @Override
-                public GetSegmentFilesResponse read(CodedInputStream in) throws IOException {
+                public GetSegmentFilesResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         );
     }
diff --git a/server/src/test/java/org/opensearch/transport/InboundHandlerTests.java b/server/src/test/java/org/opensearch/transport/InboundHandlerTests.java
index 07ab2246dfd89..50efcf8b285f9 100644
--- a/server/src/test/java/org/opensearch/transport/InboundHandlerTests.java
+++ b/server/src/test/java/org/opensearch/transport/InboundHandlerTests.java
@@ -56,8 +56,6 @@
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
 
-import com.google.protobuf.CodedInputStream;
-
 import org.junit.After;
 import org.junit.Before;
 
@@ -184,16 +182,11 @@ public TestResponse read(StreamInput in) throws IOException {
             }
 
             @Override
-            public TestResponse read(CodedInputStream in) throws IOException {
+            public TestResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         }, null, action));
         RequestHandlerRegistry<TestRequest> registry = new RequestHandlerRegistry<>(
             action,
@@ -383,16 +376,11 @@ public TestResponse read(StreamInput in) throws IOException {
             }
 
             @Override
-            public TestResponse read(CodedInputStream in) throws IOException {
+            public TestResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         }, null, action));
 
         RequestHandlerRegistry<TestRequest> registry = new RequestHandlerRegistry<>(
@@ -467,16 +455,11 @@ public TestResponse read(StreamInput in) throws IOException {
             }
 
             @Override
-            public TestResponse read(CodedInputStream in) throws IOException {
+            public TestResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         }, null, action));
 
         RequestHandlerRegistry<TestRequest> registry = new RequestHandlerRegistry<>(
@@ -552,16 +535,11 @@ public TestResponse read(StreamInput in) throws IOException {
             }
 
             @Override
-            public TestResponse read(CodedInputStream in) throws IOException {
+            public TestResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         }, null, action));
         RequestHandlerRegistry<TestRequest> registry = new RequestHandlerRegistry<>(
             action,
@@ -652,16 +630,11 @@ public TestResponse read(StreamInput in) throws IOException {
             }
 
             @Override
-            public TestResponse read(CodedInputStream in) throws IOException {
+            public TestResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         }, null, action));
         RequestHandlerRegistry<TestRequest> registry = new RequestHandlerRegistry<>(
             action,
diff --git a/server/src/test/java/org/opensearch/transport/TransportActionProxyTests.java b/server/src/test/java/org/opensearch/transport/TransportActionProxyTests.java
index 8aa8a6b1f03e8..40280696af870 100644
--- a/server/src/test/java/org/opensearch/transport/TransportActionProxyTests.java
+++ b/server/src/test/java/org/opensearch/transport/TransportActionProxyTests.java
@@ -44,8 +44,6 @@
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
 
-import com.google.protobuf.CodedInputStream;
-
 import org.junit.Before;
 
 import java.io.IOException;
@@ -152,16 +150,11 @@ public String executor() {
                 }
 
                 @Override
-                public SimpleTestResponse read(CodedInputStream in) throws IOException {
+                public SimpleTestResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         );
         latch.await();
@@ -224,16 +217,11 @@ public String executor() {
                 }
 
                 @Override
-                public SimpleTestResponse read(CodedInputStream in) throws IOException {
+                public SimpleTestResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         );
         latch.await();
diff --git a/server/src/test/java/org/opensearch/transport/TransportServiceDeserializationFailureTests.java b/server/src/test/java/org/opensearch/transport/TransportServiceDeserializationFailureTests.java
index 10664113539a2..7a01bc0276114 100644
--- a/server/src/test/java/org/opensearch/transport/TransportServiceDeserializationFailureTests.java
+++ b/server/src/test/java/org/opensearch/transport/TransportServiceDeserializationFailureTests.java
@@ -47,8 +47,6 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportResponse.Empty;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
@@ -137,16 +135,11 @@ public String toString() {
                     }
 
                     @Override
-                    public Empty read(CodedInputStream in) throws IOException {
+                    public Empty read(byte[] in) throws IOException {
                         // TODO Auto-generated method stub
                         throw new UnsupportedOperationException("Unimplemented method 'read'");
                     }
 
-                    @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                    }
                 }
             );
 
@@ -205,16 +198,11 @@ public String toString() {
                     }
 
                     @Override
-                    public Empty read(CodedInputStream in) throws IOException {
+                    public Empty read(byte[] in) throws IOException {
                         // TODO Auto-generated method stub
                         throw new UnsupportedOperationException("Unimplemented method 'read'");
                     }
 
-                    @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                    }
                 }
             );
 
diff --git a/test/framework/src/main/java/org/opensearch/transport/AbstractSimpleTransportTestCase.java b/test/framework/src/main/java/org/opensearch/transport/AbstractSimpleTransportTestCase.java
index 1edfe3a350e90..5fc4633448caa 100644
--- a/test/framework/src/main/java/org/opensearch/transport/AbstractSimpleTransportTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/transport/AbstractSimpleTransportTestCase.java
@@ -76,8 +76,6 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportResponse.Empty;
 
-import com.google.protobuf.CodedInputStream;
-
 import org.junit.After;
 import org.junit.Before;
 
@@ -330,16 +328,11 @@ public void handleException(TransportException exp) {
                 }
 
                 @Override
-                public StringMessageResponse read(CodedInputStream in) throws IOException {
+                public StringMessageResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         );
 
@@ -378,16 +371,11 @@ public void handleException(TransportException exp) {
                 }
 
                 @Override
-                public StringMessageResponse read(CodedInputStream in) throws IOException {
+                public StringMessageResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         );
 
@@ -447,16 +435,10 @@ public void handleException(TransportException exp) {
             }
 
             @Override
-            public StringMessageResponse read(CodedInputStream in) throws IOException {
+            public StringMessageResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
-
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         };
         StringMessageRequest ping = new StringMessageRequest("ping");
         threadPool.getThreadContext().putHeader("test.ping.user", "ping_user");
@@ -518,16 +500,11 @@ public String executor() {
                 }
 
                 @Override
-                public StringMessageResponse read(CodedInputStream in) throws IOException {
+                public StringMessageResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         );
         responseLatch.await();
@@ -713,16 +690,11 @@ public void handleException(TransportException exp) {
                     }
 
                     @Override
-                    public Empty read(CodedInputStream in) throws IOException {
+                    public Empty read(byte[] in) throws IOException {
                         // TODO Auto-generated method stub
                         throw new UnsupportedOperationException("Unimplemented method 'read'");
                     }
 
-                    @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                    }
                 }
             );
 
@@ -787,16 +759,11 @@ public void handleException(TransportException exp) {
                     }
 
                     @Override
-                    public StringMessageResponse read(CodedInputStream in) throws IOException {
+                    public StringMessageResponse read(byte[] in) throws IOException {
                         // TODO Auto-generated method stub
                         throw new UnsupportedOperationException("Unimplemented method 'read'");
                     }
 
-                    @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                    }
                 }
             );
 
@@ -846,16 +813,11 @@ public void handleException(TransportException exp) {
                 }
 
                 @Override
-                public StringMessageResponse read(CodedInputStream in) throws IOException {
+                public StringMessageResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         );
 
@@ -1107,16 +1069,11 @@ public void handleException(TransportException exp) {
                 }
 
                 @Override
-                public StringMessageResponse read(CodedInputStream in) throws IOException {
+                public StringMessageResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         );
 
@@ -1193,16 +1150,11 @@ public void handleException(TransportException exp) {
                 }
 
                 @Override
-                public StringMessageResponse read(CodedInputStream in) throws IOException {
+                public StringMessageResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         );
 
@@ -1246,16 +1198,11 @@ public void handleException(TransportException exp) {
                     }
 
                     @Override
-                    public StringMessageResponse read(CodedInputStream in) throws IOException {
+                    public StringMessageResponse read(byte[] in) throws IOException {
                         // TODO Auto-generated method stub
                         throw new UnsupportedOperationException("Unimplemented method 'read'");
                     }
 
-                    @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                    }
                 }
             );
 
@@ -1302,16 +1249,11 @@ public String executor() {
             }
 
             @Override
-            public StringMessageResponse read(CodedInputStream in) throws IOException {
+            public StringMessageResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         };
 
         serviceA.registerRequestHandler("internal:test", ThreadPool.Names.SAME, StringMessageRequest::new, handler);
@@ -1609,16 +1551,11 @@ public String executor() {
                 }
 
                 @Override
-                public Version0Response read(CodedInputStream in) throws IOException {
+                public Version0Response read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         ).txGet();
 
@@ -1672,16 +1609,11 @@ public String executor() {
                 }
 
                 @Override
-                public Version1Response read(CodedInputStream in) throws IOException {
+                public Version1Response read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         ).txGet();
 
@@ -1729,16 +1661,11 @@ public String executor() {
                 }
 
                 @Override
-                public Version1Response read(CodedInputStream in) throws IOException {
+                public Version1Response read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         ).txGet();
 
@@ -1783,16 +1710,11 @@ public String executor() {
                 }
 
                 @Override
-                public Version0Response read(CodedInputStream in) throws IOException {
+                public Version0Response read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         ).txGet();
 
@@ -1840,16 +1762,11 @@ public void handleException(TransportException exp) {
                 }
 
                 @Override
-                public StringMessageResponse read(CodedInputStream in) throws IOException {
+                public StringMessageResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         );
 
@@ -1916,16 +1833,11 @@ public void handleException(TransportException exp) {
                 }
 
                 @Override
-                public StringMessageResponse read(CodedInputStream in) throws IOException {
+                public StringMessageResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
 
-                @Override
-                public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                    // TODO Auto-generated method stub
-                    throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                }
             }
         );
 
@@ -1979,16 +1891,11 @@ public String executor() {
             }
 
             @Override
-            public TestResponse read(CodedInputStream in) throws IOException {
+            public TestResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         });
 
         if (!latch.await(10, TimeUnit.SECONDS)) {
@@ -2039,16 +1946,11 @@ public String executor() {
                         }
 
                         @Override
-                        public TestResponse read(CodedInputStream in) throws IOException {
+                        public TestResponse read(byte[] in) throws IOException {
                             // TODO Auto-generated method stub
                             throw new UnsupportedOperationException("Unimplemented method 'read'");
                         }
 
-                        @Override
-                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                            // TODO Auto-generated method stub
-                            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                        }
                     }
                 );
 
@@ -2086,16 +1988,11 @@ public String executor() {
                         }
 
                         @Override
-                        public TestResponse read(CodedInputStream in) throws IOException {
+                        public TestResponse read(byte[] in) throws IOException {
                             // TODO Auto-generated method stub
                             throw new UnsupportedOperationException("Unimplemented method 'read'");
                         }
 
-                        @Override
-                        public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                            // TODO Auto-generated method stub
-                            throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                        }
                     }
                 );
 
@@ -2256,16 +2153,11 @@ public String executor() {
                             }
 
                             @Override
-                            public TestResponse read(CodedInputStream in) throws IOException {
+                            public TestResponse read(byte[] in) throws IOException {
                                 // TODO Auto-generated method stub
                                 throw new UnsupportedOperationException("Unimplemented method 'read'");
                             }
 
-                            @Override
-                            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                                // TODO Auto-generated method stub
-                                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                            }
                         }
                     );
                 } else {
@@ -2330,16 +2222,11 @@ public String executor() {
             }
 
             @Override
-            public TestResponse read(CodedInputStream in) throws IOException {
+            public TestResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         }
 
         for (int i = 0; i < iters; i++) {
@@ -2677,16 +2564,11 @@ public String executor() {
             }
 
             @Override
-            public TransportResponse read(CodedInputStream in) throws IOException {
+            public TransportResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         };
 
         serviceB.sendRequest(nodeA, "internal:action", new TestRequest(randomFrom("fail", "pass")), transportResponseHandler);
@@ -2739,16 +2621,11 @@ public String executor() {
             }
 
             @Override
-            public TransportResponse read(CodedInputStream in) throws IOException {
+            public TransportResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         };
         ConnectionProfile.Builder builder = new ConnectionProfile.Builder();
         builder.addConnections(
@@ -2821,16 +2698,11 @@ public String executor() {
             }
 
             @Override
-            public TransportResponse read(CodedInputStream in) throws IOException {
+            public TransportResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         };
 
         ConnectionProfile.Builder builder = new ConnectionProfile.Builder();
@@ -2907,16 +2779,11 @@ public String executor() {
             }
 
             @Override
-            public TransportResponse read(CodedInputStream in) throws IOException {
+            public TransportResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         };
 
         TransportStats stats = serviceC.transport.getStats(); // nothing transmitted / read yet
@@ -3040,16 +2907,11 @@ public String executor() {
             }
 
             @Override
-            public TransportResponse read(CodedInputStream in) throws IOException {
+            public TransportResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         };
 
         TransportStats stats = serviceC.transport.getStats(); // nothing transmitted / read yet
@@ -3439,16 +3301,11 @@ public TransportResponse read(final StreamInput in) {
                     }
 
                     @Override
-                    public TransportResponse read(CodedInputStream in) throws IOException {
+                    public TransportResponse read(byte[] in) throws IOException {
                         // TODO Auto-generated method stub
                         throw new UnsupportedOperationException("Unimplemented method 'read'");
                     }
 
-                    @Override
-                    public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                        // TODO Auto-generated method stub
-                        throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-                    }
                 }
             );
             assertThat(te.get(), not(nullValue()));
diff --git a/test/framework/src/test/java/org/opensearch/test/disruption/DisruptableMockTransportTests.java b/test/framework/src/test/java/org/opensearch/test/disruption/DisruptableMockTransportTests.java
index 2455e5ce9c23c..0ea90005cf7cf 100644
--- a/test/framework/src/test/java/org/opensearch/test/disruption/DisruptableMockTransportTests.java
+++ b/test/framework/src/test/java/org/opensearch/test/disruption/DisruptableMockTransportTests.java
@@ -45,7 +45,6 @@
 import org.opensearch.test.disruption.DisruptableMockTransport.ConnectionStatus;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ConnectTransportException;
-import org.opensearch.transport.ProtobufTransportException;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
@@ -55,8 +54,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import org.junit.Before;
 
 import java.io.IOException;
@@ -236,16 +233,11 @@ public String executor() {
             }
 
             @Override
-            public TransportResponse read(CodedInputStream in) throws IOException {
+            public TransportResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         };
     }
 
@@ -272,16 +264,11 @@ public String executor() {
             }
 
             @Override
-            public TransportResponse read(CodedInputStream in) throws IOException {
+            public TransportResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         };
     }
 
@@ -308,16 +295,11 @@ public String executor() {
             }
 
             @Override
-            public TransportResponse read(CodedInputStream in) throws IOException {
+            public TransportResponse read(byte[] in) throws IOException {
                 // TODO Auto-generated method stub
                 throw new UnsupportedOperationException("Unimplemented method 'read'");
             }
 
-            @Override
-            public void handleExceptionProtobuf(ProtobufTransportException exp) {
-                // TODO Auto-generated method stub
-                throw new UnsupportedOperationException("Unimplemented method 'handleExceptionProtobuf'");
-            }
         };
     }
 
diff --git a/test/framework/src/test/java/org/opensearch/test/disruption/NetworkDisruptionIT.java b/test/framework/src/test/java/org/opensearch/test/disruption/NetworkDisruptionIT.java
index 0ee1146c52ccf..91b235706fc9c 100644
--- a/test/framework/src/test/java/org/opensearch/test/disruption/NetworkDisruptionIT.java
+++ b/test/framework/src/test/java/org/opensearch/test/disruption/NetworkDisruptionIT.java
@@ -50,8 +50,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-import com.google.protobuf.CodedInputStream;
-
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.Collection;
@@ -218,10 +216,11 @@ public TransportResponse read(StreamInput in) throws IOException {
                 }
 
                 @Override
-                public TransportResponse read(CodedInputStream in) throws IOException {
+                public TransportResponse read(byte[] in) throws IOException {
                     // TODO Auto-generated method stub
                     throw new UnsupportedOperationException("Unimplemented method 'read'");
                 }
+
             }
         );
     }

From d5f3a0e995c94f41c28fb8378a0580ac67d1e908 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Wed, 2 Aug 2023 02:13:49 +0000
Subject: [PATCH 26/37] Performance improvements

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../admin/cluster/node/info/ProtobufNodeInfo.java    |  5 +++++
 .../cluster/node/info/ProtobufNodesInfoRequest.java  |  5 +++++
 .../admin/cluster/node/stats/ProtobufNodeStats.java  |  5 +++++
 .../node/stats/ProtobufNodesStatsRequest.java        |  6 ++++++
 .../cluster/state/ProtobufClusterStateRequest.java   |  4 ++++
 .../cluster/state/ProtobufClusterStateResponse.java  |  4 ++++
 .../state/ProtobufTransportClusterStateAction.java   |  1 -
 .../cluster/state/TransportClusterStateAction.java   |  1 -
 .../org/opensearch/cluster/metadata/Metadata.java    |  1 -
 .../java/org/opensearch/rest/RestController.java     |  5 +++++
 .../org/opensearch/transport/InboundHandler.java     | 12 ++++++------
 11 files changed, 40 insertions(+), 9 deletions(-)

diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
index 8a60d01dbf8ec..fc259315110b7 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
@@ -69,6 +69,11 @@ public ProtobufNodeInfo(byte[] data) throws InvalidProtocolBufferException {
         this.nodesInfoResponse = NodesInfoProto.NodesInfo.parseFrom(data);
     }
 
+    public ProtobufNodeInfo(NodesInfoProto.NodesInfo nodesInfo) throws InvalidProtocolBufferException {
+        super(nodesInfo.toByteArray());
+        this.nodesInfoResponse = nodesInfo;
+    }
+
     public ProtobufNodeInfo(
         Version version,
         Build build,
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
index 5d47ec213dc29..d4222f6def154 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
@@ -71,6 +71,11 @@ public ProtobufNodesInfoRequest(byte[] data) throws IOException {
         this.nodesInfoRequest = NodesInfoRequestProto.NodesInfoReq.parseFrom(data);
     }
 
+    public ProtobufNodesInfoRequest(NodesInfoRequestProto.NodesInfoReq nodesInfoRequest) throws IOException {
+        super(nodesInfoRequest.toByteArray());
+        this.nodesInfoRequest = nodesInfoRequest;
+    }
+
     /**
      * An enumeration of the "core" sections of metrics that may be requested
      * from the nodes information endpoint. Eventually this list list will be
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
index 3e6073f380e27..42dfe806468a2 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
@@ -54,6 +54,11 @@ public ProtobufNodeStats(byte[] data) throws InvalidProtocolBufferException {
         this.nodesStatsResponse = NodesStatsProto.NodesStats.parseFrom(data);
     }
 
+    public ProtobufNodeStats(NodesStatsProto.NodesStats nodesStats) throws InvalidProtocolBufferException {
+        super(nodesStats.toByteArray());
+        this.nodesStatsResponse = nodesStats;
+    }
+
     public ProtobufNodeStats(
         DiscoveryNode node,
         long timestamp,
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
index 89543c2c2ca85..54c7063220ac8 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
@@ -11,6 +11,7 @@
 import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
 import org.opensearch.action.support.nodes.ProtobufBaseNodesRequest;
 import org.opensearch.server.proto.NodesStatsRequestProto.NodesStatsReq;
+import org.opensearch.server.proto.NodesInfoRequestProto;
 import org.opensearch.server.proto.NodesStatsRequestProto;
 
 import java.io.IOException;
@@ -146,6 +147,11 @@ public ProtobufNodesStatsRequest(byte[] data) throws IOException {
         this.nodesStatsRequest = NodesStatsRequestProto.NodesStatsReq.parseFrom(data);
     }
 
+     public ProtobufNodesStatsRequest(NodesStatsRequestProto.NodesStatsReq nodesStatsRequest) throws IOException {
+        super(nodesStatsRequest.toByteArray());
+        this.nodesStatsRequest = nodesStatsRequest;
+    }
+
     /**
      * An enumeration of the "core" sections of metrics that may be requested
     * from the nodes stats endpoint. Eventually this list will be pluggable.
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
index dee9b934b51fe..4127cd55012c6 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
@@ -205,6 +205,10 @@ public ProtobufClusterStateRequest(byte[] data) throws IOException {
         this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.parseFrom(data);
     }
 
+    public ProtobufClusterStateRequest(ClusterStateRequestProto.ClusterStateReq clusterStateRequest) {
+        this.clusterStateRequest = clusterStateRequest;
+    }
+
     @Override
     public void writeTo(OutputStream out) throws IOException {
         out.write(this.clusterStateRequest.toByteArray());
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
index d580e30575b77..6b73013b2da0d 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
@@ -94,6 +94,10 @@ public ProtobufClusterStateResponse(byte[] data) throws IOException {
         this.clusterStateRes = ClusterStateResponseProto.ClusterStateRes.parseFrom(data);
     }
 
+    public ProtobufClusterStateResponse(ClusterStateResponseProto.ClusterStateRes clusterStateRes) {
+        this.clusterStateRes = clusterStateRes;
+    }
+
     @Override
     public void writeTo(OutputStream out) throws IOException {
         out.write(this.clusterStateRes.toByteArray());
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
index 855685297e1c8..7b50a427aaa50 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
@@ -139,7 +139,6 @@ public void onTimeout(TimeValue timeout) {
     }
 
     private ProtobufClusterStateResponse buildResponse(final ProtobufClusterStateRequest request, final ClusterState currentState) {
-        System.out.println("Coming in build response for cluster state");
         logger.trace("Serving cluster state request using version {}", currentState.version());
         return new ProtobufClusterStateResponse(currentState.getClusterName().value(), currentState.nodes(), currentState.version(), currentState.stateUUID(), false);
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
index ac8d93cc55fcd..05e817b4e9339 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
@@ -166,7 +166,6 @@ public void onTimeout(TimeValue timeout) {
     }
 
     private ClusterStateResponse buildResponse(final ClusterStateRequest request, final ClusterState currentState) {
-        System.out.println("Coming in build response for cluster state");
         logger.trace("Serving cluster state request using version {}", currentState.version());
         ClusterState.Builder builder = ClusterState.builder(currentState.getClusterName());
         builder.version(currentState.version());
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java b/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java
index aa8d8af0f01a3..47fa1c6399ef1 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java
@@ -93,7 +93,6 @@
 import java.util.stream.StreamSupport;
 
 import static org.opensearch.common.settings.Settings.readSettingsFromStream;
-import static org.opensearch.common.settings.Settings.readSettingsFromStreamProtobuf;
 import static org.opensearch.common.settings.Settings.writeSettingsToStream;
 
 /**
diff --git a/server/src/main/java/org/opensearch/rest/RestController.java b/server/src/main/java/org/opensearch/rest/RestController.java
index 172152ac9cfab..57fd542fb24b3 100644
--- a/server/src/main/java/org/opensearch/rest/RestController.java
+++ b/server/src/main/java/org/opensearch/rest/RestController.java
@@ -576,7 +576,10 @@ private void tryAllHandlers(final RestRequest request, final RestChannel channel
                     }
                 } else {
                     if (rawPath.contains("protobuf")) {
+                        long startTime = System.nanoTime();
                         dispatchProtobufRequest(request, channel, protobufHandler);
+                        long endTime = System.nanoTime();
+                        System.out.println("protobuf request time: " + (endTime - startTime) + "ns");
                     } else {
                     if (FeatureFlags.isEnabled(FeatureFlags.IDENTITY)) {
                         if (!handleAuthenticateUser(request, channel)) {
@@ -585,6 +588,8 @@ private void tryAllHandlers(final RestRequest request, final RestChannel channel
                     }
                         long startTime = System.nanoTime();
                         dispatchRequest(request, channel, handler);
+                        long endTime = System.nanoTime();
+                        System.out.println("original request time: " + (endTime - startTime) + "ns");
                     }
                     return;
                 }
diff --git a/server/src/main/java/org/opensearch/transport/InboundHandler.java b/server/src/main/java/org/opensearch/transport/InboundHandler.java
index c96d26f3f4c7a..0c5ff1af8649e 100644
--- a/server/src/main/java/org/opensearch/transport/InboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/InboundHandler.java
@@ -280,7 +280,7 @@ private <T extends TransportRequest> void handleRequestProtobuf(TcpChannel chann
             assert reg != null;
             if (outboundMsg.hasClusterStateReq()) {
                 final ClusterStateReq clusterStateReq = outboundMsg.getClusterStateReq();
-                ProtobufClusterStateRequest protobufClusterStateRequest = new ProtobufClusterStateRequest(clusterStateReq.toByteArray());
+                ProtobufClusterStateRequest protobufClusterStateRequest = new ProtobufClusterStateRequest(clusterStateReq);
                 final T request = (T) protobufClusterStateRequest;
                 request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
                 final String executor = reg.getExecutor();
@@ -296,7 +296,7 @@ private <T extends TransportRequest> void handleRequestProtobuf(TcpChannel chann
             } else if (outboundMsg.hasNodesInfoReq()) {
                 final NodesInfoReq nodesInfoReq = outboundMsg.getNodesInfoReq();
                 try {
-                    ProtobufNodesInfoRequest protobufNodesInfoRequest = new ProtobufNodesInfoRequest(nodesInfoReq.toByteArray());
+                    ProtobufNodesInfoRequest protobufNodesInfoRequest = new ProtobufNodesInfoRequest(nodesInfoReq);
                     final T request = (T) new NodeInfoRequest(protobufNodesInfoRequest);
                     request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
                     final String executor = reg.getExecutor();
@@ -315,7 +315,7 @@ private <T extends TransportRequest> void handleRequestProtobuf(TcpChannel chann
             } else if (outboundMsg.hasNodesStatsReq()) {
                 final NodesStatsReq nodesStatsReq = outboundMsg.getNodesStatsReq();
                 try {
-                    ProtobufNodesStatsRequest protobufNodesStatsRequest = new ProtobufNodesStatsRequest(nodesStatsReq.toByteArray());
+                    ProtobufNodesStatsRequest protobufNodesStatsRequest = new ProtobufNodesStatsRequest(nodesStatsReq);
                     final T request = (T) new NodeStatsRequest(protobufNodesStatsRequest);
                     request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
                     final String executor = reg.getExecutor();
@@ -556,7 +556,7 @@ private <T extends TransportResponse> void handleProtobufResponse(
             OutboundMsg outboundMsg = message.getMessage();
             if (outboundMsg.hasClusterStateRes()) {
                 final ClusterStateRes clusterStateRes = outboundMsg.getClusterStateRes();
-                ProtobufClusterStateResponse protobufClusterStateResponse = new ProtobufClusterStateResponse(clusterStateRes.toByteArray());
+                ProtobufClusterStateResponse protobufClusterStateResponse = new ProtobufClusterStateResponse(clusterStateRes);
                 final T response = (T) protobufClusterStateResponse;
                 response.remoteAddress(new TransportAddress(remoteAddress));
 
@@ -568,7 +568,7 @@ private <T extends TransportResponse> void handleProtobufResponse(
                 }
             } else if (outboundMsg.hasNodesInfoRes()) {
                 final NodesInfo nodesInfoRes = outboundMsg.getNodesInfoRes();
-                ProtobufNodeInfo protobufNodeInfo = new ProtobufNodeInfo(nodesInfoRes.toByteArray());
+                ProtobufNodeInfo protobufNodeInfo = new ProtobufNodeInfo(nodesInfoRes);
                 final T response = (T) protobufNodeInfo;
                 response.remoteAddress(new TransportAddress(remoteAddress));
 
@@ -580,7 +580,7 @@ private <T extends TransportResponse> void handleProtobufResponse(
                 }
             } else if (outboundMsg.hasNodesStatsRes()) {
                 final NodesStats nodesStatsRes = outboundMsg.getNodesStatsRes();
-                ProtobufNodeStats protobufNodeStats = new ProtobufNodeStats(nodesStatsRes.toByteArray());
+                ProtobufNodeStats protobufNodeStats = new ProtobufNodeStats(nodesStatsRes);
                 final T response = (T) protobufNodeStats;
                 response.remoteAddress(new TransportAddress(remoteAddress));
 

From 2f423b968683c8abd808686e7b2e63e85a9d214d Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Wed, 2 Aug 2023 21:42:49 +0000
Subject: [PATCH 27/37] Fixing compile errors after merging with main

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../src/main/java/org/opensearch/Build.java   |  24 ---
 .../common/io/stream/ProtobufWriteable.java   |   2 +-
 .../org/opensearch/action/ActionModule.java   |  10 +-
 ...ProtobufActionListenerResponseHandler.java |   4 +-
 .../opensearch/action/ProtobufActionType.java |   4 +-
 .../cluster/node/info/ProtobufNodeInfo.java   |   2 +-
 .../cluster/node/stats/ProtobufNodeStats.java |   2 +-
 .../state/ProtobufClusterStateResponse.java   |  10 +-
 .../ProtobufTransportClusterStateAction.java  |   1 -
 .../admin/indices/stats/CommonStatsFlags.java |   1 -
 .../ProtobufHandledTransportAction.java       |   2 +-
 ...obufTransportClusterManagerNodeAction.java |   2 +-
 ...TransportClusterManagerNodeReadAction.java |   2 +-
 .../nodes/ProtobufTransportNodesAction.java   |   4 +-
 .../client/node/ProtobufNodeClient.java       |   2 +-
 .../org/opensearch/cluster/ClusterName.java   |   2 +-
 .../org/opensearch/cluster/ProtobufDiff.java  |   2 +-
 .../opensearch/cluster/ProtobufDiffable.java  |   2 +-
 .../io/stream/ProtobufNamedWriteable.java     |  29 ---
 .../ProtobufNamedWriteableRegistry.java       | 121 ------------
 .../ProtobufVersionedNamedWriteable.java      |  34 ----
 .../common/util/concurrent/ThreadContext.java |  11 --
 .../index/seqno/RetentionLease.java           |   2 +-
 .../index/seqno/RetentionLeaseStats.java      |   2 +-
 .../opensearch/node/ProtobufNodeService.java  |   2 +-
 .../node/ProtobufReportingService.java        |   2 +-
 .../node/ResponseCollectorService.java        |   2 +-
 .../plugins/ProtobufActionPlugin.java         |   2 +-
 .../rest/ProtobufBaseRestHandler.java         |   1 +
 .../rest/ProtobufDeprecationRestHandler.java  |   2 +-
 .../org/opensearch/rest/RestController.java   |  50 +----
 .../action/cat/ProtobufAbstractCatAction.java |   4 +-
 .../action/cat/ProtobufRestCatAction.java     |   2 +-
 .../action/cat/ProtobufRestNodesAction.java   |   2 +-
 .../org/opensearch/tasks/ProtobufTask.java    |   2 +-
 .../org/opensearch/tasks/ProtobufTaskId.java  |   4 +-
 .../opensearch/tasks/ProtobufTaskInfo.java    |   2 +-
 .../tasks/ProtobufTaskResourceStats.java      |   2 +-
 .../opensearch/tasks/ProtobufTaskResult.java  |   7 +-
 .../org/opensearch/tasks/TaskManager.java     | 172 +-----------------
 .../opensearch/tasks/TaskResultsService.java  |   2 +-
 .../opensearch/transport/InboundHandler.java  |   2 +-
 .../opensearch/transport/InboundPipeline.java |   2 +-
 ...ProtobufEmptyTransportResponseHandler.java |   2 +-
 .../ProtobufRequestHandlerRegistry.java       |   2 +-
 .../transport/TransportMessage.java           |   2 +-
 .../transport/TransportResponseHandler.java   |   2 +-
 .../transport/TransportService.java           |   2 +-
 48 files changed, 62 insertions(+), 489 deletions(-)
 rename {server/src/main/java/org/opensearch => libs/core/src/main/java/org/opensearch/core}/common/io/stream/ProtobufWriteable.java (97%)
 delete mode 100644 server/src/main/java/org/opensearch/common/io/stream/ProtobufNamedWriteable.java
 delete mode 100644 server/src/main/java/org/opensearch/common/io/stream/ProtobufNamedWriteableRegistry.java
 delete mode 100644 server/src/main/java/org/opensearch/common/io/stream/ProtobufVersionedNamedWriteable.java

diff --git a/libs/core/src/main/java/org/opensearch/Build.java b/libs/core/src/main/java/org/opensearch/Build.java
index dd238e8684c87..67a50a8a31a0e 100644
--- a/libs/core/src/main/java/org/opensearch/Build.java
+++ b/libs/core/src/main/java/org/opensearch/Build.java
@@ -206,30 +206,6 @@ public String date() {
         return date;
     }
 
-    public static Build readBuild(StreamInput in) throws IOException {
-        // the following is new for opensearch: we write the distribution to support any "forks"
-        final String distribution = in.readString();
-        // be lenient when reading on the wire, the enumeration values from other versions might be different than what we know
-        final Type type = Type.fromDisplayName(in.readString(), false);
-        String hash = in.readString();
-        String date = in.readString();
-        boolean snapshot = in.readBoolean();
-        final String version = in.readString();
-        return new Build(type, hash, date, snapshot, version, distribution);
-    }
-
-    public static void writeBuild(Build build, StreamOutput out) throws IOException {
-        // the following is new for opensearch: we write the distribution name to support any "forks" of the code
-        out.writeString(build.distribution);
-
-        final Type buildType = build.type();
-        out.writeString(buildType.displayName());
-        out.writeString(build.hash());
-        out.writeString(build.date());
-        out.writeBoolean(build.isSnapshot());
-        out.writeString(build.getQualifiedVersion());
-    }
-
     /**
      * Get the distribution name (expected to be OpenSearch; empty if legacy; something else if forked)
      * @return distribution name as a string
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufWriteable.java b/libs/core/src/main/java/org/opensearch/core/common/io/stream/ProtobufWriteable.java
similarity index 97%
rename from server/src/main/java/org/opensearch/common/io/stream/ProtobufWriteable.java
rename to libs/core/src/main/java/org/opensearch/core/common/io/stream/ProtobufWriteable.java
index 9abc2ed7a93e2..b3ac65ff76896 100644
--- a/server/src/main/java/org/opensearch/common/io/stream/ProtobufWriteable.java
+++ b/libs/core/src/main/java/org/opensearch/core/common/io/stream/ProtobufWriteable.java
@@ -11,7 +11,7 @@
 * GitHub history for details.
 */
 
-package org.opensearch.common.io.stream;
+package org.opensearch.core.common.io.stream;
 
 import java.io.IOException;
 import java.io.OutputStream;
diff --git a/server/src/main/java/org/opensearch/action/ActionModule.java b/server/src/main/java/org/opensearch/action/ActionModule.java
index 94ee82cb92f7f..d12944ef59725 100644
--- a/server/src/main/java/org/opensearch/action/ActionModule.java
+++ b/server/src/main/java/org/opensearch/action/ActionModule.java
@@ -555,10 +555,8 @@ public ActionModule(
         this.settingsFilter = settingsFilter;
         this.actionPlugins = actionPlugins;
         this.protobufActionPlugins = new ArrayList<>();
-        ;
         this.protobufActions = new HashMap<String, ProtobufActionPlugin.ActionHandler<?, ?>>();
         this.protobufActionFilters = setupProtobufActionFilters(this.protobufActionPlugins);
-        ;
         this.threadPool = threadPool;
         this.extensionsManager = extensionsManager;
         actions = setupActions(actionPlugins);
@@ -605,7 +603,9 @@ public ActionModule(
         ProtobufNodeClient protobufNodeClient,
         CircuitBreakerService circuitBreakerService,
         UsageService usageService,
-        SystemIndices systemIndices
+        SystemIndices systemIndices,
+        IdentityService identityService,
+        ExtensionsManager extensionsManager
     ) {
         this.settings = settings;
         this.indexNameExpressionResolver = indexNameExpressionResolver;
@@ -614,6 +614,7 @@ public ActionModule(
         this.settingsFilter = settingsFilter;
         this.protobufActionPlugins = protobufActionPlugins;
         this.threadPool = threadPool;
+        this.extensionsManager = extensionsManager;
         this.actionPlugins = actionPlugins;
         actions = setupActions(actionPlugins);
         actionFilters = setupActionFilters(actionPlugins);
@@ -663,7 +664,8 @@ public ActionModule(
             protobufRestWrapper,
             protobufNodeClient,
             circuitBreakerService,
-            usageService
+            usageService,
+            identityService
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java b/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
index 9fe65474a028e..8408897d8fc6c 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
@@ -8,8 +8,8 @@
 
 package org.opensearch.action;
 
-import org.opensearch.common.io.stream.StreamInput;
-import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportException;
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionType.java b/server/src/main/java/org/opensearch/action/ProtobufActionType.java
index b28ce7575c765..1be9c28f3a17f 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionType.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionType.java
@@ -8,8 +8,8 @@
 
 package org.opensearch.action;
 
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.transport.TransportRequestOptions;
 
 /**
@@ -39,7 +39,7 @@ public String name() {
     }
 
     /**
-     * Get a reader that can create a new instance of the class from a {@link org.opensearch.common.io.stream.StreamInput}
+     * Get a reader that can create a new instance of the class from a {@link byte[]}
     */
     public ProtobufWriteable.Reader<Response> getResponseReaderTry() {
         return responseReader;
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
index fc259315110b7..b6f7e6212e626 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
@@ -21,7 +21,7 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.http.HttpInfo;
 import org.opensearch.ingest.IngestInfo;
 import org.opensearch.monitor.jvm.JvmInfo;
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
index 42dfe806468a2..db890313db666 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
@@ -19,7 +19,7 @@
 import org.opensearch.discovery.DiscoveryStats;
 import org.opensearch.http.HttpStats;
 import org.opensearch.indices.NodeIndicesStats;
-import org.opensearch.indices.breaker.AllCircuitBreakerStats;
+import org.opensearch.core.indices.breaker.AllCircuitBreakerStats;
 import org.opensearch.ingest.IngestStats;
 import org.opensearch.monitor.fs.FsInfo;
 import org.opensearch.monitor.jvm.JvmStats;
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
index 6b73013b2da0d..7b7b72fce2bed 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
@@ -13,7 +13,6 @@
 
 package org.opensearch.action.admin.cluster.state;
 
-import com.carrotsearch.hppc.cursors.ObjectCursor;
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.metadata.AliasMetadata;
@@ -21,7 +20,6 @@
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.routing.RoutingNode;
 import org.opensearch.cluster.ClusterName;
-import org.opensearch.common.collect.ImmutableOpenMap;
 import org.opensearch.server.proto.ClusterStateResponseProto;
 import org.opensearch.server.proto.ClusterStateResponseProto.ClusterStateRes;
 
@@ -66,16 +64,16 @@ private List<ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNod
         if (nodes.getNodes().isEmpty()) {
             return convertedNodes;
         }
-        for (ObjectCursor<DiscoveryNode> node : nodes.getNodes().values()) {
+        for (DiscoveryNode node : nodes.getNodes().values()) {
             List<ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole> nodeRoles = new ArrayList<>();
-            node.value.getRoles().forEach(role -> {
+            node.getRoles().forEach(role -> {
                 ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole.Builder nodeRoleBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole.newBuilder();
                 nodeRoleBuilder.setIsKnownRole(role.isKnownRole()).setIsDynamicRole(role.isDynamicRole()).setRoleName(role.roleName()).setRoleNameAbbreviation(role.roleNameAbbreviation()).setCanContainData(role.canContainData()).build();
                 nodeRoles.add(nodeRoleBuilder.build());
             });
             ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.Builder nodeBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.newBuilder();
-            nodeBuilder.setNodeName(node.value.getName()).setNodeId(node.value.getId()).setEphemeralId(node.value.getEphemeralId()).setHostName(node.value.getHostName())
-            .setHostAddress(node.value.getHostAddress()).setTransportAddress(node.value.getAddress().toString()).putAllAttributes(node.value.getAttributes()).addAllRoles(nodeRoles).setVersion(node.value.getVersion().toString()).build();
+            nodeBuilder.setNodeName(node.getName()).setNodeId(node.getId()).setEphemeralId(node.getEphemeralId()).setHostName(node.getHostName())
+            .setHostAddress(node.getHostAddress()).setTransportAddress(node.getAddress().toString()).putAllAttributes(node.getAttributes()).addAllRoles(nodeRoles).setVersion(node.getVersion().toString()).build();
             convertedNodes.add(nodeBuilder.build());
         }
         return convertedNodes;
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
index 7b50a427aaa50..19e182c504002 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
@@ -8,7 +8,6 @@
 
 package org.opensearch.action.admin.cluster.state;
 
-import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.opensearch.action.ActionListener;
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/stats/CommonStatsFlags.java b/server/src/main/java/org/opensearch/action/admin/indices/stats/CommonStatsFlags.java
index aeb3b4b5e1692..502b90417615f 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/stats/CommonStatsFlags.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/stats/CommonStatsFlags.java
@@ -37,7 +37,6 @@
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.core.common.Strings;
-import org.opensearch.common.Strings;
 
 import java.io.IOException;
 import java.util.Collections;
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java b/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
index 0078815cdaf62..9b0bd19d353eb 100644
--- a/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
@@ -10,7 +10,7 @@
 
 import org.opensearch.action.ProtobufActionRequest;
 import org.opensearch.action.ProtobufActionResponse;
-import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.tasks.ProtobufTask;
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
index 4c28131a9cc7e..672dc27ee1da7 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
@@ -32,8 +32,8 @@
 import org.opensearch.cluster.service.ClusterManagerTaskThrottler;
 import org.opensearch.cluster.service.ClusterManagerThrottlingException;
 import org.opensearch.cluster.service.ClusterService;
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.discovery.ClusterManagerNotDiscoveredException;
 import org.opensearch.node.NodeClosedException;
 import org.opensearch.tasks.ProtobufTask;
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeReadAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeReadAction.java
index fe863eaa05c5d..5d82ed341611b 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeReadAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeReadAction.java
@@ -12,7 +12,7 @@
 import org.opensearch.action.support.ProtobufActionFilters;
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
 import org.opensearch.cluster.service.ClusterService;
-import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportService;
 
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
index ffa64a81330d2..0d9665e765c8f 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
@@ -17,8 +17,8 @@
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.service.ClusterService;
-import org.opensearch.common.io.stream.ProtobufWriteable;
-import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.tasks.ProtobufTask;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.NodeShouldNotConnectException;
diff --git a/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java b/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java
index 78c4671c71305..e2e1136966f3c 100644
--- a/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java
+++ b/server/src/main/java/org/opensearch/client/node/ProtobufNodeClient.java
@@ -18,7 +18,7 @@
 import org.opensearch.client.ProtobufClient;
 import org.opensearch.client.support.ProtobufAbstractClient;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.tasks.ProtobufTask;
 import org.opensearch.tasks.ProtobufTaskListener;
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterName.java b/server/src/main/java/org/opensearch/cluster/ClusterName.java
index ba3620973bf7b..4edea6b2984ef 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterName.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterName.java
@@ -32,7 +32,7 @@
 
 package org.opensearch.cluster;
 
-import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufDiff.java b/server/src/main/java/org/opensearch/cluster/ProtobufDiff.java
index 9d281ff10be04..a187610856107 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufDiff.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufDiff.java
@@ -13,7 +13,7 @@
 
 package org.opensearch.cluster;
 
-import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
 
 /**
  * Represents difference between states of cluster state parts
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java b/server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java
index 4f1f2c83ef19f..140ec4bc74d3b 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java
@@ -13,7 +13,7 @@
 
 package org.opensearch.cluster;
 
-import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
 
 /**
  * Cluster state part, changes in which can be serialized
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufNamedWriteable.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufNamedWriteable.java
deleted file mode 100644
index 174f99d7e7f07..0000000000000
--- a/server/src/main/java/org/opensearch/common/io/stream/ProtobufNamedWriteable.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-* 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.
-*/
-
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
-package org.opensearch.common.io.stream;
-
-/**
- * A {@link Writeable} object identified by its name.
-* To be used for arbitrary serializable objects (e.g. queries); when reading them, their name tells
-* which specific object needs to be created.
-*
-* @opensearch.internal
-*/
-public interface ProtobufNamedWriteable extends ProtobufWriteable {
-
-    /**
-     * Returns the name of the writeable object
-    */
-    String getWriteableName();
-}
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufNamedWriteableRegistry.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufNamedWriteableRegistry.java
deleted file mode 100644
index 4d724d8d2683b..0000000000000
--- a/server/src/main/java/org/opensearch/common/io/stream/ProtobufNamedWriteableRegistry.java
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.common.io.stream;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-
-/**
- * A registry for {@link org.opensearch.common.io.stream.ProtobufWriteable.Reader} readers of {@link ProtobufNamedWriteable}.
-*
-* The registration is keyed by the combination of the category class of {@link ProtobufNamedWriteable}, and a name unique
-* to that category.
-*
-* @opensearch.internal
-*/
-public class ProtobufNamedWriteableRegistry {
-
-    /**
-     * An entry in the registry, made up of a category class and name, and a reader for that category class.
-    *
-    * @opensearch.internal
-    */
-    public static class Entry {
-
-        /** The superclass of a {@link ProtobufNamedWriteable} which will be read by {@link #reader}. */
-        public final Class<?> categoryClass;
-
-        /** A name for the writeable which is unique to the {@link #categoryClass}. */
-        public final String name;
-
-        /** A reader capability of reading*/
-        public final ProtobufWriteable.Reader<?> reader;
-
-        /** Creates a new entry which can be stored by the registry. */
-        public <T extends ProtobufNamedWriteable> Entry(Class<T> categoryClass, String name, ProtobufWriteable.Reader<? extends T> reader) {
-            this.categoryClass = Objects.requireNonNull(categoryClass);
-            this.name = Objects.requireNonNull(name);
-            this.reader = Objects.requireNonNull(reader);
-        }
-    }
-
-    /**
-     * The underlying data of the registry maps from the category to an inner
-    * map of name unique to that category, to the actual reader.
-    */
-    private final Map<Class<?>, Map<String, ProtobufWriteable.Reader<?>>> registry;
-
-    /**
-     * Constructs a new registry from the given entries.
-    */
-    public ProtobufNamedWriteableRegistry(List<Entry> entries) {
-        if (entries.isEmpty()) {
-            registry = Collections.emptyMap();
-            return;
-        }
-        entries = new ArrayList<>(entries);
-        entries.sort((e1, e2) -> e1.categoryClass.getName().compareTo(e2.categoryClass.getName()));
-
-        Map<Class<?>, Map<String, ProtobufWriteable.Reader<?>>> registry = new HashMap<>();
-        Map<String, ProtobufWriteable.Reader<?>> readers = null;
-        Class currentCategory = null;
-        for (Entry entry : entries) {
-            if (currentCategory != entry.categoryClass) {
-                if (currentCategory != null) {
-                    // we've seen the last of this category, put it into the big map
-                    registry.put(currentCategory, Collections.unmodifiableMap(readers));
-                }
-                readers = new HashMap<>();
-                currentCategory = entry.categoryClass;
-            }
-
-            ProtobufWriteable.Reader<?> oldReader = readers.put(entry.name, entry.reader);
-            if (oldReader != null) {
-                throw new IllegalArgumentException(
-                    "ProtobufNamedWriteable ["
-                        + currentCategory.getName()
-                        + "]["
-                        + entry.name
-                        + "]"
-                        + " is already registered for ["
-                        + oldReader.getClass().getName()
-                        + "],"
-                        + " cannot register ["
-                        + entry.reader.getClass().getName()
-                        + "]"
-                );
-            }
-        }
-        // handle the last category
-        registry.put(currentCategory, Collections.unmodifiableMap(readers));
-
-        this.registry = Collections.unmodifiableMap(registry);
-    }
-
-    /**
-     * Returns a reader for a {@link ProtobufNamedWriteable} object identified by the
-    * name provided as argument and its category.
-    */
-    public <T> ProtobufWriteable.Reader<? extends T> getReader(Class<T> categoryClass, String name) {
-        Map<String, ProtobufWriteable.Reader<?>> readers = registry.get(categoryClass);
-        if (readers == null) {
-            throw new IllegalArgumentException("Unknown ProtobufNamedWriteable category [" + categoryClass.getName() + "]");
-        }
-        @SuppressWarnings("unchecked")
-        ProtobufWriteable.Reader<? extends T> reader = (ProtobufWriteable.Reader<? extends T>) readers.get(name);
-        if (reader == null) {
-            throw new IllegalArgumentException("Unknown ProtobufNamedWriteable [" + categoryClass.getName() + "][" + name + "]");
-        }
-        return reader;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/common/io/stream/ProtobufVersionedNamedWriteable.java b/server/src/main/java/org/opensearch/common/io/stream/ProtobufVersionedNamedWriteable.java
deleted file mode 100644
index 5e888abc9b0aa..0000000000000
--- a/server/src/main/java/org/opensearch/common/io/stream/ProtobufVersionedNamedWriteable.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
-* 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.
-*/
-
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
-package org.opensearch.common.io.stream;
-
-import org.opensearch.Version;
-
-/**
- * A {@link NamedWriteable} that has a minimum version associated with it.
-*
-* @opensearch.internal
-*/
-public interface ProtobufVersionedNamedWriteable extends ProtobufNamedWriteable {
-
-    /**
-     * Returns the name of the writeable object
-    */
-    String getWriteableName();
-
-    /**
-     * The minimal version of the recipient this object can be sent to
-    */
-    Version getMinimalSupportedVersion();
-}
diff --git a/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java b/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
index b52109e93b22b..1e1d70f1468dd 100644
--- a/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
+++ b/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
@@ -185,17 +185,6 @@ public Writeable captureAsWriteable() {
         };
     }
 
-    /**
-     * Captures the current thread context as writeable, allowing it to be serialized out later
-     */
-    public ProtobufWriteable captureAsWriteable() {
-        final ThreadContextStruct context = threadLocal.get();
-        return out -> {
-            final Map<String, String> propagatedHeaders = propagateHeaders(context.transientHeaders);
-            context.writeTo(out, defaultHeader, propagatedHeaders);
-        };
-    }
-
     /**
      * Removes the current context and resets a default context marked with as
      * originating from the supplied string. The removed context can be
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java
index dbc99b263bb56..8c97d3999e94a 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java
@@ -33,7 +33,7 @@
 package org.opensearch.index.seqno;
 
 import org.opensearch.core.ParseField;
-import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java
index 28963f10db64b..9f38321245d5b 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java
@@ -32,7 +32,7 @@
 
 package org.opensearch.index.seqno;
 
-import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
diff --git a/server/src/main/java/org/opensearch/node/ProtobufNodeService.java b/server/src/main/java/org/opensearch/node/ProtobufNodeService.java
index 8623612e5236a..c7cc351fce7cd 100644
--- a/server/src/main/java/org/opensearch/node/ProtobufNodeService.java
+++ b/server/src/main/java/org/opensearch/node/ProtobufNodeService.java
@@ -24,7 +24,7 @@
 import org.opensearch.index.IndexingPressureService;
 import org.opensearch.index.store.remote.filecache.FileCache;
 import org.opensearch.indices.IndicesService;
-import org.opensearch.indices.breaker.CircuitBreakerService;
+import org.opensearch.core.indices.breaker.CircuitBreakerService;
 import org.opensearch.ingest.IngestService;
 import org.opensearch.monitor.MonitorService;
 import org.opensearch.plugins.PluginsService;
diff --git a/server/src/main/java/org/opensearch/node/ProtobufReportingService.java b/server/src/main/java/org/opensearch/node/ProtobufReportingService.java
index fbb90a7617148..dc2648adaae27 100644
--- a/server/src/main/java/org/opensearch/node/ProtobufReportingService.java
+++ b/server/src/main/java/org/opensearch/node/ProtobufReportingService.java
@@ -8,7 +8,7 @@
 
 package org.opensearch.node;
 
-import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.xcontent.ToXContent;
 
 /**
diff --git a/server/src/main/java/org/opensearch/node/ResponseCollectorService.java b/server/src/main/java/org/opensearch/node/ResponseCollectorService.java
index feae8597c1e81..a1fb3086d5609 100644
--- a/server/src/main/java/org/opensearch/node/ResponseCollectorService.java
+++ b/server/src/main/java/org/opensearch/node/ResponseCollectorService.java
@@ -13,7 +13,7 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.ExponentiallyWeightedMovingAverage;
-import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
diff --git a/server/src/main/java/org/opensearch/plugins/ProtobufActionPlugin.java b/server/src/main/java/org/opensearch/plugins/ProtobufActionPlugin.java
index caed963482a31..f9794aa050eff 100644
--- a/server/src/main/java/org/opensearch/plugins/ProtobufActionPlugin.java
+++ b/server/src/main/java/org/opensearch/plugins/ProtobufActionPlugin.java
@@ -19,7 +19,7 @@
 import org.opensearch.action.support.TransportActions;
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
 import org.opensearch.cluster.node.DiscoveryNodes;
-import org.opensearch.common.Strings;
+import org.opensearch.core.common.Strings;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.IndexScopedSettings;
 import org.opensearch.common.settings.Settings;
diff --git a/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java b/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java
index 6bc78abee594b..3c2d2a7aae256 100644
--- a/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java
+++ b/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java
@@ -20,6 +20,7 @@
 import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Setting.Property;
+import org.opensearch.core.rest.RestStatus;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.plugins.ActionPlugin;
 import org.opensearch.rest.action.admin.cluster.RestNodesUsageAction;
diff --git a/server/src/main/java/org/opensearch/rest/ProtobufDeprecationRestHandler.java b/server/src/main/java/org/opensearch/rest/ProtobufDeprecationRestHandler.java
index 0b0c147d7f29d..01b4b9240a136 100644
--- a/server/src/main/java/org/opensearch/rest/ProtobufDeprecationRestHandler.java
+++ b/server/src/main/java/org/opensearch/rest/ProtobufDeprecationRestHandler.java
@@ -9,7 +9,7 @@
 package org.opensearch.rest;
 
 import org.opensearch.client.node.ProtobufNodeClient;
-import org.opensearch.common.Strings;
+import org.opensearch.core.common.Strings;
 import org.opensearch.common.logging.DeprecationLogger;
 
 import java.util.Objects;
diff --git a/server/src/main/java/org/opensearch/rest/RestController.java b/server/src/main/java/org/opensearch/rest/RestController.java
index 57fd542fb24b3..afac4b6a22457 100644
--- a/server/src/main/java/org/opensearch/rest/RestController.java
+++ b/server/src/main/java/org/opensearch/rest/RestController.java
@@ -157,7 +157,8 @@ public RestController(
         UnaryOperator<ProtobufRestHandler> handlerProtobufWrapper,
         ProtobufNodeClient protobufNodeClient,
         CircuitBreakerService circuitBreakerService,
-        UsageService usageService
+        UsageService usageService,
+        IdentityService identityService
     ) {
         this.headersToCopy = headersToCopy;
         this.usageService = usageService;
@@ -172,6 +173,7 @@ public RestController(
         this.client = client;
         this.handlerWrapper = handlerWrapper;
         this.circuitBreakerService = circuitBreakerService;
+        this.identityService = identityService;
         registerProtobufHandlerNoWrap(
             RestRequest.Method.GET,
             "/favicon.ico",
@@ -441,52 +443,6 @@ private void dispatchProtobufRequest(RestRequest request, RestChannel channel, P
         }
     }
 
-    private void dispatchProtobufRequest(RestRequest request, RestChannel channel, ProtobufRestHandler handler) throws Exception {
-        System.out.println("Dispatching protobuf request");
-        final int contentLength = request.content().length();
-        if (contentLength > 0) {
-            final XContentType xContentType = request.getXContentType();
-            if (xContentType == null) {
-                sendContentTypeErrorMessage(request.getAllHeaderValues("Content-Type"), channel);
-                return;
-            }
-            if (handler.supportsContentStream() && xContentType != XContentType.JSON && xContentType != XContentType.SMILE) {
-                channel.sendResponse(
-                    BytesRestResponse.createSimpleErrorResponse(
-                        channel,
-                        RestStatus.NOT_ACCEPTABLE,
-                        "Content-Type [" + xContentType + "] does not support stream parsing. Use JSON or SMILE instead"
-                    )
-                );
-                return;
-            }
-        }
-        RestChannel responseChannel = channel;
-        try {
-            if (handler.canTripCircuitBreaker()) {
-                inFlightRequestsBreaker(circuitBreakerService).addEstimateBytesAndMaybeBreak(contentLength, "<http_request>");
-            } else {
-                inFlightRequestsBreaker(circuitBreakerService).addWithoutBreaking(contentLength);
-            }
-            // iff we could reserve bytes for the request we need to send the response also over this channel
-            responseChannel = new ResourceHandlingHttpChannel(channel, circuitBreakerService, contentLength);
-            // TODO: Count requests double in the circuit breaker if they need copying?
-            if (handler.allowsUnsafeBuffers() == false) {
-                request.ensureSafeBuffers();
-            }
-            if (handler.allowSystemIndexAccessByDefault() == false && request.header(OPENSEARCH_PRODUCT_ORIGIN_HTTP_HEADER) == null) {
-                // The OPENSEARCH_PRODUCT_ORIGIN_HTTP_HEADER indicates that the request is coming from an OpenSearch product with a plan
-                // to move away from direct access to system indices, and thus deprecation warnings should not be emitted.
-                // This header is intended for internal use only.
-                protobufClient.threadPool().getThreadContext().putHeader(SYSTEM_INDEX_ACCESS_CONTROL_HEADER_KEY, Boolean.FALSE.toString());
-            }
-
-            handler.handleRequest(request, responseChannel, protobufClient);
-        } catch (Exception e) {
-            responseChannel.sendResponse(new BytesRestResponse(responseChannel, e));
-        }
-    }
-
     private boolean handleNoHandlerFound(String rawPath, RestRequest.Method method, String uri, RestChannel channel) {
         // Get the map of matching handlers for a request, for the full set of HTTP methods.
         final Set<RestRequest.Method> validMethodSet = getValidHandlerMethodSet(rawPath);
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufAbstractCatAction.java b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufAbstractCatAction.java
index 55653f5e738c9..07c1b63981922 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufAbstractCatAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufAbstractCatAction.java
@@ -12,11 +12,11 @@
 import org.opensearch.common.Table;
 import org.opensearch.common.io.Streams;
 import org.opensearch.common.io.UTF8StreamWriter;
-import org.opensearch.common.io.stream.BytesStream;
+import org.opensearch.core.common.io.stream.BytesStream;
 import org.opensearch.rest.ProtobufBaseRestHandler;
 import org.opensearch.rest.BytesRestResponse;
 import org.opensearch.rest.RestRequest;
-import org.opensearch.rest.RestStatus;
+import org.opensearch.core.rest.RestStatus;
 
 import java.io.IOException;
 import java.util.Arrays;
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestCatAction.java b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestCatAction.java
index ec432fe6e64e1..8d901db9904b2 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestCatAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestCatAction.java
@@ -12,7 +12,7 @@
 import org.opensearch.rest.ProtobufBaseRestHandler;
 import org.opensearch.rest.BytesRestResponse;
 import org.opensearch.rest.RestRequest;
-import org.opensearch.rest.RestStatus;
+import org.opensearch.core.rest.RestStatus;
 
 import java.io.IOException;
 import java.util.List;
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
index be0286ed73074..84216b688fa88 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
@@ -18,7 +18,7 @@
 import org.opensearch.common.Strings;
 import org.opensearch.common.Table;
 import org.opensearch.common.logging.DeprecationLogger;
-import org.opensearch.common.unit.ByteSizeValue;
+import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.rest.RestRequest;
 import org.opensearch.rest.RestResponse;
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTask.java b/server/src/main/java/org/opensearch/tasks/ProtobufTask.java
index 779089a610d68..5b62b0d37a751 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTask.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTask.java
@@ -17,7 +17,7 @@
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.action.NotifyOnceListener;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.common.io.stream.NamedWriteable;
+import org.opensearch.core.common.io.stream.NamedWriteable;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.ToXContentObject;
 import org.opensearch.tasks.proto.TaskResourceStatsProto;
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
index d908eca24cbe7..2c59d42658382 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
@@ -12,7 +12,7 @@
 package org.opensearch.tasks;
 
 import org.opensearch.common.Strings;
-import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.tasks.proto.TaskIdProto;
 
 import java.io.IOException;
@@ -41,7 +41,7 @@ private ProtobufTaskId() {
     }
 
     public ProtobufTaskId(String taskId) {
-        if (Strings.hasLength(taskId) && "unset".equals(taskId) == false) {
+        if (org.opensearch.core.common.Strings.hasLength(taskId) && "unset".equals(taskId) == false) {
             String[] s = Strings.split(taskId, ":");
             if (s == null || s.length != 2) {
                 throw new IllegalArgumentException("malformed task id " + taskId);
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
index 1c07fb9292a16..17662779ccba3 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
@@ -11,8 +11,8 @@
 
 package org.opensearch.tasks;
 
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java
index 051f96f6203c1..12530e69df7d8 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java
@@ -11,7 +11,7 @@
 
 package org.opensearch.tasks;
 
-import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.tasks.proto.TaskResourceStatsProto;
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
index 7e7d1cb184ba1..6a5844bd2fe0e 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
@@ -14,8 +14,9 @@
 import org.opensearch.OpenSearchException;
 import org.opensearch.client.Requests;
 import org.opensearch.common.Nullable;
-import org.opensearch.common.bytes.BytesReference;
-import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.xcontent.MediaTypeRegistry;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.ToXContentObject;
 import org.opensearch.core.xcontent.XContentBuilder;
@@ -144,7 +145,7 @@ public XContentBuilder innerToXContent(XContentBuilder builder, Params params) t
     }
 
     private static BytesReference toXContent(Exception error) throws IOException {
-        try (XContentBuilder builder = XContentFactory.contentBuilder(Requests.INDEX_CONTENT_TYPE)) {
+        try (XContentBuilder builder = MediaTypeRegistry.contentBuilder(Requests.INDEX_CONTENT_TYPE)) {
             builder.startObject();
             OpenSearchException.generateThrowableXContent(builder, ToXContent.EMPTY_PARAMS, error);
             builder.endObject();
diff --git a/server/src/main/java/org/opensearch/tasks/TaskManager.java b/server/src/main/java/org/opensearch/tasks/TaskManager.java
index 5f360f0cfe037..5b8d88377db1d 100644
--- a/server/src/main/java/org/opensearch/tasks/TaskManager.java
+++ b/server/src/main/java/org/opensearch/tasks/TaskManager.java
@@ -63,9 +63,6 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TcpChannel;
 
-import com.carrotsearch.hppc.ObjectIntHashMap;
-import com.carrotsearch.hppc.ObjectIntMap;
-
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -397,34 +394,6 @@ public void cancel(CancellableTask task, String reason, Runnable listener) {
         }
     }
 
-    /**
-     * Cancels a task
-    * <p>
-    * After starting cancellation on the parent task, the task manager tries to cancel all children tasks
-    * of the current task. Once cancellation of the children tasks is done, the listener is triggered.
-    * If the task is completed or unregistered from ProtobufTaskManager, then the listener is called immediately.
-    */
-    public void cancelProtobufTask(ProtobufCancellableTask task, String reason, Runnable listener) {
-        CancellableTaskHolder holder = cancellableTasks.get(task.getId());
-        List<Exception> exceptions = new ArrayList<>();
-        for (TaskEventListeners taskEventListener : taskEventListeners) {
-            try {
-                taskEventListener.onTaskCancelled(task);
-            } catch (Exception e) {
-                exceptions.add(e);
-            }
-        }
-        // Throwing exception in case any of the cancellation listener results into exception.
-        // Should we just swallow such exceptions?
-        ExceptionsHelper.maybeThrowRuntimeAndSuppress(exceptions);
-        if (holder != null) {
-            logger.trace("cancelling task with id {}", task.getId());
-            holder.cancel(reason, listener);
-        } else {
-            listener.run();
-        }
-    }
-
     /**
      * Cancels a task
     * <p>
@@ -1152,140 +1121,7 @@ private static class ProtobufCancellableTaskHolder {
         private final ProtobufCancellableTask task;
         private boolean finished = false;
         private List<Runnable> cancellationListeners = null;
-        private ObjectIntMap<ProtobufDiscoveryNode> childTasksPerNode = null;
-        private boolean banChildren = false;
-        private List<Runnable> childTaskCompletedListeners = null;
-
-        ProtobufCancellableTaskHolder(ProtobufCancellableTask task) {
-            this.task = task;
-        }
-
-        void cancel(String reason, Runnable listener) {
-            final Runnable toRun;
-            synchronized (this) {
-                if (finished) {
-                    assert cancellationListeners == null;
-                    toRun = listener;
-                } else {
-                    toRun = () -> {};
-                    if (listener != null) {
-                        if (cancellationListeners == null) {
-                            cancellationListeners = new ArrayList<>();
-                        }
-                        cancellationListeners.add(listener);
-                    }
-                }
-            }
-            try {
-                task.cancel(reason);
-            } finally {
-                if (toRun != null) {
-                    toRun.run();
-                }
-            }
-        }
-
-        void cancel(String reason) {
-            task.cancel(reason);
-        }
-
-        /**
-         * Marks task as finished.
-        */
-        public void finish() {
-            final List<Runnable> listeners;
-            synchronized (this) {
-                this.finished = true;
-                if (cancellationListeners != null) {
-                    listeners = cancellationListeners;
-                    cancellationListeners = null;
-                } else {
-                    listeners = Collections.emptyList();
-                }
-            }
-            // We need to call the listener outside of the synchronised section to avoid potential bottle necks
-            // in the listener synchronization
-            notifyListeners(listeners);
-        }
-
-        private void notifyListeners(List<Runnable> listeners) {
-            assert Thread.holdsLock(this) == false;
-            Exception rootException = null;
-            for (Runnable listener : listeners) {
-                try {
-                    listener.run();
-                } catch (RuntimeException inner) {
-                    rootException = ExceptionsHelper.useOrSuppress(rootException, inner);
-                }
-            }
-            ExceptionsHelper.reThrowIfNotNull(rootException);
-        }
-
-        public boolean hasParent(ProtobufTaskId parentTaskId) {
-            return task.getParentTaskId().equals(parentTaskId);
-        }
-
-        public ProtobufCancellableTask getTask() {
-            return task;
-        }
-
-        synchronized void registerChildNode(ProtobufDiscoveryNode node) {
-            if (banChildren) {
-                throw new TaskCancelledException("The parent task was cancelled, shouldn't start any child tasks");
-            }
-            if (childTasksPerNode == null) {
-                childTasksPerNode = new ObjectIntHashMap<>();
-            }
-            childTasksPerNode.addTo(node, 1);
-        }
-
-        void unregisterChildNode(ProtobufDiscoveryNode node) {
-            final List<Runnable> listeners;
-            synchronized (this) {
-                if (childTasksPerNode.addTo(node, -1) == 0) {
-                    childTasksPerNode.remove(node);
-                }
-                if (childTasksPerNode.isEmpty() && this.childTaskCompletedListeners != null) {
-                    listeners = childTaskCompletedListeners;
-                    childTaskCompletedListeners = null;
-                } else {
-                    listeners = Collections.emptyList();
-                }
-            }
-            notifyListeners(listeners);
-        }
-
-        Set<ProtobufDiscoveryNode> startBan(Runnable onChildTasksCompleted) {
-            final Set<ProtobufDiscoveryNode> pendingChildNodes;
-            final Runnable toRun;
-            synchronized (this) {
-                banChildren = true;
-                if (childTasksPerNode == null) {
-                    pendingChildNodes = Collections.emptySet();
-                } else {
-                    pendingChildNodes = Set.copyOf(childTasksPerNode.keySet());
-                }
-                if (pendingChildNodes.isEmpty()) {
-                    assert childTaskCompletedListeners == null;
-                    toRun = onChildTasksCompleted;
-                } else {
-                    toRun = () -> {};
-                    if (childTaskCompletedListeners == null) {
-                        childTaskCompletedListeners = new ArrayList<>();
-                    }
-                    childTaskCompletedListeners.add(onChildTasksCompleted);
-                }
-            }
-            toRun.run();
-            return pendingChildNodes;
-        }
-    }
-
-    private static class ProtobufCancellableTaskHolder {
-        private final ProtobufCancellableTask task;
-        private boolean finished = false;
-        private List<Runnable> cancellationListeners = null;
-        private ObjectIntMap<DiscoveryNode> childTasksPerNode = null;
+        private Map<DiscoveryNode, Integer> childTasksPerNode = null;
         private boolean banChildren = false;
         private List<Runnable> childTaskCompletedListeners = null;
 
@@ -1367,15 +1203,15 @@ synchronized void registerChildNode(DiscoveryNode node) {
                 throw new TaskCancelledException("The parent task was cancelled, shouldn't start any child tasks");
             }
             if (childTasksPerNode == null) {
-                childTasksPerNode = new ObjectIntHashMap<>();
+                childTasksPerNode = new HashMap<>();
             }
-            childTasksPerNode.addTo(node, 1);
+            childTasksPerNode.merge(node, 1, Integer::sum);
         }
 
         void unregisterChildNode(DiscoveryNode node) {
             final List<Runnable> listeners;
             synchronized (this) {
-                if (childTasksPerNode.addTo(node, -1) == 0) {
+                if (childTasksPerNode.merge(node, -1, Integer::sum) == 0) {
                     childTasksPerNode.remove(node);
                 }
                 if (childTasksPerNode.isEmpty() && this.childTaskCompletedListeners != null) {
diff --git a/server/src/main/java/org/opensearch/tasks/TaskResultsService.java b/server/src/main/java/org/opensearch/tasks/TaskResultsService.java
index 26cebbea22a6e..995274ada4b4f 100644
--- a/server/src/main/java/org/opensearch/tasks/TaskResultsService.java
+++ b/server/src/main/java/org/opensearch/tasks/TaskResultsService.java
@@ -227,7 +227,7 @@ private void doStoreResult(TaskResult taskResult, ActionListener<Void> listener)
 
     private void doStoreResult(ProtobufTaskResult taskResult, ActionListener<Void> listener) {
         IndexRequestBuilder index = client.prepareIndex(TASK_INDEX).setId(taskResult.getTask().getTaskId().toString());
-        try (XContentBuilder builder = XContentFactory.contentBuilder(Requests.INDEX_CONTENT_TYPE)) {
+        try (XContentBuilder builder = MediaTypeRegistry.contentBuilder(Requests.INDEX_CONTENT_TYPE)) {
             taskResult.toXContent(builder, ToXContent.EMPTY_PARAMS);
             index.setSource(builder);
         } catch (IOException e) {
diff --git a/server/src/main/java/org/opensearch/transport/InboundHandler.java b/server/src/main/java/org/opensearch/transport/InboundHandler.java
index 0c5ff1af8649e..b63938f652c2b 100644
--- a/server/src/main/java/org/opensearch/transport/InboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/InboundHandler.java
@@ -45,7 +45,7 @@
 import org.opensearch.action.admin.cluster.node.stats.ProtobufTransportNodesStatsAction.NodeStatsRequest;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
-import org.opensearch.common.bytes.BytesReference;
+import org.opensearch.core.common.bytes.BytesReference;
 import org.opensearch.common.bytes.ReleasableBytesReference;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.core.common.io.stream.ByteBufferStreamInput;
diff --git a/server/src/main/java/org/opensearch/transport/InboundPipeline.java b/server/src/main/java/org/opensearch/transport/InboundPipeline.java
index 44899c27d75de..ed5c35ca40120 100644
--- a/server/src/main/java/org/opensearch/transport/InboundPipeline.java
+++ b/server/src/main/java/org/opensearch/transport/InboundPipeline.java
@@ -34,7 +34,7 @@
 
 import org.opensearch.Version;
 import org.opensearch.core.common.breaker.CircuitBreaker;
-import org.opensearch.common.bytes.BytesReference;
+import org.opensearch.core.common.bytes.BytesReference;
 import org.opensearch.core.common.bytes.CompositeBytesReference;
 import org.opensearch.common.bytes.ReleasableBytesReference;
 import org.opensearch.common.util.PageCacheRecycler;
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java
index 3308de616fc1e..586c94a725566 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java
@@ -10,7 +10,7 @@
 
 import java.io.IOException;
 
-import org.opensearch.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportResponse.Empty;
 
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
index df6a34c37226c..2691f6b426b87 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufRequestHandlerRegistry.java
@@ -8,10 +8,10 @@
 
 package org.opensearch.transport;
 
-import org.opensearch.common.io.stream.ProtobufWriteable;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.lease.Releasables;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.tasks.ProtobufCancellableTask;
 import org.opensearch.tasks.ProtobufTask;
 import org.opensearch.tasks.TaskManager;
diff --git a/server/src/main/java/org/opensearch/transport/TransportMessage.java b/server/src/main/java/org/opensearch/transport/TransportMessage.java
index 7e080c4b8dcf3..66502662d1860 100644
--- a/server/src/main/java/org/opensearch/transport/TransportMessage.java
+++ b/server/src/main/java/org/opensearch/transport/TransportMessage.java
@@ -32,7 +32,7 @@
 
 package org.opensearch.transport;
 
-import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.common.transport.TransportAddress;
diff --git a/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java
index dd52b15e1eee5..d4fad0e299d35 100644
--- a/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java
+++ b/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java
@@ -32,7 +32,7 @@
 
 package org.opensearch.transport;
 
-import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.Writeable;
 
diff --git a/server/src/main/java/org/opensearch/transport/TransportService.java b/server/src/main/java/org/opensearch/transport/TransportService.java
index 8255786bb15e6..1da343aeeaec8 100644
--- a/server/src/main/java/org/opensearch/transport/TransportService.java
+++ b/server/src/main/java/org/opensearch/transport/TransportService.java
@@ -45,7 +45,7 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
-import org.opensearch.common.io.stream.ProtobufWriteable;
+import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.common.io.stream.Streamables;

From eeeb40f055303cd02df51455e678234e31e17e52 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Wed, 2 Aug 2023 22:29:30 +0000
Subject: [PATCH 28/37] Renaming proto messages and related classes

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../node/info/ProtobufNodesInfoRequest.java   | 12 +--
 .../node/info/ProtobufNodesInfoResponse.java  |  8 +-
 .../node/stats/ProtobufNodesStatsRequest.java | 12 +--
 .../stats/ProtobufNodesStatsResponse.java     |  8 +-
 .../state/ProtobufClusterStateRequest.java    | 32 +++----
 .../state/ProtobufClusterStateResponse.java   | 28 +++----
 .../example/proto/ExampleProtoRequest.java    | 69 ---------------
 .../org/opensearch/rest/BaseRestHandler.java  |  2 -
 .../rest/ProtobufBaseRestHandler.java         |  2 -
 .../org/opensearch/rest/RestController.java   |  6 --
 .../action/cat/ProtobufRestNodesAction.java   | 12 +--
 .../opensearch/transport/InboundHandler.java  | 60 ++++++-------
 .../opensearch/transport/OutboundHandler.java | 27 ------
 .../transport/ProtobufOutboundMessage.java    | 52 ++++++------
 .../transport/TransportRequest.java           | 10 ---
 .../proto/examples/ExampleRequestProto.proto  | 20 -----
 .../server/ClusterStateRequestProto.proto     |  2 +-
 .../server/ClusterStateResponseProto.proto    |  2 +-
 ...dMessageProto.proto => MessageProto.proto} | 18 ++--
 .../proto/server/NodesInfoRequestProto.proto  |  2 +-
 .../proto/server/NodesInfoResponseProto.proto |  2 +-
 .../proto/server/NodesStatsRequestProto.proto |  2 +-
 .../server/NodesStatsResponseProto.proto      |  2 +-
 .../proto/server/TransportRequestProto.proto  | 21 -----
 .../transport/OutboundHandlerTests.java       | 84 -------------------
 25 files changed, 122 insertions(+), 373 deletions(-)
 delete mode 100644 server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java
 delete mode 100644 server/src/main/proto/examples/ExampleRequestProto.proto
 rename server/src/main/proto/server/{OutboundMessageProto.proto => MessageProto.proto} (74%)
 delete mode 100644 server/src/main/proto/server/TransportRequestProto.proto

diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
index d4222f6def154..004847bc8cb25 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
@@ -15,7 +15,7 @@
 
 import org.opensearch.action.support.nodes.ProtobufBaseNodesRequest;
 import org.opensearch.common.unit.TimeValue;
-import org.opensearch.server.proto.NodesInfoRequestProto.NodesInfoReq;
+import org.opensearch.server.proto.NodesInfoRequestProto.NodesInfoRequest;
 import org.opensearch.server.proto.NodesInfoRequestProto;
 
 import java.io.IOException;
@@ -34,7 +34,7 @@
  */
 public class ProtobufNodesInfoRequest extends ProtobufBaseNodesRequest<ProtobufNodesInfoRequest> {
 
-    private NodesInfoRequestProto.NodesInfoReq nodesInfoRequest;
+    private NodesInfoRequestProto.NodesInfoRequest nodesInfoRequest;
     private final TimeValue DEFAULT_TIMEOUT_SECS = TimeValue.timeValueSeconds(30);
 
     /**
@@ -62,16 +62,16 @@ public ProtobufNodesInfoRequest addMetrics(String timeout, String... metrics) {
             String plural = metricsSet.size() == 1 ? "" : "s";
             throw new IllegalStateException("Used illegal metric" + plural + ": " + metricsSet);
         }
-        this.nodesInfoRequest = NodesInfoRequestProto.NodesInfoReq.newBuilder().addAllRequestedMetrics(metricsSet).setTimeout(DEFAULT_TIMEOUT_SECS.toString()).build();
+        this.nodesInfoRequest = NodesInfoRequestProto.NodesInfoRequest.newBuilder().addAllRequestedMetrics(metricsSet).setTimeout(DEFAULT_TIMEOUT_SECS.toString()).build();
         return this;
     }
 
     public ProtobufNodesInfoRequest(byte[] data) throws IOException {
         super(data);
-        this.nodesInfoRequest = NodesInfoRequestProto.NodesInfoReq.parseFrom(data);
+        this.nodesInfoRequest = NodesInfoRequestProto.NodesInfoRequest.parseFrom(data);
     }
 
-    public ProtobufNodesInfoRequest(NodesInfoRequestProto.NodesInfoReq nodesInfoRequest) throws IOException {
+    public ProtobufNodesInfoRequest(NodesInfoRequestProto.NodesInfoRequest nodesInfoRequest) throws IOException {
         super(nodesInfoRequest.toByteArray());
         this.nodesInfoRequest = nodesInfoRequest;
     }
@@ -119,7 +119,7 @@ public void writeTo(OutputStream out) throws IOException {
         this.nodesInfoRequest.writeTo(out);
     }
 
-    public NodesInfoReq request() {
+    public NodesInfoRequest request() {
         return this.nodesInfoRequest;
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
index 400ed014fb679..99b2869c61e4a 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
@@ -58,7 +58,7 @@
 */
 public class ProtobufNodesInfoResponse extends ProtobufBaseNodesResponse<ProtobufNodeInfo> implements ToXContentFragment {
 
-    private NodesInfoResponseProto.NodesInfoRes nodesInfoRes;
+    private NodesInfoResponseProto.NodesInfoResponse nodesInfoRes;
     private Map<String, NodesInfo> nodesMap = new HashMap<>();
 
     public ProtobufNodesInfoResponse(ClusterName clusterName, List<ProtobufNodeInfo> nodes, List<FailedNodeException> failures) {
@@ -68,7 +68,7 @@ public ProtobufNodesInfoResponse(ClusterName clusterName, List<ProtobufNodeInfo>
             nodesInfo.add(nodeInfo.response());
             this.nodesMap.put(nodeInfo.response().getNodeId(), nodeInfo.response());
         }
-        this.nodesInfoRes = NodesInfoResponseProto.NodesInfoRes.newBuilder()
+        this.nodesInfoRes = NodesInfoResponseProto.NodesInfoResponse.newBuilder()
             .setClusterName(clusterName.value())
             .addAllNodesInfo(nodesInfo)
             .build();
@@ -132,7 +132,7 @@ public String toString() {
         }
     }
 
-    public NodesInfoResponseProto.NodesInfoRes response() {
+    public NodesInfoResponseProto.NodesInfoResponse response() {
         return nodesInfoRes;
     }
 
@@ -142,7 +142,7 @@ public Map<String, NodesInfo> nodesMap() {
 
     public ProtobufNodesInfoResponse(byte[] data) throws IOException {
         super(data);
-        this.nodesInfoRes = NodesInfoResponseProto.NodesInfoRes.parseFrom(data);
+        this.nodesInfoRes = NodesInfoResponseProto.NodesInfoResponse.parseFrom(data);
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
index 54c7063220ac8..6591b872f6822 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
@@ -10,7 +10,7 @@
 
 import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
 import org.opensearch.action.support.nodes.ProtobufBaseNodesRequest;
-import org.opensearch.server.proto.NodesStatsRequestProto.NodesStatsReq;
+import org.opensearch.server.proto.NodesStatsRequestProto.NodesStatsRequest;
 import org.opensearch.server.proto.NodesInfoRequestProto;
 import org.opensearch.server.proto.NodesStatsRequestProto;
 
@@ -32,7 +32,7 @@ public class ProtobufNodesStatsRequest extends ProtobufBaseNodesRequest<Protobuf
 
     private CommonStatsFlags indices = new CommonStatsFlags();
     private final Set<String> requestedMetrics = new HashSet<>();
-    private NodesStatsRequestProto.NodesStatsReq nodesStatsRequest;
+    private NodesStatsRequestProto.NodesStatsRequest nodesStatsRequest;
 
     public ProtobufNodesStatsRequest() {
         super((String[]) null);
@@ -126,7 +126,7 @@ public ProtobufNodesStatsRequest addMetrics(String... metrics) {
             String plural = metricsSet.size() == 1 ? "" : "s";
             throw new IllegalStateException("Used illegal metric" + plural + ": " + metricsSet);
         }
-        this.nodesStatsRequest = NodesStatsRequestProto.NodesStatsReq.newBuilder().addAllRequestedMetrics(metricsSet).build();
+        this.nodesStatsRequest = NodesStatsRequestProto.NodesStatsRequest.newBuilder().addAllRequestedMetrics(metricsSet).build();
         requestedMetrics.addAll(metricsSet);
         return this;
     }
@@ -144,10 +144,10 @@ public ProtobufNodesStatsRequest removeMetric(String metric) {
 
     public ProtobufNodesStatsRequest(byte[] data) throws IOException {
         super(data);
-        this.nodesStatsRequest = NodesStatsRequestProto.NodesStatsReq.parseFrom(data);
+        this.nodesStatsRequest = NodesStatsRequestProto.NodesStatsRequest.parseFrom(data);
     }
 
-     public ProtobufNodesStatsRequest(NodesStatsRequestProto.NodesStatsReq nodesStatsRequest) throws IOException {
+     public ProtobufNodesStatsRequest(NodesStatsRequestProto.NodesStatsRequest nodesStatsRequest) throws IOException {
         super(nodesStatsRequest.toByteArray());
         this.nodesStatsRequest = nodesStatsRequest;
     }
@@ -201,7 +201,7 @@ public void writeTo(OutputStream out) throws IOException {
         this.nodesStatsRequest.writeTo(out);
     }
 
-    public NodesStatsReq request() {
+    public NodesStatsRequest request() {
         return this.nodesStatsRequest;
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
index 23808c8a04e13..c70c32af009a5 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsResponse.java
@@ -32,12 +32,12 @@
 */
 public class ProtobufNodesStatsResponse extends ProtobufBaseNodesResponse<ProtobufNodeStats> implements ToXContentFragment {
 
-    private NodesStatsResponseProto.NodesStatsRes nodesStatsRes;
+    private NodesStatsResponseProto.NodesStatsResponse nodesStatsRes;
     private Map<String, NodesStats> nodesMap = new HashMap<>();
 
     public ProtobufNodesStatsResponse(byte[] data) throws IOException {
         super(data);
-        this.nodesStatsRes = NodesStatsResponseProto.NodesStatsRes.parseFrom(data);
+        this.nodesStatsRes = NodesStatsResponseProto.NodesStatsResponse.parseFrom(data);
     }
 
     public ProtobufNodesStatsResponse(ClusterName clusterName, List<ProtobufNodeStats> nodes, List<FailedNodeException> failures) {
@@ -47,7 +47,7 @@ public ProtobufNodesStatsResponse(ClusterName clusterName, List<ProtobufNodeStat
             nodesStats.add(nodeStats.response());
             this.nodesMap.put(nodeStats.response().getNodeId(), nodeStats.response());
         }
-        this.nodesStatsRes = NodesStatsResponseProto.NodesStatsRes.newBuilder()
+        this.nodesStatsRes = NodesStatsResponseProto.NodesStatsResponse.newBuilder()
             .setClusterName(clusterName.value())
             .addAllNodesStats(nodesStats)
             .build();
@@ -81,7 +81,7 @@ public String toString() {
         }
     }
 
-    public NodesStatsResponseProto.NodesStatsRes response() {
+    public NodesStatsResponseProto.NodesStatsResponse response() {
         return nodesStatsRes;
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
index 4127cd55012c6..e446b7fd7ce5b 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
@@ -20,7 +20,7 @@
 import org.opensearch.common.Strings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.server.proto.ClusterStateRequestProto;
-import org.opensearch.server.proto.ClusterStateRequestProto.ClusterStateReq;
+import org.opensearch.server.proto.ClusterStateRequestProto.ClusterStateRequest;
 
 import java.io.IOException;
 import java.io.OutputStream;
@@ -37,13 +37,13 @@ public class ProtobufClusterStateRequest extends ProtobufClusterManagerNodeReadR
         IndicesRequest.Replaceable {
 
     public static final TimeValue DEFAULT_WAIT_FOR_NODE_TIMEOUT = TimeValue.timeValueMinutes(1);
-    private ClusterStateRequestProto.ClusterStateReq clusterStateRequest;
+    private ClusterStateRequestProto.ClusterStateRequest clusterStateRequest;
 
     public ProtobufClusterStateRequest () {}
 
     public ProtobufClusterStateRequest(boolean routingTable, boolean nodes, boolean metadata, boolean blocks,
                                         boolean customs, long waitForMetadataVersion, TimeValue waitForTimeout, List<String> indices) {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setRoutingTable(routingTable)
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setRoutingTable(routingTable)
                                         .setNodes(nodes)
                                         .setMetadata(metadata)
                                         .setBlocks(blocks)
@@ -60,7 +60,7 @@ public ActionRequestValidationException validate() {
     }
 
     public ProtobufClusterStateRequest all() {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setRoutingTable(true)
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setRoutingTable(true)
                                         .setNodes(true)
                                         .setMetadata(true)
                                         .setBlocks(true)
@@ -72,7 +72,7 @@ public ProtobufClusterStateRequest all() {
     }
 
     public ProtobufClusterStateRequest clear() {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setRoutingTable(false)
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setRoutingTable(false)
                                         .setNodes(false)
                                         .setMetadata(false)
                                         .setBlocks(false)
@@ -88,7 +88,7 @@ public boolean routingTable() {
     }
 
     public ProtobufClusterStateRequest routingTable(boolean routingTable) {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setRoutingTable(routingTable).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setRoutingTable(routingTable).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
         return this;
     }
 
@@ -97,7 +97,7 @@ public boolean nodes() {
     }
 
     public ProtobufClusterStateRequest nodes(boolean nodes) {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setNodes(nodes).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setNodes(nodes).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
         return this;
     }
 
@@ -106,7 +106,7 @@ public boolean metadata() {
     }
 
     public ProtobufClusterStateRequest metadata(boolean metadata) {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setMetadata(metadata).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setMetadata(metadata).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
         return this;
     }
 
@@ -115,7 +115,7 @@ public boolean blocks() {
     }
 
     public ProtobufClusterStateRequest blocks(boolean blocks) {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).setBlocks(blocks).build();
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).setBlocks(blocks).build();
         return this;
     }
 
@@ -126,7 +126,7 @@ public String[] indices() {
 
     @Override
     public ProtobufClusterStateRequest indices(String... indices) {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().addAllIndices(Arrays.asList(indices)).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().addAllIndices(Arrays.asList(indices)).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
         return this;
     }
 
@@ -146,7 +146,7 @@ public boolean includeDataStreams() {
     }
 
     public ProtobufClusterStateRequest customs(boolean customs) {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setCustoms(customs).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setCustoms(customs).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
         return this;
     }
 
@@ -162,7 +162,7 @@ public TimeValue waitForTimeout() {
     }
 
     public ProtobufClusterStateRequest waitForTimeout(TimeValue waitForTimeout) {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setWaitForTimeout(waitForTimeout.toString()).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setWaitForTimeout(waitForTimeout.toString()).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
         return this;
     }
 
@@ -176,7 +176,7 @@ public ProtobufClusterStateRequest waitForMetadataVersion(long waitForMetadataVe
                 "provided waitForMetadataVersion should be >= 1, but instead is [" + waitForMetadataVersion + "]"
             );
         }
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.newBuilder().setWaitForMetadataVersion(waitForMetadataVersion).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setWaitForMetadataVersion(waitForMetadataVersion).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
         return this;
     }
 
@@ -202,10 +202,10 @@ public IndicesOptions indicesOptions() {
     }
 
     public ProtobufClusterStateRequest(byte[] data) throws IOException {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateReq.parseFrom(data);
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.parseFrom(data);
     }
 
-    public ProtobufClusterStateRequest(ClusterStateRequestProto.ClusterStateReq clusterStateRequest) {
+    public ProtobufClusterStateRequest(ClusterStateRequestProto.ClusterStateRequest clusterStateRequest) {
         this.clusterStateRequest = clusterStateRequest;
     }
 
@@ -214,7 +214,7 @@ public void writeTo(OutputStream out) throws IOException {
         out.write(this.clusterStateRequest.toByteArray());
     }
 
-    public ClusterStateReq request() {
+    public ClusterStateRequest request() {
         return this.clusterStateRequest;
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
index 7b7b72fce2bed..56b1fd308b358 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
@@ -21,7 +21,7 @@
 import org.opensearch.cluster.routing.RoutingNode;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.server.proto.ClusterStateResponseProto;
-import org.opensearch.server.proto.ClusterStateResponseProto.ClusterStateRes;
+import org.opensearch.server.proto.ClusterStateResponseProto.ClusterStateResponse;
 
 import java.io.IOException;
 import java.io.OutputStream;
@@ -40,38 +40,38 @@
 */
 public class ProtobufClusterStateResponse extends ProtobufActionResponse {
 
-    private ClusterStateResponseProto.ClusterStateRes clusterStateRes;
+    private ClusterStateResponseProto.ClusterStateResponse clusterStateRes;
 
     public ProtobufClusterStateResponse(String clusterName, DiscoveryNodes nodes, long version, String stateUUID, boolean waitForTimedOut) {
-        ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Builder discoveryNodesBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.newBuilder();
+        ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Builder discoveryNodesBuilder = ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.newBuilder();
 
-        List<ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> allNodes = convertNodes(nodes);
+        List<ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node> allNodes = convertNodes(nodes);
         discoveryNodesBuilder.addAllAllNodes(allNodes).setClusterManagerNodeId(nodes.getClusterManagerNodeId()).setLocalNodeId(nodes.getLocalNodeId()).setMinNonClientNodeVersion(nodes.getSmallestNonClientNodeVersion().toString()).setMaxNonClientNodeVersion(nodes.getLargestNonClientNodeVersion().toString()).setMinNodeVersion(nodes.getMinNodeVersion().toString()).setMaxNodeVersion(nodes.getMaxNodeVersion().toString());
-        ClusterStateResponseProto.ClusterStateRes.ClusterState.Builder clusterStateBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.newBuilder();
+        ClusterStateResponseProto.ClusterStateResponse.ClusterState.Builder clusterStateBuilder = ClusterStateResponseProto.ClusterStateResponse.ClusterState.newBuilder();
         clusterStateBuilder.setClusterName(clusterName)
             .setVersion(version)
             .setStateUUID(stateUUID)
             .setNodes(discoveryNodesBuilder.build());
-        this.clusterStateRes = ClusterStateResponseProto.ClusterStateRes.newBuilder()
+        this.clusterStateRes = ClusterStateResponseProto.ClusterStateResponse.newBuilder()
                                             .setClusterName(clusterName)
                                             .setClusterState(clusterStateBuilder.build())
                                             .setWaitForTimedOut(waitForTimedOut)
                                             .build();
     }
 
-    private List<ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> convertNodes(DiscoveryNodes nodes) {
-        List<ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node> convertedNodes = new ArrayList<>();
+    private List<ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node> convertNodes(DiscoveryNodes nodes) {
+        List<ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node> convertedNodes = new ArrayList<>();
         if (nodes.getNodes().isEmpty()) {
             return convertedNodes;
         }
         for (DiscoveryNode node : nodes.getNodes().values()) {
-            List<ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole> nodeRoles = new ArrayList<>();
+            List<ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole> nodeRoles = new ArrayList<>();
             node.getRoles().forEach(role -> {
-                ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole.Builder nodeRoleBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole.newBuilder();
+                ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole.Builder nodeRoleBuilder = ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole.newBuilder();
                 nodeRoleBuilder.setIsKnownRole(role.isKnownRole()).setIsDynamicRole(role.isDynamicRole()).setRoleName(role.roleName()).setRoleNameAbbreviation(role.roleNameAbbreviation()).setCanContainData(role.canContainData()).build();
                 nodeRoles.add(nodeRoleBuilder.build());
             });
-            ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.Builder nodeBuilder = ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.newBuilder();
+            ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.Builder nodeBuilder = ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.newBuilder();
             nodeBuilder.setNodeName(node.getName()).setNodeId(node.getId()).setEphemeralId(node.getEphemeralId()).setHostName(node.getHostName())
             .setHostAddress(node.getHostAddress()).setTransportAddress(node.getAddress().toString()).putAllAttributes(node.getAttributes()).addAllRoles(nodeRoles).setVersion(node.getVersion().toString()).build();
             convertedNodes.add(nodeBuilder.build());
@@ -84,15 +84,15 @@ public String toString() {
         return "ProtobufClusterStateResponse{" + "clusterState=" + this.clusterStateRes.getClusterState() + '}';
     }
 
-    public ClusterStateRes response() {
+    public ClusterStateResponse response() {
         return this.clusterStateRes;
     }
 
     public ProtobufClusterStateResponse(byte[] data) throws IOException {
-        this.clusterStateRes = ClusterStateResponseProto.ClusterStateRes.parseFrom(data);
+        this.clusterStateRes = ClusterStateResponseProto.ClusterStateResponse.parseFrom(data);
     }
 
-    public ProtobufClusterStateResponse(ClusterStateResponseProto.ClusterStateRes clusterStateRes) {
+    public ProtobufClusterStateResponse(ClusterStateResponseProto.ClusterStateResponse clusterStateRes) {
         this.clusterStateRes = clusterStateRes;
     }
 
diff --git a/server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java b/server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java
deleted file mode 100644
index 1b538da573531..0000000000000
--- a/server/src/main/java/org/opensearch/example/proto/ExampleProtoRequest.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
-* 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.
-*/
-
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
-package org.opensearch.example.proto;
-
-import com.google.protobuf.InvalidProtocolBufferException;
-
-import org.opensearch.common.io.stream.TryWriteable;
-import org.opensearch.example.proto.ExampleRequestProto.ExampleRequest;
-import org.opensearch.transport.TransportRequest;
-
-import java.io.IOException;
-import java.io.OutputStream;
-
-/**
- * Transport request for obtaining cluster state
-*
-* @opensearch.internal
-*/
-public class ExampleProtoRequest extends TransportRequest implements TryWriteable {
-
-    private ExampleRequest request;
-
-    public ExampleProtoRequest(int id, String message) {
-        this.request = ExampleRequest.newBuilder().setId(id).setMessage(message).build();
-    }
-
-    public ExampleProtoRequest(byte[] data) throws InvalidProtocolBufferException {
-        this.request = ExampleRequest.parseFrom(data);
-    }
-
-    @Override
-    public void writeTo(OutputStream out) throws IOException {
-        // super.writeTo(out);
-        out.write(this.request.toByteArray());
-    }
-
-    //add getters and setters
-    public int id() {
-        return request.getId();
-    }
-
-    public String message() {
-        return request.getMessage();
-    }
-
-    public ExampleRequest exampleRequest() {
-        return request;
-    }
-
-    @Override
-    public String toString() {
-        StringBuilder builder = new StringBuilder();
-        builder.append("ExampleRequest[");
-        builder.append("header=").append(id());
-        builder.append(",message=").append(message());
-        return builder.append("]").toString();
-    }
-}
diff --git a/server/src/main/java/org/opensearch/rest/BaseRestHandler.java b/server/src/main/java/org/opensearch/rest/BaseRestHandler.java
index bcfff383f5199..00b9b2fa1fec5 100644
--- a/server/src/main/java/org/opensearch/rest/BaseRestHandler.java
+++ b/server/src/main/java/org/opensearch/rest/BaseRestHandler.java
@@ -103,10 +103,8 @@ public final long getUsageCount() {
 
     @Override
     public final void handleRequest(RestRequest request, RestChannel channel, NodeClient client) throws Exception {
-        logger.info("BaseRestHandler.handleRequest {}", request);
         // prepare the request for execution; has the side effect of touching the request parameters
         final RestChannelConsumer action = prepareRequest(request, client);
-        logger.info("BaseRestHandler.handleRequest action: {}", action);
 
         // validate unconsumed params, but we must exclude params used to format the response
         // use a sorted set so the unconsumed parameters appear in a reliable sorted order
diff --git a/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java b/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java
index 3c2d2a7aae256..6245c213ea09b 100644
--- a/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java
+++ b/server/src/main/java/org/opensearch/rest/ProtobufBaseRestHandler.java
@@ -78,10 +78,8 @@ public final long getUsageCount() {
 
     @Override
     public final void handleRequest(RestRequest request, RestChannel channel, ProtobufNodeClient client) throws Exception {
-        logger.info("ProtobufBaseRestHandler.handleRequest {}", request);
         // prepare the request for execution; has the side effect of touching the request parameters
         final RestChannelConsumer action = prepareRequest(request, client);
-        logger.info("ProtobufBaseRestHandler.handleRequest action: {}", action.getClass().getName());
 
         // validate unconsumed params, but we must exclude params used to format the response
         // use a sorted set so the unconsumed parameters appear in a reliable sorted order
diff --git a/server/src/main/java/org/opensearch/rest/RestController.java b/server/src/main/java/org/opensearch/rest/RestController.java
index afac4b6a22457..10f711df07a07 100644
--- a/server/src/main/java/org/opensearch/rest/RestController.java
+++ b/server/src/main/java/org/opensearch/rest/RestController.java
@@ -532,20 +532,14 @@ private void tryAllHandlers(final RestRequest request, final RestChannel channel
                     }
                 } else {
                     if (rawPath.contains("protobuf")) {
-                        long startTime = System.nanoTime();
                         dispatchProtobufRequest(request, channel, protobufHandler);
-                        long endTime = System.nanoTime();
-                        System.out.println("protobuf request time: " + (endTime - startTime) + "ns");
                     } else {
                     if (FeatureFlags.isEnabled(FeatureFlags.IDENTITY)) {
                         if (!handleAuthenticateUser(request, channel)) {
                             return;
                         }
                     }
-                        long startTime = System.nanoTime();
                         dispatchRequest(request, channel, handler);
-                        long endTime = System.nanoTime();
-                        System.out.println("original request time: " + (endTime - startTime) + "ns");
                     }
                     return;
                 }
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
index 84216b688fa88..dfea494505866 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
@@ -320,10 +320,10 @@ Table buildTable(
         ProtobufNodesInfoResponse nodesInfo,
         ProtobufNodesStatsResponse nodesStats
     ) {
-        ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes nodes = state.response().getClusterState().getNodes();
+        ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes nodes = state.response().getClusterState().getNodes();
         String clusterManagerId = nodes.getClusterManagerNodeId();
         Table table = getTableWithHeader(req);
-        for (ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node node : nodes.getAllNodesList()) {
+        for (ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node node : nodes.getAllNodesList()) {
             NodesInfo info = nodesInfo.nodesMap().get(node.getNodeId());
             NodesStats stats = nodesStats.nodesMap().get(node.getNodeId());
 
@@ -386,14 +386,14 @@ Table buildTable(
                 roles = "-";
                 allRoles = "-";
             } else {
-                List<ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole> knownNodeRoles = node.getRolesList()
+                List<ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole> knownNodeRoles = node.getRolesList()
                     .stream()
-                    .filter(ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole::getIsKnownRole)
+                    .filter(ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole::getIsKnownRole)
                     .collect(Collectors.toList());
                 roles = knownNodeRoles.size() > 0
-                    ? knownNodeRoles.stream().map(ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole::getRoleNameAbbreviation).sorted().collect(Collectors.joining())
+                    ? knownNodeRoles.stream().map(ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole::getRoleNameAbbreviation).sorted().collect(Collectors.joining())
                     : "-";
-                allRoles = node.getRolesList().stream().map(ClusterStateResponseProto.ClusterStateRes.ClusterState.DiscoveryNodes.Node.NodeRole::getRoleName).sorted().collect(Collectors.joining(","));
+                allRoles = node.getRolesList().stream().map(ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole::getRoleName).sorted().collect(Collectors.joining(","));
             }
             table.addCell(roles);
             table.addCell(allRoles);
diff --git a/server/src/main/java/org/opensearch/transport/InboundHandler.java b/server/src/main/java/org/opensearch/transport/InboundHandler.java
index b63938f652c2b..5b3b742982a10 100644
--- a/server/src/main/java/org/opensearch/transport/InboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/InboundHandler.java
@@ -57,13 +57,13 @@
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
 import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.server.proto.ClusterStateRequestProto.ClusterStateReq;
-import org.opensearch.server.proto.ClusterStateResponseProto.ClusterStateRes;
+import org.opensearch.server.proto.ClusterStateRequestProto.ClusterStateRequest;
+import org.opensearch.server.proto.ClusterStateResponseProto.ClusterStateResponse;
 import org.opensearch.server.proto.NodesInfoProto.NodesInfo;
-import org.opensearch.server.proto.NodesInfoRequestProto.NodesInfoReq;
+import org.opensearch.server.proto.NodesInfoRequestProto.NodesInfoRequest;
 import org.opensearch.server.proto.NodesStatsProto.NodesStats;
-import org.opensearch.server.proto.NodesStatsRequestProto.NodesStatsReq;
-import org.opensearch.server.proto.OutboundMessageProto.OutboundMsg;
+import org.opensearch.server.proto.NodesStatsRequestProto.NodesStatsRequest;
+import org.opensearch.server.proto.MessageProto.OutboundInboundMessage;
 import org.opensearch.threadpool.ThreadPool;
 
 import java.io.EOFException;
@@ -125,14 +125,6 @@ void setMessageListener(TransportMessageListener listener) {
         }
     }
 
-    // void setProtobufMessageListener(ProtobufTransportMessageListener listener) {
-    //     if (protobufMessageListener == ProtobufTransportMessageListener.NOOP_LISTENER) {
-    //         protobufMessageListener = listener;
-    //     } else {
-    //         throw new IllegalStateException("Cannot set message listener twice");
-    //     }
-    // }
-
     void setSlowLogThreshold(TimeValue slowLogThreshold) {
         this.slowLogThresholdMs = slowLogThreshold.getMillis();
     }
@@ -161,7 +153,7 @@ void inboundMessageProtobuf(TcpChannel channel, BytesReference message) throws I
 
     private void messageReceivedProtobuf(TcpChannel channel, ProtobufOutboundMessage message, long startTime) throws IOException {
         final InetSocketAddress remoteAddress = channel.getRemoteAddress();
-        final org.opensearch.server.proto.OutboundMessageProto.OutboundMsg.Header header = message.getHeader();
+        final org.opensearch.server.proto.MessageProto.OutboundInboundMessage.Header header = message.getHeader();
 
         ThreadContext threadContext = threadPool.getThreadContext();
         try (ThreadContext.StoredContext existing = threadContext.stashContext()) {
@@ -258,18 +250,18 @@ private void messageReceived(TcpChannel channel, InboundMessage message, long st
         }
     }
 
-    private <T extends TransportRequest> void handleRequestProtobuf(TcpChannel channel, org.opensearch.server.proto.OutboundMessageProto.OutboundMsg.Header header, ProtobufOutboundMessage message) throws IOException {
-        OutboundMsg outboundMsg = message.getMessage();
-        final String action = outboundMsg.getAction();
+    private <T extends TransportRequest> void handleRequestProtobuf(TcpChannel channel, org.opensearch.server.proto.MessageProto.OutboundInboundMessage.Header header, ProtobufOutboundMessage message) throws IOException {
+        OutboundInboundMessage receivedMessage = message.getMessage();
+        final String action = receivedMessage.getAction();
         final long requestId = header.getRequestId();
-        final Version version = Version.fromString(outboundMsg.getVersion());
+        final Version version = Version.fromString(receivedMessage.getVersion());
         final TransportChannel transportChannel = new TcpTransportChannel(
             outboundHandler,
             channel,
             action,
             requestId,
             version,
-            outboundMsg.getFeaturesList().stream().map(String::valueOf).collect(Collectors.toSet()),
+            receivedMessage.getFeaturesList().stream().map(String::valueOf).collect(Collectors.toSet()),
             false,
             false,
             () -> {}
@@ -278,8 +270,8 @@ private <T extends TransportRequest> void handleRequestProtobuf(TcpChannel chann
             messageListener.onRequestReceived(requestId, action);
             final ProtobufRequestHandlerRegistry<T> reg = protobufRequestHandlers.getHandler(action);
             assert reg != null;
-            if (outboundMsg.hasClusterStateReq()) {
-                final ClusterStateReq clusterStateReq = outboundMsg.getClusterStateReq();
+            if (receivedMessage.hasClusterStateRequest()) {
+                final ClusterStateRequest clusterStateReq = receivedMessage.getClusterStateRequest();
                 ProtobufClusterStateRequest protobufClusterStateRequest = new ProtobufClusterStateRequest(clusterStateReq);
                 final T request = (T) protobufClusterStateRequest;
                 request.remoteAddress(new TransportAddress(channel.getRemoteAddress()));
@@ -293,8 +285,8 @@ private <T extends TransportRequest> void handleRequestProtobuf(TcpChannel chann
                 } else {
                     threadPool.executor(executor).execute(new ProtobufRequestHandler<>(reg, request, transportChannel));
                 }
-            } else if (outboundMsg.hasNodesInfoReq()) {
-                final NodesInfoReq nodesInfoReq = outboundMsg.getNodesInfoReq();
+            } else if (receivedMessage.hasNodesInfoRequest()) {
+                final NodesInfoRequest nodesInfoReq = receivedMessage.getNodesInfoRequest();
                 try {
                     ProtobufNodesInfoRequest protobufNodesInfoRequest = new ProtobufNodesInfoRequest(nodesInfoReq);
                     final T request = (T) new NodeInfoRequest(protobufNodesInfoRequest);
@@ -310,10 +302,10 @@ private <T extends TransportRequest> void handleRequestProtobuf(TcpChannel chann
                         threadPool.executor(executor).execute(new ProtobufRequestHandler<>(reg, request, transportChannel));
                     }
                 } catch (Exception e) {
-                    System.out.println("Exception: " + e);
+                    sendErrorResponse(action, transportChannel, e);
                 }             
-            } else if (outboundMsg.hasNodesStatsReq()) {
-                final NodesStatsReq nodesStatsReq = outboundMsg.getNodesStatsReq();
+            } else if (receivedMessage.hasNodesStatsRequest()) {
+                final NodesStatsRequest nodesStatsReq = receivedMessage.getNodesStatsRequest();
                 try {
                     ProtobufNodesStatsRequest protobufNodesStatsRequest = new ProtobufNodesStatsRequest(nodesStatsReq);
                     final T request = (T) new NodeStatsRequest(protobufNodesStatsRequest);
@@ -329,7 +321,7 @@ private <T extends TransportRequest> void handleRequestProtobuf(TcpChannel chann
                         threadPool.executor(executor).execute(new ProtobufRequestHandler<>(reg, request, transportChannel));
                     }
                 } catch (Exception e) {
-                    System.out.println("Exception: " + e);
+                    sendErrorResponse(action, transportChannel, e);
                 }             
             }
         } catch (Exception e) {
@@ -553,9 +545,9 @@ private <T extends TransportResponse> void handleProtobufResponse(
         final TransportResponseHandler<T> handler
     ) throws IOException {
         try {
-            OutboundMsg outboundMsg = message.getMessage();
-            if (outboundMsg.hasClusterStateRes()) {
-                final ClusterStateRes clusterStateRes = outboundMsg.getClusterStateRes();
+            OutboundInboundMessage receivedMessage = message.getMessage();
+            if (receivedMessage.hasClusterStateResponse()) {
+                final ClusterStateResponse clusterStateRes = receivedMessage.getClusterStateResponse();
                 ProtobufClusterStateResponse protobufClusterStateResponse = new ProtobufClusterStateResponse(clusterStateRes);
                 final T response = (T) protobufClusterStateResponse;
                 response.remoteAddress(new TransportAddress(remoteAddress));
@@ -566,8 +558,8 @@ private <T extends TransportResponse> void handleProtobufResponse(
                 } else {
                     threadPool.executor(executor).execute(() -> doHandleResponse(handler, response));
                 }
-            } else if (outboundMsg.hasNodesInfoRes()) {
-                final NodesInfo nodesInfoRes = outboundMsg.getNodesInfoRes();
+            } else if (receivedMessage.hasNodesInfoResponse()) {
+                final NodesInfo nodesInfoRes = receivedMessage.getNodesInfoResponse();
                 ProtobufNodeInfo protobufNodeInfo = new ProtobufNodeInfo(nodesInfoRes);
                 final T response = (T) protobufNodeInfo;
                 response.remoteAddress(new TransportAddress(remoteAddress));
@@ -578,8 +570,8 @@ private <T extends TransportResponse> void handleProtobufResponse(
                 } else {
                     threadPool.executor(executor).execute(() -> doHandleResponse(handler, response));
                 }
-            } else if (outboundMsg.hasNodesStatsRes()) {
-                final NodesStats nodesStatsRes = outboundMsg.getNodesStatsRes();
+            } else if (receivedMessage.hasNodesStatsResponse()) {
+                final NodesStats nodesStatsRes = receivedMessage.getNodesStatsResponse();
                 ProtobufNodeStats protobufNodeStats = new ProtobufNodeStats(nodesStatsRes);
                 final T response = (T) protobufNodeStats;
                 response.remoteAddress(new TransportAddress(remoteAddress));
diff --git a/server/src/main/java/org/opensearch/transport/OutboundHandler.java b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
index 7ebab0672b39e..8055de8c07746 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
@@ -160,33 +160,6 @@ void sendRequest(
         }
     }
 
-    // void sendProtobufRequest(
-    //     final DiscoveryNode node,
-    //     final TcpChannel channel,
-    //     final long requestId,
-    //     final String action,
-    //     final TransportRequest request,
-    //     final TransportRequestOptions options,
-    //     final Version channelVersion,
-    //     final boolean compressRequest,
-    //     final boolean isHandshake
-    // ) throws IOException, TransportException {
-    //     Version version = Version.min(this.version, channelVersion);
-
-    //     System.out.println("OutboundHandler.sendProtobufRequest");
-    //     System.out.println("node: " + node);
-    //     System.out.println("channel: " + channel);
-    //     System.out.println("requestId: " + requestId);
-    //     System.out.println("action: " + action);
-    //     System.out.println("request: " + request.toString());
-    //     System.out.println("canonical: " + request.getClass().getCanonicalName());
-    //     ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onRequestSent(node, requestId, action, request, options));
-    //     byte[] bytes = new byte[1];
-    //     bytes[0] = 0;
-    //     ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), request.transportReq(), features, action);
-    //     sendProtobufMessage(channel, protobufMessage, listener);
-    // }
-
     /**
      * Sends the response to the given channel. This method should be used to send {@link TransportResponse}
      * objects back to the caller.
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java b/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
index 09db38c1cef74..0b721aa938099 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
@@ -19,15 +19,15 @@
 
 import org.opensearch.Version;
 import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.server.proto.ClusterStateRequestProto.ClusterStateReq;
-import org.opensearch.server.proto.ClusterStateResponseProto.ClusterStateRes;
+import org.opensearch.server.proto.ClusterStateRequestProto.ClusterStateRequest;
+import org.opensearch.server.proto.ClusterStateResponseProto.ClusterStateResponse;
 import org.opensearch.server.proto.NodesInfoProto.NodesInfo;
-import org.opensearch.server.proto.NodesInfoRequestProto.NodesInfoReq;
+import org.opensearch.server.proto.NodesInfoRequestProto.NodesInfoRequest;
 import org.opensearch.server.proto.NodesStatsProto.NodesStats;
-import org.opensearch.server.proto.NodesStatsRequestProto.NodesStatsReq;
-import org.opensearch.server.proto.OutboundMessageProto.OutboundMsg;
-import org.opensearch.server.proto.OutboundMessageProto.OutboundMsg.Header;
-import org.opensearch.server.proto.OutboundMessageProto.OutboundMsg.ResponseHandlersList;
+import org.opensearch.server.proto.NodesStatsRequestProto.NodesStatsRequest;
+import org.opensearch.server.proto.MessageProto.OutboundInboundMessage;
+import org.opensearch.server.proto.MessageProto.OutboundInboundMessage.Header;
+import org.opensearch.server.proto.MessageProto.OutboundInboundMessage.ResponseHandlersList;
 import com.google.protobuf.ByteString;
 import com.google.protobuf.InvalidProtocolBufferException;
 
@@ -38,10 +38,10 @@
 */
 public class ProtobufOutboundMessage {
 
-    private final OutboundMsg message;
+    private final OutboundInboundMessage message;
     private static final byte[] PREFIX = { (byte) 'E', (byte) 'S' };
 
-    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, ClusterStateReq clusterStateReq, String[] features, String action) {
+    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, ClusterStateRequest clusterStateReq, String[] features, String action) {
         Header header = Header.newBuilder()
                             .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
                             .setRequestId(requestId)
@@ -59,14 +59,14 @@ public ProtobufOutboundMessage(long requestId, byte[] status, Version version, T
                                                                         .build();
             responseHandlers.put(key, responseHandlersList);
         }
-        this.message = OutboundMsg.newBuilder()
+        this.message = OutboundInboundMessage.newBuilder()
                             .setHeader(header)
                             .putAllRequestHeaders(requestHeaders)
                             .putAllResponseHandlers(responseHandlers)
                             .setVersion(version.toString())
                             .setStatus(ByteString.copyFrom(status))
                             .setRequestId(requestId)
-                            .setClusterStateReq(clusterStateReq)
+                            .setClusterStateRequest(clusterStateReq)
                             .setAction(action)
                             .addAllFeatures(Arrays.asList(features))
                             .setIsProtobuf(true)
@@ -74,7 +74,7 @@ public ProtobufOutboundMessage(long requestId, byte[] status, Version version, T
                             
     }
 
-    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, ClusterStateRes clusterStateRes, Set<String> features, String action) {
+    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, ClusterStateResponse clusterStateRes, Set<String> features, String action) {
         Header header = Header.newBuilder()
                             .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
                             .setRequestId(requestId)
@@ -92,14 +92,14 @@ public ProtobufOutboundMessage(long requestId, byte[] status, Version version, T
                                                                         .build();
             responseHandlers.put(key, responseHandlersList);
         }
-        this.message = OutboundMsg.newBuilder()
+        this.message = OutboundInboundMessage.newBuilder()
                             .setHeader(header)
                             .putAllRequestHeaders(requestHeaders)
                             .putAllResponseHandlers(responseHandlers)
                             .setVersion(version.toString())
                             .setStatus(ByteString.copyFrom(status))
                             .setRequestId(requestId)
-                            .setClusterStateRes(clusterStateRes)
+                            .setClusterStateResponse(clusterStateRes)
                             .setAction(action)
                             .addAllFeatures(features)
                             .setIsProtobuf(true)
@@ -107,7 +107,7 @@ public ProtobufOutboundMessage(long requestId, byte[] status, Version version, T
                             
     }
 
-    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, NodesInfoReq nodesInfoReq, String[] features, String action) {
+    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, NodesInfoRequest nodesInfoReq, String[] features, String action) {
         Header header = Header.newBuilder()
                             .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
                             .setRequestId(requestId)
@@ -125,14 +125,14 @@ public ProtobufOutboundMessage(long requestId, byte[] status, Version version, T
                                                                         .build();
             responseHandlers.put(key, responseHandlersList);
         }
-        this.message = OutboundMsg.newBuilder()
+        this.message = OutboundInboundMessage.newBuilder()
                             .setHeader(header)
                             .putAllRequestHeaders(requestHeaders)
                             .putAllResponseHandlers(responseHandlers)
                             .setVersion(version.toString())
                             .setStatus(ByteString.copyFrom(status))
                             .setRequestId(requestId)
-                            .setNodesInfoReq(nodesInfoReq)
+                            .setNodesInfoRequest(nodesInfoReq)
                             .setAction(action)
                             .addAllFeatures(Arrays.asList(features))
                             .setIsProtobuf(true)
@@ -158,14 +158,14 @@ public ProtobufOutboundMessage(long requestId, byte[] status, Version version, T
                                                                         .build();
             responseHandlers.put(key, responseHandlersList);
         }
-        this.message = OutboundMsg.newBuilder()
+        this.message = OutboundInboundMessage.newBuilder()
                             .setHeader(header)
                             .putAllRequestHeaders(requestHeaders)
                             .putAllResponseHandlers(responseHandlers)
                             .setVersion(version.toString())
                             .setStatus(ByteString.copyFrom(status))
                             .setRequestId(requestId)
-                            .setNodesInfoRes(nodesInfoRes)
+                            .setNodesInfoResponse(nodesInfoRes)
                             .setAction(action)
                             .addAllFeatures(features)
                             .setIsProtobuf(true)
@@ -173,7 +173,7 @@ public ProtobufOutboundMessage(long requestId, byte[] status, Version version, T
                             
     }
 
-    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, NodesStatsReq nodesStatsReq, String[] features, String action) {
+    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, NodesStatsRequest nodesStatsReq, String[] features, String action) {
         Header header = Header.newBuilder()
                             .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
                             .setRequestId(requestId)
@@ -191,14 +191,14 @@ public ProtobufOutboundMessage(long requestId, byte[] status, Version version, T
                                                                         .build();
             responseHandlers.put(key, responseHandlersList);
         }
-        this.message = OutboundMsg.newBuilder()
+        this.message = OutboundInboundMessage.newBuilder()
                             .setHeader(header)
                             .putAllRequestHeaders(requestHeaders)
                             .putAllResponseHandlers(responseHandlers)
                             .setVersion(version.toString())
                             .setStatus(ByteString.copyFrom(status))
                             .setRequestId(requestId)
-                            .setNodesStatsReq(nodesStatsReq)
+                            .setNodesStatsRequest(nodesStatsReq)
                             .setAction(action)
                             .addAllFeatures(Arrays.asList(features))
                             .setIsProtobuf(true)
@@ -224,14 +224,14 @@ public ProtobufOutboundMessage(long requestId, byte[] status, Version version, T
                                                                         .build();
             responseHandlers.put(key, responseHandlersList);
         }
-        this.message = OutboundMsg.newBuilder()
+        this.message = OutboundInboundMessage.newBuilder()
                             .setHeader(header)
                             .putAllRequestHeaders(requestHeaders)
                             .putAllResponseHandlers(responseHandlers)
                             .setVersion(version.toString())
                             .setStatus(ByteString.copyFrom(status))
                             .setRequestId(requestId)
-                            .setNodesStatsRes(nodesStatsRes)
+                            .setNodesStatsResponse(nodesStatsRes)
                             .setAction(action)
                             .addAllFeatures(features)
                             .setIsProtobuf(true)
@@ -240,7 +240,7 @@ public ProtobufOutboundMessage(long requestId, byte[] status, Version version, T
     }
 
     public ProtobufOutboundMessage(byte[] data) throws InvalidProtocolBufferException {
-        this.message = OutboundMsg.parseFrom(data);
+        this.message = OutboundInboundMessage.parseFrom(data);
     }
 
     public void writeTo(OutputStream out) throws IOException {
@@ -248,7 +248,7 @@ public void writeTo(OutputStream out) throws IOException {
         out.write(this.message.toByteArray());
     }
 
-    public OutboundMsg getMessage() {
+    public OutboundInboundMessage getMessage() {
         return this.message;
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/TransportRequest.java b/server/src/main/java/org/opensearch/transport/TransportRequest.java
index 7a81a03e62a21..c13e6710d8ad4 100644
--- a/server/src/main/java/org/opensearch/transport/TransportRequest.java
+++ b/server/src/main/java/org/opensearch/transport/TransportRequest.java
@@ -35,8 +35,6 @@
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
-import org.opensearch.server.proto.TransportRequestProto;
-import org.opensearch.server.proto.TransportRequestProto.TransportReq;
 import org.opensearch.tasks.ProtobufTaskAwareRequest;
 import org.opensearch.tasks.ProtobufTaskId;
 import org.opensearch.tasks.TaskAwareRequest;
@@ -52,7 +50,6 @@
  */
 public abstract class TransportRequest extends TransportMessage implements TaskAwareRequest, ProtobufTaskAwareRequest {
 
-    private TransportRequestProto.TransportReq transportReq;
     /**
      * Empty transport request
      *
@@ -84,10 +81,6 @@ public Empty(byte[] in) throws IOException {
 
     public TransportRequest() {}
 
-    public TransportRequest(ProtobufClusterStateRequest clusterStateRequest) {
-        this.transportReq = TransportReq.newBuilder().setClusterStateRequest(clusterStateRequest.request()).build();
-    }
-
     public TransportRequest(StreamInput in) throws IOException {
         parentTaskId = TaskId.readFromStream(in);
     }
@@ -138,7 +131,4 @@ public void writeTo(OutputStream out) throws IOException {
         protobufParentTaskId.writeTo(out);
     }
 
-    public TransportReq transportReq() {
-        return transportReq;
-    }
 }
diff --git a/server/src/main/proto/examples/ExampleRequestProto.proto b/server/src/main/proto/examples/ExampleRequestProto.proto
deleted file mode 100644
index 48d2f8de963a9..0000000000000
--- a/server/src/main/proto/examples/ExampleRequestProto.proto
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * 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.
- *
- * Modifications Copyright OpenSearch Contributors. See
- * GitHub history for details.
- */
-
-syntax = "proto3";
-package org.opensearch.example.proto;
-
-option java_outer_classname = "ExampleRequestProto";
-
-message ExampleRequest {
-  int32 id = 1;
-  string message = 2;
-}
diff --git a/server/src/main/proto/server/ClusterStateRequestProto.proto b/server/src/main/proto/server/ClusterStateRequestProto.proto
index ea323564b2392..7326429ae0fbd 100644
--- a/server/src/main/proto/server/ClusterStateRequestProto.proto
+++ b/server/src/main/proto/server/ClusterStateRequestProto.proto
@@ -14,7 +14,7 @@ package org.opensearch.server.proto;
 
 option java_outer_classname = "ClusterStateRequestProto";
 
-message ClusterStateReq {
+message ClusterStateRequest {
   bool routingTable = 1;
   bool nodes = 2;
   bool metadata = 3;
diff --git a/server/src/main/proto/server/ClusterStateResponseProto.proto b/server/src/main/proto/server/ClusterStateResponseProto.proto
index 2894dff625b8f..554a03b1975ab 100644
--- a/server/src/main/proto/server/ClusterStateResponseProto.proto
+++ b/server/src/main/proto/server/ClusterStateResponseProto.proto
@@ -14,7 +14,7 @@ package org.opensearch.server.proto;
 
 option java_outer_classname = "ClusterStateResponseProto";
 
-message ClusterStateRes {
+message ClusterStateResponse {
   string clusterName = 1;
   ClusterState clusterState = 2;
   bool waitForTimedOut = 3;
diff --git a/server/src/main/proto/server/OutboundMessageProto.proto b/server/src/main/proto/server/MessageProto.proto
similarity index 74%
rename from server/src/main/proto/server/OutboundMessageProto.proto
rename to server/src/main/proto/server/MessageProto.proto
index be69c1d54ebb9..e7fb8b821b737 100644
--- a/server/src/main/proto/server/OutboundMessageProto.proto
+++ b/server/src/main/proto/server/MessageProto.proto
@@ -12,8 +12,6 @@
 syntax = "proto3";
 package org.opensearch.server.proto;
 
-import "examples/ExampleRequestProto.proto";
-import "server/TransportRequestProto.proto";
 import "server/ClusterStateRequestProto.proto";
 import "server/ClusterStateResponseProto.proto";
 import "server/NodesInfoRequestProto.proto";
@@ -21,9 +19,9 @@ import "server/NodesInfoProto.proto";
 import "server/NodesStatsRequestProto.proto";
 import "server/NodesStatsProto.proto";
 
-option java_outer_classname = "OutboundMessageProto";
+option java_outer_classname = "MessageProto";
 
-message OutboundMsg {
+message OutboundInboundMessage {
   Header header = 1;
   map<string, string> requestHeaders = 2;
   map<string, ResponseHandlersList> responseHandlers = 3;
@@ -33,12 +31,12 @@ message OutboundMsg {
   string action = 7;
   int64 requestId = 8;
   oneof message {
-    ClusterStateReq clusterStateReq = 9;
-    ClusterStateRes clusterStateRes = 10;
-    NodesInfoReq nodesInfoReq = 11;
-    NodesInfo nodesInfoRes = 12;
-    NodesStatsReq nodesStatsReq = 13;
-    NodesStats nodesStatsRes = 14;
+    ClusterStateRequest clusterStateRequest = 9;
+    ClusterStateResponse clusterStateResponse = 10;
+    NodesInfoRequest nodesInfoRequest = 11;
+    NodesInfo nodesInfoResponse = 12;
+    NodesStatsRequest nodesStatsRequest = 13;
+    NodesStats nodesStatsResponse = 14;
   }
   bool isProtobuf = 15;
   
diff --git a/server/src/main/proto/server/NodesInfoRequestProto.proto b/server/src/main/proto/server/NodesInfoRequestProto.proto
index a36d93bf55539..1c02f7d2364d7 100644
--- a/server/src/main/proto/server/NodesInfoRequestProto.proto
+++ b/server/src/main/proto/server/NodesInfoRequestProto.proto
@@ -14,7 +14,7 @@ package org.opensearch.server.proto;
 
 option java_outer_classname = "NodesInfoRequestProto";
 
-message NodesInfoReq {
+message NodesInfoRequest {
   repeated string requestedMetrics = 1;
   string timeout = 2;
 }
diff --git a/server/src/main/proto/server/NodesInfoResponseProto.proto b/server/src/main/proto/server/NodesInfoResponseProto.proto
index ceb3c4b064cca..6ba56dbd44040 100644
--- a/server/src/main/proto/server/NodesInfoResponseProto.proto
+++ b/server/src/main/proto/server/NodesInfoResponseProto.proto
@@ -16,7 +16,7 @@ import "server/NodesInfoProto.proto";
 
 option java_outer_classname = "NodesInfoResponseProto";
 
-message NodesInfoRes {
+message NodesInfoResponse {
   string clusterName = 1;
   repeated NodesInfo nodesInfo = 2;
 }
diff --git a/server/src/main/proto/server/NodesStatsRequestProto.proto b/server/src/main/proto/server/NodesStatsRequestProto.proto
index 25228c409634e..b3da5cbf60aa0 100644
--- a/server/src/main/proto/server/NodesStatsRequestProto.proto
+++ b/server/src/main/proto/server/NodesStatsRequestProto.proto
@@ -14,7 +14,7 @@ package org.opensearch.server.proto;
 
 option java_outer_classname = "NodesStatsRequestProto";
 
-message NodesStatsReq {
+message NodesStatsRequest {
   repeated string requestedMetrics = 1;
   string timeout = 2;
 }
diff --git a/server/src/main/proto/server/NodesStatsResponseProto.proto b/server/src/main/proto/server/NodesStatsResponseProto.proto
index ba3d694444c31..59ba8afad3c33 100644
--- a/server/src/main/proto/server/NodesStatsResponseProto.proto
+++ b/server/src/main/proto/server/NodesStatsResponseProto.proto
@@ -16,7 +16,7 @@ import "server/NodesStatsProto.proto";
 
 option java_outer_classname = "NodesStatsResponseProto";
 
-message NodesStatsRes {
+message NodesStatsResponse {
   string clusterName = 1;
   repeated NodesStats nodesStats = 2;
 }
diff --git a/server/src/main/proto/server/TransportRequestProto.proto b/server/src/main/proto/server/TransportRequestProto.proto
deleted file mode 100644
index 636e37d33edd2..0000000000000
--- a/server/src/main/proto/server/TransportRequestProto.proto
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * 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.
- *
- * Modifications Copyright OpenSearch Contributors. See
- * GitHub history for details.
- */
-
-syntax = "proto3";
-package org.opensearch.server.proto;
-
-import "server/ClusterStateRequestProto.proto";
-
-option java_outer_classname = "TransportRequestProto";
-
-message TransportReq {
-  optional ClusterStateReq clusterStateRequest = 1;
-}
diff --git a/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java b/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
index 32884a572b968..268e689630231 100644
--- a/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
+++ b/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
@@ -49,8 +49,6 @@
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.common.util.io.Streams;
-import org.opensearch.example.proto.ExampleProtoRequest;
-import org.opensearch.example.proto.ExampleRequestProto.ExampleRequest;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
@@ -318,86 +316,4 @@ public void onResponseSent(long requestId, String action, Exception error) {
         assertEquals("header_value", header.getHeaders().v1().get("header"));
     }
 
-    public void testSendRequestProtobuf() throws IOException {
-        System.out.println("In testSendRequestProtobuf");
-        ThreadContext threadContext = threadPool.getThreadContext();
-        Version version = randomFrom(Version.CURRENT, Version.CURRENT.minimumCompatibilityVersion());
-        String action = "example";
-        long requestId = randomLongBetween(0, 300);
-        boolean isHandshake = false;
-        boolean compress = false;
-        String value = "message";
-        threadContext.putHeader("header", "header_value");
-        ExampleProtoRequest request = new ExampleProtoRequest(1, value);
-
-        AtomicReference<DiscoveryNode> nodeRef = new AtomicReference<>();
-        AtomicLong requestIdRef = new AtomicLong();
-        AtomicReference<String> actionRef = new AtomicReference<>();
-        AtomicReference<TransportRequest> requestRef = new AtomicReference<>();
-        handler.setMessageListener(new TransportMessageListener() {
-            @Override
-            public void onRequestSent(
-                DiscoveryNode node,
-                long requestId,
-                String action,
-                TransportRequest request,
-                TransportRequestOptions options
-            ) {
-                nodeRef.set(node);
-                requestIdRef.set(requestId);
-                actionRef.set(action);
-                requestRef.set(request);
-            }
-        });
-        // handler.sendProtobufRequest(node, channel, requestId, action, request, options, version, compress, isHandshake);
-
-        BytesReference reference = channel.getMessageCaptor().get();
-        ActionListener<Void> sendListener = channel.getListenerCaptor().get();
-        // if (randomBoolean()) {
-            sendListener.onResponse(null);
-        // } else {
-        //     sendListener.onFailure(new IOException("failed"));
-        // }
-        assertEquals(node, nodeRef.get());
-        assertEquals(requestId, requestIdRef.get());
-        assertEquals(action, actionRef.get());
-        assertEquals(request, requestRef.get());
-
-        pipeline.handleBytes(channel, new ReleasableBytesReference(reference, () -> {}));
-        // final Tuple<Header, BytesReference> tuple = message.get();
-        // final Header header = tuple.v1();
-        // final TestRequest message = new TestRequest(tuple.v2().streamInput());
-        final BytesReference reference2 = protobufMessage.get();
-        byte[] incomingBytes = BytesReference.toBytes(reference2);
-        System.out.println("Size of incoming bytes: " + incomingBytes.length);
-        for (int i = 0; i < incomingBytes.length; i++) {
-            System.out.println("Byte " + i + " is: " + incomingBytes[i]);
-        }
-        ProtobufOutboundMessage protobufOutboundMessage = new ProtobufOutboundMessage(incomingBytes);
-        System.out.println("Received protobuf message is: " + protobufOutboundMessage);
-        // ProtobufOutboundMessage protobufOutboundMessage = new ProtobufOutboundMessage(incomingBytes);
-        // System.out.println("Received protobuf message is: " + protobufOutboundMessage);
-        // final Header header = tuple.v1();
-        // final ExampleProtoRequest message = new ExampleProtoRequest(tuple.v2().toBytesRef().bytes);
-        // assertEquals(version, header.getVersion());
-        // assertEquals(requestId, header.getRequestId());
-        // assertTrue(header.isRequest());
-        // assertFalse(header.isResponse());
-        // if (isHandshake) {
-        //     assertTrue(header.isHandshake());
-        // } else {
-        //     assertFalse(header.isHandshake());
-        // }
-        // if (compress) {
-        //     assertTrue(header.isCompressed());
-        // } else {
-        //     assertFalse(header.isCompressed());
-        // }
-
-        // System.out.println("Received request after deserialization is: " + message);
-
-        // assertEquals(value, message.message());
-        // assertEquals(1, message.id());
-        // assertEquals("header_value", header.getHeaders().v1().get("header"));
-    }
 }

From 8f5a3279c0b484baefd3a8ac1fa11eda57574c7d Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Wed, 2 Aug 2023 23:10:36 +0000
Subject: [PATCH 29/37] Fixing precommit failures

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../common/io/stream/ProtobufWriteable.java   |   5 -
 .../CorrelationVectorFieldMapperTests.java    |   2 +-
 .../query/CorrelationQueryBuilderTests.java   |   2 +-
 .../org/opensearch/upgrades/IndexingIT.java   |   2 +-
 server/build.gradle                           |   1 +
 .../node/tasks/CancellableTasksIT.java        |   6 +
 ...ProtobufActionListenerResponseHandler.java |   4 +-
 .../action/ProtobufActionRequest.java         |   5 -
 .../action/ProtobufActionResponse.java        |   5 -
 .../cluster/node/info/ProtobufNodeInfo.java   |   5 -
 .../node/info/ProtobufNodesInfoRequest.java   |   5 +-
 .../node/info/ProtobufNodesInfoResponse.java  |   1 -
 .../cluster/node/stats/ProtobufNodeStats.java |   2 +-
 .../node/stats/ProtobufNodesStatsRequest.java |   3 +-
 .../state/ProtobufClusterStateRequest.java    | 124 +++++---
 .../state/ProtobufClusterStateResponse.java   |  66 ++--
 .../ProtobufTransportClusterStateAction.java  |  13 +-
 ...TransportFieldCapabilitiesIndexAction.java |   1 -
 .../action/main/ProtobufMainResponse.java     |   2 +-
 .../opensearch/action/search/PitService.java  |   1 -
 .../ProtobufHandledTransportAction.java       |  11 +-
 .../node/TransportBroadcastByNodeAction.java  |   4 +-
 ...ProtobufClusterManagerNodeReadRequest.java |   9 +-
 .../ProtobufClusterManagerNodeRequest.java    |   5 -
 ...obufTransportClusterManagerNodeAction.java |  11 +-
 .../nodes/ProtobufBaseNodeResponse.java       |   7 +-
 .../nodes/ProtobufBaseNodesRequest.java       |   8 +-
 .../nodes/ProtobufBaseNodesResponse.java      |   5 -
 .../nodes/ProtobufTransportNodesAction.java   |   6 +-
 .../shard/TransportSingleShardAction.java     |   1 -
 .../support/tasks/TransportTasksAction.java   |   5 +-
 .../org/opensearch/client/ProtobufClient.java |   2 -
 .../support/ProtobufAbstractClient.java       |   1 -
 .../org/opensearch/cluster/ClusterModule.java |   2 +-
 .../org/opensearch/cluster/ClusterName.java   |   1 -
 .../org/opensearch/cluster/ClusterState.java  |   1 -
 .../org/opensearch/cluster/ProtobufDiff.java  |   5 -
 .../opensearch/cluster/ProtobufDiffable.java  |   5 -
 .../cluster/block/ClusterBlocks.java          |   1 -
 .../cluster/coordination/Coordinator.java     |   1 -
 .../metadata/IndexTemplateMetadata.java       |   1 -
 .../opensearch/cluster/metadata/Metadata.java |   1 -
 .../cluster/routing/IndexRoutingTable.java    |   1 -
 .../cluster/routing/RoutingTable.java         |   1 -
 .../common/io/stream/TryWriteable.java        |   5 -
 .../common/network/NetworkModule.java         |  10 +-
 .../org/opensearch/discovery/PeerFinder.java  |   1 -
 .../index/seqno/RetentionLease.java           |   1 -
 .../index/seqno/RetentionLeaseStats.java      |   1 -
 .../org/opensearch/ingest/IngestService.java  |   1 -
 .../main/java/org/opensearch/node/Node.java   |   1 -
 .../node/ResponseCollectorService.java        |   1 -
 .../org/opensearch/rest/RestController.java   |   8 +-
 .../action/cat/ProtobufRestNodesAction.java   |  30 +-
 .../rest/action/cat/RestNodesAction.java      |   2 +-
 .../support/AggregationUsageService.java      |   1 -
 .../pipeline/SearchPipelineService.java       |   6 +-
 .../snapshots/SnapshotShardsService.java      |   1 -
 .../opensearch/tasks/ProtobufTaskResult.java  |   1 -
 .../org/opensearch/tasks/TaskManager.java     |  51 +--
 .../org/opensearch/threadpool/ThreadPool.java |   1 -
 .../opensearch/transport/InboundHandler.java  |  21 +-
 .../opensearch/transport/InboundPipeline.java |   3 +-
 .../opensearch/transport/OutboundHandler.java |  69 ++++-
 .../opensearch/transport/OutboundMessage.java |   1 -
 .../transport/ProtobufOutboundMessage.java    | 288 +++++++++--------
 .../transport/RemoteConnectionManager.java    |   6 +-
 .../opensearch/transport/TcpTransport.java    |  73 ++---
 .../org/opensearch/transport/Transport.java   | 291 +++++++++---------
 .../transport/TransportInterceptor.java       |  23 +-
 .../transport/TransportMessage.java           |   4 +-
 .../transport/TransportRequest.java           |   5 +-
 .../transport/TransportService.java           |   1 -
 .../cluster/NodeConnectionsServiceTests.java  |  72 -----
 .../coordination/CoordinatorTests.java        |   2 +-
 .../coordination/NoOpClusterApplier.java      |   1 -
 .../cluster/serialization/DiffableTests.java  |   2 +-
 .../common/network/NetworkModuleTests.java    |  11 -
 .../SegmentReplicationIndexShardTests.java    |   2 +-
 ...licationWithNodeToNodeIndexShardTests.java |   2 +-
 .../SegmentReplicationSourceServiceTests.java |   6 +
 .../opensearch/rest/RestControllerTests.java  |  11 -
 .../transport/InboundPipelineTests.java       |  27 +-
 .../transport/OutboundHandlerTests.java       |   4 +-
 .../opensearch/test/MockHttpTransport.java    |   2 +-
 .../test/transport/FakeTransport.java         |   5 +-
 .../test/transport/StubbableTransport.java    |   6 +-
 87 files changed, 695 insertions(+), 715 deletions(-)

diff --git a/libs/core/src/main/java/org/opensearch/core/common/io/stream/ProtobufWriteable.java b/libs/core/src/main/java/org/opensearch/core/common/io/stream/ProtobufWriteable.java
index b3ac65ff76896..e65b7731a2d7e 100644
--- a/libs/core/src/main/java/org/opensearch/core/common/io/stream/ProtobufWriteable.java
+++ b/libs/core/src/main/java/org/opensearch/core/common/io/stream/ProtobufWriteable.java
@@ -6,11 +6,6 @@
 * compatible open source license.
 */
 
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
 package org.opensearch.core.common.io.stream;
 
 import java.io.IOException;
diff --git a/plugins/events-correlation-engine/src/test/java/org/opensearch/plugin/correlation/core/index/mapper/CorrelationVectorFieldMapperTests.java b/plugins/events-correlation-engine/src/test/java/org/opensearch/plugin/correlation/core/index/mapper/CorrelationVectorFieldMapperTests.java
index 19dff08b63d5f..15642ef8a9dca 100644
--- a/plugins/events-correlation-engine/src/test/java/org/opensearch/plugin/correlation/core/index/mapper/CorrelationVectorFieldMapperTests.java
+++ b/plugins/events-correlation-engine/src/test/java/org/opensearch/plugin/correlation/core/index/mapper/CorrelationVectorFieldMapperTests.java
@@ -190,7 +190,7 @@ public void testTypeParser_parse_fromCorrelationParamsContext_InvalidVectorSimil
 
     /**
      * test parseCreateField in CorrelationVectorFieldMapper
-     * @throws IOException
+     * @throws IOException io exception
      */
     public void testCorrelationVectorFieldMapper_parseCreateField() throws IOException {
         String fieldName = "test-field-name";
diff --git a/plugins/events-correlation-engine/src/test/java/org/opensearch/plugin/correlation/core/index/query/CorrelationQueryBuilderTests.java b/plugins/events-correlation-engine/src/test/java/org/opensearch/plugin/correlation/core/index/query/CorrelationQueryBuilderTests.java
index f23a4f25302b1..4143bd64387c5 100644
--- a/plugins/events-correlation-engine/src/test/java/org/opensearch/plugin/correlation/core/index/query/CorrelationQueryBuilderTests.java
+++ b/plugins/events-correlation-engine/src/test/java/org/opensearch/plugin/correlation/core/index/query/CorrelationQueryBuilderTests.java
@@ -203,7 +203,7 @@ public void testDoToQueryInvalidFieldType() {
 
     /**
      * test serialization of Correlation Query Builder
-     * @throws Exception
+     * @throws Exception exception
      */
     public void testSerialization() throws Exception {
         assertSerialization(Optional.empty());
diff --git a/qa/rolling-upgrade/src/test/java/org/opensearch/upgrades/IndexingIT.java b/qa/rolling-upgrade/src/test/java/org/opensearch/upgrades/IndexingIT.java
index a03d299b32274..b60607d3fece7 100644
--- a/qa/rolling-upgrade/src/test/java/org/opensearch/upgrades/IndexingIT.java
+++ b/qa/rolling-upgrade/src/test/java/org/opensearch/upgrades/IndexingIT.java
@@ -248,7 +248,7 @@ public void testIndexing() throws IOException, ParseException {
      * This test verifies that during rolling upgrades the segment replication does not break when replica shards can
      * be running on older codec versions.
      *
-     * @throws Exception
+     * @throws Exception exception
      */
     @AwaitsFix(bugUrl = "https://github.com/opensearch-project/OpenSearch/issues/8322")
     public void testIndexingWithSegRep() throws Exception {
diff --git a/server/build.gradle b/server/build.gradle
index efe2eae553364..e465e9cc4d827 100644
--- a/server/build.gradle
+++ b/server/build.gradle
@@ -395,6 +395,7 @@ tasks.named("licenseHeaders").configure {
     // Ignore for protobuf generated code
     excludes << 'org/opensearch/extensions/proto/*'
     excludes << 'org/opensearch/tasks/proto/*'
+    excludes << 'org/opensearch/server/proto/*'
 }
 
 tasks.test {
diff --git a/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/node/tasks/CancellableTasksIT.java b/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/node/tasks/CancellableTasksIT.java
index 161dee1a96e3c..6e5542c03aebd 100644
--- a/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/node/tasks/CancellableTasksIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/node/tasks/CancellableTasksIT.java
@@ -544,6 +544,12 @@ public String executor() {
                                 public TestResponse read(StreamInput in) throws IOException {
                                     return new TestResponse(in);
                                 }
+
+                                @Override
+                                public TestResponse read(byte[] in) throws IOException {
+                                    // TODO Auto-generated method stub
+                                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                                }
                             }
                         );
                     }
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java b/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
index 8408897d8fc6c..02bfe31f32cbb 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
@@ -24,9 +24,7 @@
 *
 * @opensearch.api
 */
-public class ProtobufActionListenerResponseHandler<Response extends TransportResponse>
-    implements
-        TransportResponseHandler<Response> {
+public class ProtobufActionListenerResponseHandler<Response extends TransportResponse> implements TransportResponseHandler<Response> {
 
     private final ActionListener<? super Response> listener;
     private final ProtobufWriteable.Reader<Response> reader;
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionRequest.java b/server/src/main/java/org/opensearch/action/ProtobufActionRequest.java
index 0bf8fd85268a9..ca20364a58145 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionRequest.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionRequest.java
@@ -6,11 +6,6 @@
 * compatible open source license.
 */
 
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
 package org.opensearch.action;
 
 import org.opensearch.transport.TransportRequest;
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java b/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java
index 324ad41ebdea9..cc8c7faf02654 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java
@@ -6,11 +6,6 @@
 * compatible open source license.
 */
 
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
 package org.opensearch.action;
 
 import org.opensearch.transport.TransportResponse;
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
index b6f7e6212e626..830f4432149fc 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
@@ -6,11 +6,6 @@
 * compatible open source license.
 */
 
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
 package org.opensearch.action.admin.cluster.node.info;
 
 import com.google.protobuf.InvalidProtocolBufferException;
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
index 004847bc8cb25..daa606f29559a 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
@@ -62,7 +62,10 @@ public ProtobufNodesInfoRequest addMetrics(String timeout, String... metrics) {
             String plural = metricsSet.size() == 1 ? "" : "s";
             throw new IllegalStateException("Used illegal metric" + plural + ": " + metricsSet);
         }
-        this.nodesInfoRequest = NodesInfoRequestProto.NodesInfoRequest.newBuilder().addAllRequestedMetrics(metricsSet).setTimeout(DEFAULT_TIMEOUT_SECS.toString()).build();
+        this.nodesInfoRequest = NodesInfoRequestProto.NodesInfoRequest.newBuilder()
+            .addAllRequestedMetrics(metricsSet)
+            .setTimeout(DEFAULT_TIMEOUT_SECS.toString())
+            .build();
         return this;
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
index 99b2869c61e4a..716e74788a2f0 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.action.admin.cluster.node.info;
 
-
 import org.opensearch.action.FailedNodeException;
 import org.opensearch.action.support.nodes.ProtobufBaseNodesResponse;
 import org.opensearch.cluster.ClusterName;
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
index db890313db666..bd91837758a21 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodeStats.java
@@ -98,7 +98,7 @@ public ProtobufNodeStats(
             .setHitCount(indices.getRequestCache().getHitCount())
             .setMissCount(indices.getRequestCache().getMissCount())
             .build();
-         NodesStatsProto.NodesStats.FlushStats flushStats = NodesStatsProto.NodesStats.FlushStats.newBuilder()
+        NodesStatsProto.NodesStats.FlushStats flushStats = NodesStatsProto.NodesStats.FlushStats.newBuilder()
             .setTotal(indices.getFlush().getTotal())
             .setPeriodic(indices.getFlush().getPeriodic())
             .setTotalTimeInMillis(indices.getFlush().getTotalTimeInMillis())
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
index 6591b872f6822..1e2f2f22731df 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/ProtobufNodesStatsRequest.java
@@ -11,7 +11,6 @@
 import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
 import org.opensearch.action.support.nodes.ProtobufBaseNodesRequest;
 import org.opensearch.server.proto.NodesStatsRequestProto.NodesStatsRequest;
-import org.opensearch.server.proto.NodesInfoRequestProto;
 import org.opensearch.server.proto.NodesStatsRequestProto;
 
 import java.io.IOException;
@@ -147,7 +146,7 @@ public ProtobufNodesStatsRequest(byte[] data) throws IOException {
         this.nodesStatsRequest = NodesStatsRequestProto.NodesStatsRequest.parseFrom(data);
     }
 
-     public ProtobufNodesStatsRequest(NodesStatsRequestProto.NodesStatsRequest nodesStatsRequest) throws IOException {
+    public ProtobufNodesStatsRequest(NodesStatsRequestProto.NodesStatsRequest nodesStatsRequest) throws IOException {
         super(nodesStatsRequest.toByteArray());
         this.nodesStatsRequest = nodesStatsRequest;
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
index e446b7fd7ce5b..59784af00a70b 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
@@ -6,11 +6,6 @@
 * compatible open source license.
 */
 
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
 package org.opensearch.action.admin.cluster.state;
 
 import org.opensearch.action.ActionRequestValidationException;
@@ -39,47 +34,58 @@ public class ProtobufClusterStateRequest extends ProtobufClusterManagerNodeReadR
     public static final TimeValue DEFAULT_WAIT_FOR_NODE_TIMEOUT = TimeValue.timeValueMinutes(1);
     private ClusterStateRequestProto.ClusterStateRequest clusterStateRequest;
 
-    public ProtobufClusterStateRequest () {}
-
-    public ProtobufClusterStateRequest(boolean routingTable, boolean nodes, boolean metadata, boolean blocks,
-                                        boolean customs, long waitForMetadataVersion, TimeValue waitForTimeout, List<String> indices) {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setRoutingTable(routingTable)
-                                        .setNodes(nodes)
-                                        .setMetadata(metadata)
-                                        .setBlocks(blocks)
-                                        .setCustoms(customs)
-                                        .setWaitForMetadataVersion(waitForMetadataVersion)
-                                        .setWaitForTimeout(waitForTimeout.toString())
-                                        .addAllIndices(indices)
-                                        .build();               
-    }
-    
+    public ProtobufClusterStateRequest() {}
+
+    public ProtobufClusterStateRequest(
+        boolean routingTable,
+        boolean nodes,
+        boolean metadata,
+        boolean blocks,
+        boolean customs,
+        long waitForMetadataVersion,
+        TimeValue waitForTimeout,
+        List<String> indices
+    ) {
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder()
+            .setRoutingTable(routingTable)
+            .setNodes(nodes)
+            .setMetadata(metadata)
+            .setBlocks(blocks)
+            .setCustoms(customs)
+            .setWaitForMetadataVersion(waitForMetadataVersion)
+            .setWaitForTimeout(waitForTimeout.toString())
+            .addAllIndices(indices)
+            .build();
+    }
+
     @Override
     public ActionRequestValidationException validate() {
         return null;
     }
 
     public ProtobufClusterStateRequest all() {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setRoutingTable(true)
-                                        .setNodes(true)
-                                        .setMetadata(true)
-                                        .setBlocks(true)
-                                        .setCustoms(true)
-                                        .addAllIndices(Arrays.asList(Strings.EMPTY_ARRAY))
-                                        .setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString())
-                                        .build();
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder()
+            .setRoutingTable(true)
+            .setNodes(true)
+            .setMetadata(true)
+            .setBlocks(true)
+            .setCustoms(true)
+            .addAllIndices(Arrays.asList(Strings.EMPTY_ARRAY))
+            .setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString())
+            .build();
         return this;
     }
 
     public ProtobufClusterStateRequest clear() {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setRoutingTable(false)
-                                        .setNodes(false)
-                                        .setMetadata(false)
-                                        .setBlocks(false)
-                                        .setCustoms(false)
-                                        .addAllIndices(Arrays.asList(Strings.EMPTY_ARRAY))
-                                        .setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString())
-                                        .build();
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder()
+            .setRoutingTable(false)
+            .setNodes(false)
+            .setMetadata(false)
+            .setBlocks(false)
+            .setCustoms(false)
+            .addAllIndices(Arrays.asList(Strings.EMPTY_ARRAY))
+            .setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString())
+            .build();
         return this;
     }
 
@@ -88,7 +94,10 @@ public boolean routingTable() {
     }
 
     public ProtobufClusterStateRequest routingTable(boolean routingTable) {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setRoutingTable(routingTable).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder()
+            .setRoutingTable(routingTable)
+            .setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString())
+            .build();
         return this;
     }
 
@@ -97,7 +106,10 @@ public boolean nodes() {
     }
 
     public ProtobufClusterStateRequest nodes(boolean nodes) {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setNodes(nodes).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder()
+            .setNodes(nodes)
+            .setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString())
+            .build();
         return this;
     }
 
@@ -106,7 +118,10 @@ public boolean metadata() {
     }
 
     public ProtobufClusterStateRequest metadata(boolean metadata) {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setMetadata(metadata).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder()
+            .setMetadata(metadata)
+            .setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString())
+            .build();
         return this;
     }
 
@@ -115,7 +130,10 @@ public boolean blocks() {
     }
 
     public ProtobufClusterStateRequest blocks(boolean blocks) {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).setBlocks(blocks).build();
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder()
+            .setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString())
+            .setBlocks(blocks)
+            .build();
         return this;
     }
 
@@ -126,18 +144,21 @@ public String[] indices() {
 
     @Override
     public ProtobufClusterStateRequest indices(String... indices) {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().addAllIndices(Arrays.asList(indices)).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder()
+            .addAllIndices(Arrays.asList(indices))
+            .setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString())
+            .build();
         return this;
     }
 
     // @Override
     // public IndicesOptions indicesOptions() {
-    //     return this.clusterStateRequest.;
+    // return this.clusterStateRequest.;
     // }
 
     // public final ProtobufClusterStateRequest indicesOptions(IndicesOptions indicesOptions) {
-    //     this.indicesOptions = indicesOptions;
-    //     return this;
+    // this.indicesOptions = indicesOptions;
+    // return this;
     // }
 
     @Override
@@ -146,7 +167,10 @@ public boolean includeDataStreams() {
     }
 
     public ProtobufClusterStateRequest customs(boolean customs) {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setCustoms(customs).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder()
+            .setCustoms(customs)
+            .setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString())
+            .build();
         return this;
     }
 
@@ -162,7 +186,10 @@ public TimeValue waitForTimeout() {
     }
 
     public ProtobufClusterStateRequest waitForTimeout(TimeValue waitForTimeout) {
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setWaitForTimeout(waitForTimeout.toString()).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder()
+            .setWaitForTimeout(waitForTimeout.toString())
+            .setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString())
+            .build();
         return this;
     }
 
@@ -176,7 +203,10 @@ public ProtobufClusterStateRequest waitForMetadataVersion(long waitForMetadataVe
                 "provided waitForMetadataVersion should be >= 1, but instead is [" + waitForMetadataVersion + "]"
             );
         }
-        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder().setWaitForMetadataVersion(waitForMetadataVersion).setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString()).build();
+        this.clusterStateRequest = ClusterStateRequestProto.ClusterStateRequest.newBuilder()
+            .setWaitForMetadataVersion(waitForMetadataVersion)
+            .setWaitForTimeout(DEFAULT_WAIT_FOR_NODE_TIMEOUT.toString())
+            .build();
         return this;
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
index 56b1fd308b358..15c39de1c049a 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateResponse.java
@@ -6,32 +6,18 @@
 * compatible open source license.
 */
 
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
 package org.opensearch.action.admin.cluster.state;
 
 import org.opensearch.action.ProtobufActionResponse;
-import org.opensearch.cluster.ClusterState;
-import org.opensearch.cluster.metadata.AliasMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
-import org.opensearch.cluster.routing.RoutingNode;
-import org.opensearch.cluster.ClusterName;
 import org.opensearch.server.proto.ClusterStateResponseProto;
 import org.opensearch.server.proto.ClusterStateResponseProto.ClusterStateResponse;
 
 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
-import java.util.Set;
 
 /**
  * The response for getting the cluster state.
@@ -43,20 +29,25 @@ public class ProtobufClusterStateResponse extends ProtobufActionResponse {
     private ClusterStateResponseProto.ClusterStateResponse clusterStateRes;
 
     public ProtobufClusterStateResponse(String clusterName, DiscoveryNodes nodes, long version, String stateUUID, boolean waitForTimedOut) {
-        ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Builder discoveryNodesBuilder = ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.newBuilder();
+        ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Builder discoveryNodesBuilder =
+            ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.newBuilder();
 
         List<ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node> allNodes = convertNodes(nodes);
-        discoveryNodesBuilder.addAllAllNodes(allNodes).setClusterManagerNodeId(nodes.getClusterManagerNodeId()).setLocalNodeId(nodes.getLocalNodeId()).setMinNonClientNodeVersion(nodes.getSmallestNonClientNodeVersion().toString()).setMaxNonClientNodeVersion(nodes.getLargestNonClientNodeVersion().toString()).setMinNodeVersion(nodes.getMinNodeVersion().toString()).setMaxNodeVersion(nodes.getMaxNodeVersion().toString());
-        ClusterStateResponseProto.ClusterStateResponse.ClusterState.Builder clusterStateBuilder = ClusterStateResponseProto.ClusterStateResponse.ClusterState.newBuilder();
-        clusterStateBuilder.setClusterName(clusterName)
-            .setVersion(version)
-            .setStateUUID(stateUUID)
-            .setNodes(discoveryNodesBuilder.build());
+        discoveryNodesBuilder.addAllAllNodes(allNodes)
+            .setClusterManagerNodeId(nodes.getClusterManagerNodeId())
+            .setLocalNodeId(nodes.getLocalNodeId())
+            .setMinNonClientNodeVersion(nodes.getSmallestNonClientNodeVersion().toString())
+            .setMaxNonClientNodeVersion(nodes.getLargestNonClientNodeVersion().toString())
+            .setMinNodeVersion(nodes.getMinNodeVersion().toString())
+            .setMaxNodeVersion(nodes.getMaxNodeVersion().toString());
+        ClusterStateResponseProto.ClusterStateResponse.ClusterState.Builder clusterStateBuilder =
+            ClusterStateResponseProto.ClusterStateResponse.ClusterState.newBuilder();
+        clusterStateBuilder.setClusterName(clusterName).setVersion(version).setStateUUID(stateUUID).setNodes(discoveryNodesBuilder.build());
         this.clusterStateRes = ClusterStateResponseProto.ClusterStateResponse.newBuilder()
-                                            .setClusterName(clusterName)
-                                            .setClusterState(clusterStateBuilder.build())
-                                            .setWaitForTimedOut(waitForTimedOut)
-                                            .build();
+            .setClusterName(clusterName)
+            .setClusterState(clusterStateBuilder.build())
+            .setWaitForTimedOut(waitForTimedOut)
+            .build();
     }
 
     private List<ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node> convertNodes(DiscoveryNodes nodes) {
@@ -67,13 +58,28 @@ private List<ClusterStateResponseProto.ClusterStateResponse.ClusterState.Discove
         for (DiscoveryNode node : nodes.getNodes().values()) {
             List<ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole> nodeRoles = new ArrayList<>();
             node.getRoles().forEach(role -> {
-                ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole.Builder nodeRoleBuilder = ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole.newBuilder();
-                nodeRoleBuilder.setIsKnownRole(role.isKnownRole()).setIsDynamicRole(role.isDynamicRole()).setRoleName(role.roleName()).setRoleNameAbbreviation(role.roleNameAbbreviation()).setCanContainData(role.canContainData()).build();
+                ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole.Builder nodeRoleBuilder =
+                    ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole.newBuilder();
+                nodeRoleBuilder.setIsKnownRole(role.isKnownRole())
+                    .setIsDynamicRole(role.isDynamicRole())
+                    .setRoleName(role.roleName())
+                    .setRoleNameAbbreviation(role.roleNameAbbreviation())
+                    .setCanContainData(role.canContainData())
+                    .build();
                 nodeRoles.add(nodeRoleBuilder.build());
             });
-            ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.Builder nodeBuilder = ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.newBuilder();
-            nodeBuilder.setNodeName(node.getName()).setNodeId(node.getId()).setEphemeralId(node.getEphemeralId()).setHostName(node.getHostName())
-            .setHostAddress(node.getHostAddress()).setTransportAddress(node.getAddress().toString()).putAllAttributes(node.getAttributes()).addAllRoles(nodeRoles).setVersion(node.getVersion().toString()).build();
+            ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.Builder nodeBuilder =
+                ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.newBuilder();
+            nodeBuilder.setNodeName(node.getName())
+                .setNodeId(node.getId())
+                .setEphemeralId(node.getEphemeralId())
+                .setHostName(node.getHostName())
+                .setHostAddress(node.getHostAddress())
+                .setTransportAddress(node.getAddress().toString())
+                .putAllAttributes(node.getAttributes())
+                .addAllRoles(nodeRoles)
+                .setVersion(node.getVersion().toString())
+                .build();
             convertedNodes.add(nodeBuilder.build());
         }
         return convertedNodes;
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
index 19e182c504002..a9de5245cc2d0 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufTransportClusterStateAction.java
@@ -17,11 +17,7 @@
 import org.opensearch.cluster.ClusterStateObserver;
 import org.opensearch.cluster.NotClusterManagerException;
 import org.opensearch.cluster.block.ClusterBlockException;
-import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
-import org.opensearch.cluster.metadata.Metadata;
-import org.opensearch.cluster.metadata.Metadata.Custom;
-import org.opensearch.cluster.routing.RoutingTable;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.inject.Inject;
 import org.opensearch.common.unit.TimeValue;
@@ -31,7 +27,6 @@
 
 import java.io.IOException;
 import java.util.function.Predicate;
-import java.util.Map;
 
 /**
  * Transport action for obtaining cluster state
@@ -139,7 +134,13 @@ public void onTimeout(TimeValue timeout) {
 
     private ProtobufClusterStateResponse buildResponse(final ProtobufClusterStateRequest request, final ClusterState currentState) {
         logger.trace("Serving cluster state request using version {}", currentState.version());
-        return new ProtobufClusterStateResponse(currentState.getClusterName().value(), currentState.nodes(), currentState.version(), currentState.stateUUID(), false);
+        return new ProtobufClusterStateResponse(
+            currentState.getClusterName().value(),
+            currentState.nodes(),
+            currentState.version(),
+            currentState.stateUUID(),
+            false
+        );
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java b/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java
index 954092219e95a..1d6fd70e691c6 100644
--- a/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java
+++ b/server/src/main/java/org/opensearch/action/fieldcaps/TransportFieldCapabilitiesIndexAction.java
@@ -75,7 +75,6 @@
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
-
 import java.io.IOException;
 import java.util.Collections;
 import java.util.HashMap;
diff --git a/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java b/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java
index aae1d9fe398db..27f2a00864dc8 100644
--- a/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java
+++ b/server/src/main/java/org/opensearch/action/main/ProtobufMainResponse.java
@@ -72,7 +72,7 @@ public Build getBuild() {
 
     @Override
     public void writeTo(OutputStream out) throws IOException {
-        
+
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/action/search/PitService.java b/server/src/main/java/org/opensearch/action/search/PitService.java
index 8550c2b3be829..5066bb768da30 100644
--- a/server/src/main/java/org/opensearch/action/search/PitService.java
+++ b/server/src/main/java/org/opensearch/action/search/PitService.java
@@ -8,7 +8,6 @@
 
 package org.opensearch.action.search;
 
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java b/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
index 9b0bd19d353eb..5c7007bd8b05d 100644
--- a/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufHandledTransportAction.java
@@ -12,11 +12,9 @@
 import org.opensearch.action.ProtobufActionResponse;
 import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.tasks.ProtobufTask;
-import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ProtobufTransportRequestHandler;
 import org.opensearch.transport.TransportChannel;
-import org.opensearch.transport.TransportRequestHandler;
 import org.opensearch.transport.TransportService;
 
 /**
@@ -65,7 +63,14 @@ protected ProtobufHandledTransportAction(
         String executor
     ) {
         super(actionName, actionFilters, transportService.getTaskManager());
-        transportService.registerRequestHandlerProtobuf(actionName, executor, false, canTripCircuitBreaker, requestReader, new TransportHandler());
+        transportService.registerRequestHandlerProtobuf(
+            actionName,
+            executor,
+            false,
+            canTripCircuitBreaker,
+            requestReader,
+            new TransportHandler()
+        );
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java b/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
index 0656b841133d9..754194734bc52 100644
--- a/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
@@ -395,8 +395,8 @@ public String executor() {
                         }
 
                         @Override
-                        public TransportBroadcastByNodeAction<Request, Response, ShardOperationResult>.NodeResponse read(
-                                byte[] in) throws IOException {
+                        public TransportBroadcastByNodeAction<Request, Response, ShardOperationResult>.NodeResponse read(byte[] in)
+                            throws IOException {
                             // TODO Auto-generated method stub
                             throw new UnsupportedOperationException("Unimplemented method 'read'");
                         }
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadRequest.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadRequest.java
index d098b4c575bdc..8da301b87716c 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadRequest.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadRequest.java
@@ -6,11 +6,6 @@
 * compatible open source license.
 */
 
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
 package org.opensearch.action.support.clustermanager;
 
 import java.io.IOException;
@@ -29,12 +24,12 @@ public abstract class ProtobufClusterManagerNodeReadRequest<Request extends Prot
     protected ProtobufClusterManagerNodeReadRequest() {}
 
     protected ProtobufClusterManagerNodeReadRequest(byte[] in) throws IOException {
-        
+
     }
 
     @Override
     public void writeTo(OutputStream out) throws IOException {
-        
+
     }
 
     @SuppressWarnings("unchecked")
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeRequest.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeRequest.java
index ad436e2ac62c9..6b6704d36ecc6 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeRequest.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeRequest.java
@@ -6,11 +6,6 @@
 * compatible open source license.
 */
 
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
 package org.opensearch.action.support.clustermanager;
 
 import org.opensearch.action.ProtobufActionRequest;
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
index 672dc27ee1da7..93ef1c8f2cbe5 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufTransportClusterManagerNodeAction.java
@@ -107,8 +107,7 @@ protected void masterOperation(Request request, ClusterState state, ActionListen
     }
 
     // TODO: Add abstract keyword after removing the deprecated masterOperation()
-    protected void clusterManagerOperation(Request request, ClusterState state, ActionListener<Response> listener)
-        throws Exception {
+    protected void clusterManagerOperation(Request request, ClusterState state, ActionListener<Response> listener) throws Exception {
         masterOperation(request, state, listener);
     }
 
@@ -126,12 +125,8 @@ protected void masterOperation(ProtobufTask task, Request request, ClusterState
      * Override this operation if access to the task parameter is needed
      */
     // TODO: Change the implementation to call 'clusterManagerOperation(request...)' after removing the deprecated masterOperation()
-    protected void clusterManagerOperation(
-        ProtobufTask task,
-        Request request,
-        ClusterState state,
-        ActionListener<Response> listener
-    ) throws Exception {
+    protected void clusterManagerOperation(ProtobufTask task, Request request, ClusterState state, ActionListener<Response> listener)
+        throws Exception {
         masterOperation(task, request, state, listener);
     }
 
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
index 87e46e8897914..da52d2828edf4 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
@@ -6,11 +6,6 @@
 * compatible open source license.
 */
 
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
 package org.opensearch.action.support.nodes;
 
 import org.opensearch.cluster.node.DiscoveryNode;
@@ -26,7 +21,7 @@ public abstract class ProtobufBaseNodeResponse extends TransportResponse {
     private DiscoveryNode node;
 
     protected ProtobufBaseNodeResponse(byte[] data) {
-        
+
     }
 
     protected ProtobufBaseNodeResponse(DiscoveryNode node) {
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
index 12828aa0288ea..861315f599ade 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesRequest.java
@@ -6,11 +6,6 @@
 * compatible open source license.
 */
 
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
 package org.opensearch.action.support.nodes;
 
 import org.opensearch.action.ActionRequestValidationException;
@@ -48,8 +43,7 @@ public abstract class ProtobufBaseNodesRequest<Request extends ProtobufBaseNodes
 
     private TimeValue timeout;
 
-    protected ProtobufBaseNodesRequest(byte[] data) throws IOException {
-    }
+    protected ProtobufBaseNodesRequest(byte[] data) throws IOException {}
 
     protected ProtobufBaseNodesRequest(String... nodesIds) {
         this.nodesIds = nodesIds;
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java
index 29ead82d728e2..798f06bf5ce75 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodesResponse.java
@@ -6,11 +6,6 @@
 * compatible open source license.
 */
 
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
 package org.opensearch.action.support.nodes;
 
 import org.opensearch.action.FailedNodeException;
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
index 0d9665e765c8f..1ab16a429f205 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufTransportNodesAction.java
@@ -164,11 +164,7 @@ protected NodesResponse newResponse(NodesRequest request, AtomicReferenceArray<?
     * @return Never {@code null}.
     * @throws NullPointerException if any parameter is {@code null}.
     */
-    protected abstract NodesResponse newResponse(
-        NodesRequest request,
-        List<NodeResponse> responses,
-        List<FailedNodeException> failures
-    );
+    protected abstract NodesResponse newResponse(NodesRequest request, List<NodeResponse> responses, List<FailedNodeException> failures);
 
     protected abstract NodeRequest newNodeRequest(NodesRequest request);
 
diff --git a/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java b/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java
index 81f6f276483f5..757017e52b61e 100644
--- a/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java
+++ b/server/src/main/java/org/opensearch/action/support/single/shard/TransportSingleShardAction.java
@@ -232,7 +232,6 @@ public Response read(byte[] in) throws IOException {
                             throw new UnsupportedOperationException("Unimplemented method 'read'");
                         }
 
-                        
                     }
                 );
             } else {
diff --git a/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java b/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java
index 7a94b5cfc29f7..ec1a9c64eadec 100644
--- a/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java
+++ b/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java
@@ -318,8 +318,9 @@ public String executor() {
                                     }
 
                                     @Override
-                                    public TransportTasksAction<OperationTask, TasksRequest, TasksResponse, TaskResponse>.NodeTasksResponse read(
-                                            byte[] in) throws IOException {
+                                    public
+                                        TransportTasksAction<OperationTask, TasksRequest, TasksResponse, TaskResponse>.NodeTasksResponse
+                                        read(byte[] in) throws IOException {
                                         // TODO Auto-generated method stub
                                         throw new UnsupportedOperationException("Unimplemented method 'read'");
                                     }
diff --git a/server/src/main/java/org/opensearch/client/ProtobufClient.java b/server/src/main/java/org/opensearch/client/ProtobufClient.java
index c1d5970908243..2b75e919e11d5 100644
--- a/server/src/main/java/org/opensearch/client/ProtobufClient.java
+++ b/server/src/main/java/org/opensearch/client/ProtobufClient.java
@@ -14,8 +14,6 @@
 import org.opensearch.common.settings.Setting.Property;
 import org.opensearch.common.settings.Settings;
 
-import java.util.Map;
-
 /**
  * A client provides a one stop interface for performing actions/operations against the cluster.
 * <p>
diff --git a/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java b/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
index 740b28d6a894c..f1494c46fd7de 100644
--- a/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
+++ b/server/src/main/java/org/opensearch/client/support/ProtobufAbstractClient.java
@@ -32,7 +32,6 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.threadpool.ThreadPool;
 
-
 /**
  * Base client used to create concrete client implementations
 *
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterModule.java b/server/src/main/java/org/opensearch/cluster/ClusterModule.java
index eede99d26cb5a..bd34d75c30c84 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterModule.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterModule.java
@@ -345,7 +345,7 @@ public IndexNameExpressionResolver getIndexNameExpressionResolver() {
     }
 
     // public ProtobufIndexNameExpressionResolver getProtobufIndexNameExpressionResolver() {
-    //     return protobufIndexNameExpressionResolver;
+    // return protobufIndexNameExpressionResolver;
     // }
 
     // TODO: this is public so allocation benchmark can access the default deciders...can we do that in another way?
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterName.java b/server/src/main/java/org/opensearch/cluster/ClusterName.java
index 4edea6b2984ef..440fde284afb8 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterName.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterName.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.cluster;
 
-import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterState.java b/server/src/main/java/org/opensearch/cluster/ClusterState.java
index 91d72af44c7bd..bf4d7977222ab 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterState.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterState.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.cluster;
 
-
 import org.opensearch.cluster.block.ClusterBlock;
 import org.opensearch.cluster.block.ClusterBlocks;
 import org.opensearch.cluster.coordination.CoordinationMetadata;
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufDiff.java b/server/src/main/java/org/opensearch/cluster/ProtobufDiff.java
index a187610856107..0ac12cb4718c0 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufDiff.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufDiff.java
@@ -6,11 +6,6 @@
 * compatible open source license.
 */
 
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
 package org.opensearch.cluster;
 
 import org.opensearch.core.common.io.stream.ProtobufWriteable;
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java b/server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java
index 140ec4bc74d3b..26c9987871240 100644
--- a/server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java
+++ b/server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java
@@ -6,11 +6,6 @@
 * compatible open source license.
 */
 
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
 package org.opensearch.cluster;
 
 import org.opensearch.core.common.io.stream.ProtobufWriteable;
diff --git a/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java b/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java
index d2eb0aa6f6a6a..40ce43b748cc9 100644
--- a/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java
+++ b/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.cluster.block;
 
-
 import org.opensearch.cluster.AbstractDiffable;
 import org.opensearch.cluster.Diff;
 import org.opensearch.cluster.metadata.IndexMetadata;
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
index 4f214021abeb1..37240141705a6 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
@@ -612,7 +612,6 @@ private void handleJoinRequest(JoinRequest joinRequest, JoinHelper.JoinCallback
             }
         }, joinCallback::onFailure));
 
-        
     }
 
     // package private for tests
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java b/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java
index 3e3d5fd458a27..e430ba5465499 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java
@@ -31,7 +31,6 @@
 
 package org.opensearch.cluster.metadata;
 
-
 import org.opensearch.OpenSearchParseException;
 import org.opensearch.cluster.AbstractDiffable;
 import org.opensearch.cluster.Diff;
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java b/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java
index 47fa1c6399ef1..3e36a5e65bf07 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.cluster.metadata;
 
-
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.LogManager;
 import org.apache.lucene.util.CollectionUtil;
diff --git a/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java b/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java
index b9077465a7504..781ca5bb2255a 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.cluster.routing;
 
-
 import org.apache.lucene.util.CollectionUtil;
 import org.opensearch.cluster.AbstractDiffable;
 import org.opensearch.cluster.Diff;
diff --git a/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java b/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java
index 1e91dafe0ede3..d6a67bc714689 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.cluster.routing;
 
-
 import org.opensearch.cluster.Diff;
 import org.opensearch.cluster.Diffable;
 import org.opensearch.cluster.DiffableUtils;
diff --git a/server/src/main/java/org/opensearch/common/io/stream/TryWriteable.java b/server/src/main/java/org/opensearch/common/io/stream/TryWriteable.java
index 16ff465335d24..3a4ab6974db0d 100644
--- a/server/src/main/java/org/opensearch/common/io/stream/TryWriteable.java
+++ b/server/src/main/java/org/opensearch/common/io/stream/TryWriteable.java
@@ -6,11 +6,6 @@
 * compatible open source license.
 */
 
-/*
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
-*/
-
 package org.opensearch.common.io.stream;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/common/network/NetworkModule.java b/server/src/main/java/org/opensearch/common/network/NetworkModule.java
index c6445853de068..2f4e8799d239d 100644
--- a/server/src/main/java/org/opensearch/common/network/NetworkModule.java
+++ b/server/src/main/java/org/opensearch/common/network/NetworkModule.java
@@ -322,15 +322,15 @@ public AsyncSender interceptSender(AsyncSender sender) {
     // * Registers a new {@link TransportInterceptor}
     // */
     // private void registerTransportInterceptor(TransportInterceptor interceptor) {
-    //     this.TransportInterceptors.add(Objects.requireNonNull(interceptor, "interceptor must not be null"));
+    // this.TransportInterceptors.add(Objects.requireNonNull(interceptor, "interceptor must not be null"));
     // }
 
     // /**
-    //  * Returns a composite {@link TransportInterceptor} containing all registered interceptors
-    //  * @see #registerTransportInterceptor(TransportInterceptor)
-    //  */
+    // * Returns a composite {@link TransportInterceptor} containing all registered interceptors
+    // * @see #registerTransportInterceptor(TransportInterceptor)
+    // */
     // public TransportInterceptor getTransportInterceptor() {
-    //     return new ProtobufCompositeTransportInterceptor(this.TransportInterceptors);
+    // return new ProtobufCompositeTransportInterceptor(this.TransportInterceptors);
     // }
 
     static final class ProtobufCompositeTransportInterceptor implements TransportInterceptor {
diff --git a/server/src/main/java/org/opensearch/discovery/PeerFinder.java b/server/src/main/java/org/opensearch/discovery/PeerFinder.java
index 87613624a360c..bea31a03bba1a 100644
--- a/server/src/main/java/org/opensearch/discovery/PeerFinder.java
+++ b/server/src/main/java/org/opensearch/discovery/PeerFinder.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.discovery;
 
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java
index 8c97d3999e94a..620e7dc70c66b 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java
@@ -33,7 +33,6 @@
 package org.opensearch.index.seqno;
 
 import org.opensearch.core.ParseField;
-import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java
index 9f38321245d5b..bf5f3a7943b00 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.index.seqno;
 
-import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
diff --git a/server/src/main/java/org/opensearch/ingest/IngestService.java b/server/src/main/java/org/opensearch/ingest/IngestService.java
index 117bb0dd75bc6..52ced9c051d14 100644
--- a/server/src/main/java/org/opensearch/ingest/IngestService.java
+++ b/server/src/main/java/org/opensearch/ingest/IngestService.java
@@ -71,7 +71,6 @@
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.VersionType;
 import org.opensearch.index.analysis.AnalysisRegistry;
-import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.node.ReportingService;
 import org.opensearch.plugins.IngestPlugin;
 import org.opensearch.script.ScriptService;
diff --git a/server/src/main/java/org/opensearch/node/Node.java b/server/src/main/java/org/opensearch/node/Node.java
index 14da625deaa50..afb0daf14a591 100644
--- a/server/src/main/java/org/opensearch/node/Node.java
+++ b/server/src/main/java/org/opensearch/node/Node.java
@@ -223,7 +223,6 @@
 import org.opensearch.snapshots.SnapshotShardsService;
 import org.opensearch.snapshots.SnapshotsInfoService;
 import org.opensearch.snapshots.SnapshotsService;
-import org.opensearch.tasks.ProtobufTaskCancellationService;
 import org.opensearch.tasks.Task;
 import org.opensearch.tasks.TaskCancellationService;
 import org.opensearch.tasks.TaskResultsService;
diff --git a/server/src/main/java/org/opensearch/node/ResponseCollectorService.java b/server/src/main/java/org/opensearch/node/ResponseCollectorService.java
index a1fb3086d5609..011f74d8a96e5 100644
--- a/server/src/main/java/org/opensearch/node/ResponseCollectorService.java
+++ b/server/src/main/java/org/opensearch/node/ResponseCollectorService.java
@@ -13,7 +13,6 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.ExponentiallyWeightedMovingAverage;
-import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
diff --git a/server/src/main/java/org/opensearch/rest/RestController.java b/server/src/main/java/org/opensearch/rest/RestController.java
index 10f711df07a07..9d76594591655 100644
--- a/server/src/main/java/org/opensearch/rest/RestController.java
+++ b/server/src/main/java/org/opensearch/rest/RestController.java
@@ -534,11 +534,11 @@ private void tryAllHandlers(final RestRequest request, final RestChannel channel
                     if (rawPath.contains("protobuf")) {
                         dispatchProtobufRequest(request, channel, protobufHandler);
                     } else {
-                    if (FeatureFlags.isEnabled(FeatureFlags.IDENTITY)) {
-                        if (!handleAuthenticateUser(request, channel)) {
-                            return;
+                        if (FeatureFlags.isEnabled(FeatureFlags.IDENTITY)) {
+                            if (!handleAuthenticateUser(request, channel)) {
+                                return;
+                            }
                         }
-                    }
                         dispatchRequest(request, channel, handler);
                     }
                     return;
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
index dfea494505866..25d9ccdeeb882 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
@@ -90,12 +90,12 @@ public RestChannelConsumer doCatRequest(final RestRequest request, final Protobu
                 public void processResponse(final ProtobufClusterStateResponse clusterStateResponse) {
                     ProtobufNodesInfoRequest nodesInfoRequest = new ProtobufNodesInfoRequest();
                     nodesInfoRequest.addMetrics(
-                            request.param("timeout"),
-                            ProtobufNodesInfoRequest.Metric.JVM.metricName(),
-                            ProtobufNodesInfoRequest.Metric.OS.metricName(),
-                            ProtobufNodesInfoRequest.Metric.PROCESS.metricName(),
-                            ProtobufNodesInfoRequest.Metric.HTTP.metricName()
-                        );
+                        request.param("timeout"),
+                        ProtobufNodesInfoRequest.Metric.JVM.metricName(),
+                        ProtobufNodesInfoRequest.Metric.OS.metricName(),
+                        ProtobufNodesInfoRequest.Metric.PROCESS.metricName(),
+                        ProtobufNodesInfoRequest.Metric.HTTP.metricName()
+                    );
                     client.admin().cluster().nodesInfo(nodesInfoRequest, new RestActionListener<ProtobufNodesInfoResponse>(channel) {
                         @Override
                         public void processResponse(final ProtobufNodesInfoResponse nodesInfoResponse) {
@@ -345,7 +345,7 @@ Table buildTable(
             ByteSizeValue diskUsed = new ByteSizeValue(diskTotal.getBytes() - diskAvailable.getBytes());
             double diskUsedRatio = diskTotal.getBytes() == 0 ? 1.0 : (double) diskUsed.getBytes() / diskTotal.getBytes();
             String diskUsedPercent = String.format(Locale.ROOT, "%.2f", 100.0 * diskUsedRatio);
-            
+
             table.addCell(diskTotal);
             table.addCell(diskUsed);
             table.addCell(diskAvailable);
@@ -386,14 +386,24 @@ Table buildTable(
                 roles = "-";
                 allRoles = "-";
             } else {
-                List<ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole> knownNodeRoles = node.getRolesList()
+                List<ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole> knownNodeRoles = node
+                    .getRolesList()
                     .stream()
                     .filter(ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole::getIsKnownRole)
                     .collect(Collectors.toList());
                 roles = knownNodeRoles.size() > 0
-                    ? knownNodeRoles.stream().map(ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole::getRoleNameAbbreviation).sorted().collect(Collectors.joining())
+                    ? knownNodeRoles.stream()
+                        .map(
+                            ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole::getRoleNameAbbreviation
+                        )
+                        .sorted()
+                        .collect(Collectors.joining())
                     : "-";
-                allRoles = node.getRolesList().stream().map(ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole::getRoleName).sorted().collect(Collectors.joining(","));
+                allRoles = node.getRolesList()
+                    .stream()
+                    .map(ClusterStateResponseProto.ClusterStateResponse.ClusterState.DiscoveryNodes.Node.NodeRole::getRoleName)
+                    .sorted()
+                    .collect(Collectors.joining(","));
             }
             table.addCell(roles);
             table.addCell(allRoles);
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
index 2cabe1e649d70..88ae0dd74c087 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
@@ -357,7 +357,7 @@ Table buildTable(
         DiscoveryNodes nodes = state.getState().nodes();
         String clusterManagerId = nodes.getClusterManagerNodeId();
         Table table = getTableWithHeader(req);
-        
+
         for (DiscoveryNode node : nodes) {
             NodeInfo info = nodesInfo.getNodesMap().get(node.getId());
             NodeStats stats = nodesStats.getNodesMap().get(node.getId());
diff --git a/server/src/main/java/org/opensearch/search/aggregations/support/AggregationUsageService.java b/server/src/main/java/org/opensearch/search/aggregations/support/AggregationUsageService.java
index 24a9701161741..6124b3306954c 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/support/AggregationUsageService.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/support/AggregationUsageService.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.search.aggregations.support;
 
-import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.node.ReportingService;
 
 import java.util.HashMap;
diff --git a/server/src/main/java/org/opensearch/search/pipeline/SearchPipelineService.java b/server/src/main/java/org/opensearch/search/pipeline/SearchPipelineService.java
index ed4350d69ddcf..1066d836e5183 100644
--- a/server/src/main/java/org/opensearch/search/pipeline/SearchPipelineService.java
+++ b/server/src/main/java/org/opensearch/search/pipeline/SearchPipelineService.java
@@ -41,7 +41,6 @@
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.analysis.AnalysisRegistry;
 import org.opensearch.ingest.ConfigurationUtils;
-import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.node.ReportingService;
 import org.opensearch.plugins.SearchPipelinePlugin;
 import org.opensearch.script.ScriptService;
@@ -64,10 +63,7 @@
  * The main entry point for search pipelines. Handles CRUD operations and exposes the API to execute search pipelines
  * against requests and responses.
  */
-public class SearchPipelineService
-    implements
-        ClusterStateApplier,
-        ReportingService<SearchPipelineInfo> {
+public class SearchPipelineService implements ClusterStateApplier, ReportingService<SearchPipelineInfo> {
 
     public static final String SEARCH_PIPELINE_ORIGIN = "search_pipeline";
     public static final String AD_HOC_PIPELINE_ID = "_ad_hoc_pipeline";
diff --git a/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java b/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java
index 87f68a2716937..ac5040cfb9ce1 100644
--- a/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java
+++ b/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.snapshots;
 
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
index 6a5844bd2fe0e..37b91dbd8ec15 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
@@ -20,7 +20,6 @@
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.ToXContentObject;
 import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.common.xcontent.XContentFactory;
 import org.opensearch.common.xcontent.XContentHelper;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/tasks/TaskManager.java b/server/src/main/java/org/opensearch/tasks/TaskManager.java
index 5b8d88377db1d..551dbae919be2 100644
--- a/server/src/main/java/org/opensearch/tasks/TaskManager.java
+++ b/server/src/main/java/org/opensearch/tasks/TaskManager.java
@@ -80,7 +80,6 @@
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
-import java.util.stream.StreamSupport;
 
 import static org.opensearch.common.unit.TimeValue.timeValueMillis;
 import static org.opensearch.http.HttpTransportSettings.SETTING_HTTP_MAX_HEADER_SIZE;
@@ -305,9 +304,17 @@ public ProtobufTask registerProtobuf(String type, String action, ProtobufTaskAwa
                 headers.put(key, httpHeader);
             }
         }
-        ProtobufTask task = request.createProtobufTask(taskIdGenerator.incrementAndGet(), type, action, request.getProtobufParentTask(), headers);
+        ProtobufTask task = request.createProtobufTask(
+            taskIdGenerator.incrementAndGet(),
+            type,
+            action,
+            request.getProtobufParentTask(),
+            headers
+        );
         Objects.requireNonNull(task);
-        assert task.getParentTaskId().equals(request.getProtobufParentTask()) : "Request [ " + request + "] didn't preserve it parentTaskId";
+        assert task.getParentTaskId().equals(request.getProtobufParentTask()) : "Request [ "
+            + request
+            + "] didn't preserve it parentTaskId";
         if (logger.isTraceEnabled()) {
             logger.trace("register {} [{}] [{}] [{}]", task.getId(), type, action, task.getDescription());
         }
@@ -905,25 +912,25 @@ public void applyClusterState(ClusterChangedEvent event) {
 
     // @Override
     // public void applyProtobufClusterState(ProtobufClusterChangedEvent event) {
-    //     lastDiscoveryNodes = event.state().getNodes();
-    //     if (event.nodesRemoved()) {
-    //         synchronized (banedParentsProtobuf) {
-    //             lastDiscoveryNodes = event.state().getNodes();
-    //             // Remove all bans that were registered by nodes that are no longer in the cluster state
-    //             Iterator<ProtobufTaskId> banIterator = banedParentsProtobuf.keySet().iterator();
-    //             while (banIterator.hasNext()) {
-    //                 ProtobufTaskId taskId = banIterator.next();
-    //                 if (lastDiscoveryNodes.nodeExists(taskId.getNodeId()) == false) {
-    //                     logger.debug(
-    //                         "Removing ban for the parent [{}] on the node [{}], reason: the parent node is gone",
-    //                         taskId,
-    //                         event.state().getNodes().getLocalNode()
-    //                     );
-    //                     banIterator.remove();
-    //                 }
-    //             }
-    //         }
-    //     }
+    // lastDiscoveryNodes = event.state().getNodes();
+    // if (event.nodesRemoved()) {
+    // synchronized (banedParentsProtobuf) {
+    // lastDiscoveryNodes = event.state().getNodes();
+    // // Remove all bans that were registered by nodes that are no longer in the cluster state
+    // Iterator<ProtobufTaskId> banIterator = banedParentsProtobuf.keySet().iterator();
+    // while (banIterator.hasNext()) {
+    // ProtobufTaskId taskId = banIterator.next();
+    // if (lastDiscoveryNodes.nodeExists(taskId.getNodeId()) == false) {
+    // logger.debug(
+    // "Removing ban for the parent [{}] on the node [{}], reason: the parent node is gone",
+    // taskId,
+    // event.state().getNodes().getLocalNode()
+    // );
+    // banIterator.remove();
+    // }
+    // }
+    // }
+    // }
     // }
 
     /**
diff --git a/server/src/main/java/org/opensearch/threadpool/ThreadPool.java b/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
index 46eec31863751..0851677bcb13a 100644
--- a/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
+++ b/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
@@ -53,7 +53,6 @@
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.node.Node;
-import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.node.ReportingService;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/transport/InboundHandler.java b/server/src/main/java/org/opensearch/transport/InboundHandler.java
index 5b3b742982a10..8d569429c0f20 100644
--- a/server/src/main/java/org/opensearch/transport/InboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/InboundHandler.java
@@ -46,13 +46,11 @@
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateResponse;
 import org.opensearch.core.common.bytes.BytesReference;
-import org.opensearch.common.bytes.ReleasableBytesReference;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.core.common.io.stream.ByteBufferStreamInput;
 import org.opensearch.core.common.io.stream.NamedWriteableAwareStreamInput;
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.core.common.io.stream.StreamInput;
-import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
@@ -144,7 +142,7 @@ void inboundMessage(TcpChannel channel, InboundMessage message) throws Exception
     void inboundMessageProtobuf(TcpChannel channel, BytesReference message) throws IOException {
         final long startTime = threadPool.relativeTimeInMillis();
         channel.getChannelStats().markAccessed(startTime);
-        ProtobufOutboundMessage protobufOutboundMessage = new ProtobufOutboundMessage(BytesReference.toBytes(message)); 
+        ProtobufOutboundMessage protobufOutboundMessage = new ProtobufOutboundMessage(BytesReference.toBytes(message));
         messageReceivedProtobuf(channel, protobufOutboundMessage, startTime);
     }
 
@@ -158,7 +156,10 @@ private void messageReceivedProtobuf(TcpChannel channel, ProtobufOutboundMessage
         ThreadContext threadContext = threadPool.getThreadContext();
         try (ThreadContext.StoredContext existing = threadContext.stashContext()) {
             // Place the context with the headers from the message
-            final Tuple<Map<String, String>, Map<String, Set<String>>> headers = new Tuple<Map<String,String>,Map<String,Set<String>>>(message.getRequestHeaders(), message.getResponseHandlers());
+            final Tuple<Map<String, String>, Map<String, Set<String>>> headers = new Tuple<Map<String, String>, Map<String, Set<String>>>(
+                message.getRequestHeaders(),
+                message.getResponseHandlers()
+            );
             threadContext.setHeaders(headers);
             threadContext.putTransient("_remote_address", remoteAddress);
             if (TransportStatus.isRequest(header.getStatus().byteAt(0))) {
@@ -171,7 +172,7 @@ private void messageReceivedProtobuf(TcpChannel channel, ProtobufOutboundMessage
                 );
                 if (handler != null) {
                     // if (handler.toString().contains("Protobuf")) {
-                        handleProtobufResponse(requestId, remoteAddress, message, handler);
+                    handleProtobufResponse(requestId, remoteAddress, message, handler);
                     // }
                 }
             }
@@ -250,7 +251,11 @@ private void messageReceived(TcpChannel channel, InboundMessage message, long st
         }
     }
 
-    private <T extends TransportRequest> void handleRequestProtobuf(TcpChannel channel, org.opensearch.server.proto.MessageProto.OutboundInboundMessage.Header header, ProtobufOutboundMessage message) throws IOException {
+    private <T extends TransportRequest> void handleRequestProtobuf(
+        TcpChannel channel,
+        org.opensearch.server.proto.MessageProto.OutboundInboundMessage.Header header,
+        ProtobufOutboundMessage message
+    ) throws IOException {
         OutboundInboundMessage receivedMessage = message.getMessage();
         final String action = receivedMessage.getAction();
         final long requestId = header.getRequestId();
@@ -303,7 +308,7 @@ private <T extends TransportRequest> void handleRequestProtobuf(TcpChannel chann
                     }
                 } catch (Exception e) {
                     sendErrorResponse(action, transportChannel, e);
-                }             
+                }
             } else if (receivedMessage.hasNodesStatsRequest()) {
                 final NodesStatsRequest nodesStatsReq = receivedMessage.getNodesStatsRequest();
                 try {
@@ -322,7 +327,7 @@ private <T extends TransportRequest> void handleRequestProtobuf(TcpChannel chann
                     }
                 } catch (Exception e) {
                     sendErrorResponse(action, transportChannel, e);
-                }             
+                }
             }
         } catch (Exception e) {
             sendErrorResponse(action, transportChannel, e);
diff --git a/server/src/main/java/org/opensearch/transport/InboundPipeline.java b/server/src/main/java/org/opensearch/transport/InboundPipeline.java
index ed5c35ca40120..7b5a4771e3551 100644
--- a/server/src/main/java/org/opensearch/transport/InboundPipeline.java
+++ b/server/src/main/java/org/opensearch/transport/InboundPipeline.java
@@ -44,7 +44,6 @@
 import java.io.IOException;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.function.BiConsumer;
 import java.util.function.Function;
 import java.util.function.LongSupplier;
@@ -134,7 +133,7 @@ public void doHandleBytes(TcpChannel channel, ReleasableBytesReference reference
                 forwardFragmentsProtobuf(channel, reference);
             }
         } catch (Exception e) {
-        
+
             channel.getChannelStats().markAccessed(relativeTimeInMillis.getAsLong());
             statsTracker.markBytesRead(reference.length());
             pending.add(reference.retain());
diff --git a/server/src/main/java/org/opensearch/transport/OutboundHandler.java b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
index 8055de8c07746..a4581b0378964 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
@@ -39,9 +39,7 @@
 import org.opensearch.action.ActionListener;
 import org.opensearch.action.NotifyOnceListener;
 import org.opensearch.action.admin.cluster.node.info.ProtobufNodeInfo;
-import org.opensearch.action.admin.cluster.node.info.ProtobufNodesInfoRequest;
 import org.opensearch.action.admin.cluster.node.info.ProtobufTransportNodesInfoAction.NodeInfoRequest;
-import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
 import org.opensearch.action.admin.cluster.node.stats.ProtobufNodeStats;
 import org.opensearch.action.admin.cluster.node.stats.ProtobufTransportNodesStatsAction.NodeStatsRequest;
 import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
@@ -141,19 +139,43 @@ void sendRequest(
             ProtobufClusterStateRequest protobufClusterStateRequest = (ProtobufClusterStateRequest) request;
             byte[] bytes = new byte[1];
             bytes[0] = 0;
-            ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufClusterStateRequest.request(), features, action);
+            ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(
+                requestId,
+                bytes,
+                Version.CURRENT,
+                threadPool.getThreadContext(),
+                protobufClusterStateRequest.request(),
+                features,
+                action
+            );
             sendProtobufMessage(channel, protobufMessage, listener);
         } else if (canonicalName.contains("ProtobufTransportNodesInfo")) {
             NodeInfoRequest protobufNodesInfoRequest = (NodeInfoRequest) request;
             byte[] bytes = new byte[1];
             bytes[0] = 0;
-            ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufNodesInfoRequest.request().request(), features, action);
+            ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(
+                requestId,
+                bytes,
+                Version.CURRENT,
+                threadPool.getThreadContext(),
+                protobufNodesInfoRequest.request().request(),
+                features,
+                action
+            );
             sendProtobufMessage(channel, protobufMessage, listener);
         } else if (canonicalName.contains("ProtobufTransportNodesStats")) {
             NodeStatsRequest protobufNodesStatsRequest = (NodeStatsRequest) request;
             byte[] bytes = new byte[1];
             bytes[0] = 0;
-            ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufNodesStatsRequest.request().request(), features, action);
+            ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(
+                requestId,
+                bytes,
+                Version.CURRENT,
+                threadPool.getThreadContext(),
+                protobufNodesStatsRequest.request().request(),
+                features,
+                action
+            );
             sendProtobufMessage(channel, protobufMessage, listener);
         } else {
             sendMessage(channel, message, listener);
@@ -193,19 +215,43 @@ void sendResponse(
             ProtobufClusterStateResponse protobufClusterStateResponse = (ProtobufClusterStateResponse) response;
             byte[] bytes = new byte[1];
             bytes[0] = 1;
-            ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufClusterStateResponse.response(), features, action);
+            ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(
+                requestId,
+                bytes,
+                Version.CURRENT,
+                threadPool.getThreadContext(),
+                protobufClusterStateResponse.response(),
+                features,
+                action
+            );
             sendProtobufMessage(channel, protobufMessage, listener);
         } else if (canonicalName.contains("ProtobufNodeInfo")) {
             ProtobufNodeInfo protobufNodeInfo = (ProtobufNodeInfo) response;
             byte[] bytes = new byte[1];
             bytes[0] = 1;
-            ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufNodeInfo.response(), features, action);
+            ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(
+                requestId,
+                bytes,
+                Version.CURRENT,
+                threadPool.getThreadContext(),
+                protobufNodeInfo.response(),
+                features,
+                action
+            );
             sendProtobufMessage(channel, protobufMessage, listener);
         } else if (canonicalName.contains("ProtobufNodeStats")) {
             ProtobufNodeStats protobufNodeStats = (ProtobufNodeStats) response;
             byte[] bytes = new byte[1];
             bytes[0] = 1;
-            ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(requestId, bytes, Version.CURRENT, threadPool.getThreadContext(), protobufNodeStats.response(), features, action);
+            ProtobufOutboundMessage protobufMessage = new ProtobufOutboundMessage(
+                requestId,
+                bytes,
+                Version.CURRENT,
+                threadPool.getThreadContext(),
+                protobufNodeStats.response(),
+                features,
+                action
+            );
             sendProtobufMessage(channel, protobufMessage, listener);
         } else {
             sendMessage(channel, message, listener);
@@ -245,7 +291,8 @@ private void sendMessage(TcpChannel channel, OutboundMessage networkMessage, Act
         internalSend(channel, sendContext);
     }
 
-    private void sendProtobufMessage(TcpChannel channel, ProtobufOutboundMessage message, ActionListener<Void> listener) throws IOException {
+    private void sendProtobufMessage(TcpChannel channel, ProtobufOutboundMessage message, ActionListener<Void> listener)
+        throws IOException {
         TryMessageSerializer serializer = new TryMessageSerializer(message, bigArrays);
         SendContext sendContext = new SendContext(channel, serializer, listener, serializer);
         internalSend(channel, sendContext);
@@ -320,12 +367,12 @@ private TryMessageSerializer(ProtobufOutboundMessage message, BigArrays bigArray
         @Override
         public BytesReference get() throws IOException {
             bytesStreamOutput = new ReleasableBytesStreamOutput(bigArrays);
-            BytesReference reference = serialize(bytesStreamOutput); 
+            BytesReference reference = serialize(bytesStreamOutput);
             return reference;
         }
 
         private BytesReference serialize(BytesStreamOutput bytesStream) throws IOException {
-            ByteBuffer byteBuffers = ByteBuffer.wrap(message.getMessage().toByteArray()); 
+            ByteBuffer byteBuffers = ByteBuffer.wrap(message.getMessage().toByteArray());
             message.getMessage().writeTo(bytesStream);
             return BytesReference.fromByteBuffer(byteBuffers);
         }
diff --git a/server/src/main/java/org/opensearch/transport/OutboundMessage.java b/server/src/main/java/org/opensearch/transport/OutboundMessage.java
index e6b93a426559b..c3c6e418a9c70 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundMessage.java
@@ -95,7 +95,6 @@ BytesReference serialize1(BytesStreamOutput bytesStream) throws IOException {
         writeVariableHeader(bytesStream);
         variableHeaderLength = Math.toIntExact(bytesStream.position() - preHeaderPosition);
 
-
         try (CompressibleBytesOutputStream stream = new CompressibleBytesOutputStream(bytesStream, TransportStatus.isCompress(status))) {
             stream.setVersion(version);
             stream.setFeatures(bytesStream.getFeatures());
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java b/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
index 0b721aa938099..55745e06351b5 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
@@ -41,202 +41,238 @@ public class ProtobufOutboundMessage {
     private final OutboundInboundMessage message;
     private static final byte[] PREFIX = { (byte) 'E', (byte) 'S' };
 
-    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, ClusterStateRequest clusterStateReq, String[] features, String action) {
+    public ProtobufOutboundMessage(
+        long requestId,
+        byte[] status,
+        Version version,
+        ThreadContext threadContext,
+        ClusterStateRequest clusterStateReq,
+        String[] features,
+        String action
+    ) {
         Header header = Header.newBuilder()
-                            .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
-                            .setRequestId(requestId)
-                            .setStatus(ByteString.copyFrom(status))
-                            .setVersionId(version.id)
-                            .build();
+            .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
+            .setRequestId(requestId)
+            .setStatus(ByteString.copyFrom(status))
+            .setVersionId(version.id)
+            .build();
         Map<String, String> requestHeaders = threadContext.getHeaders();
         Map<String, List<String>> responseHeaders = threadContext.getResponseHeaders();
         Map<String, ResponseHandlersList> responseHandlers = new HashMap<>();
         for (Map.Entry<String, List<String>> entry : responseHeaders.entrySet()) {
             String key = entry.getKey();
             List<String> value = entry.getValue();
-            ResponseHandlersList responseHandlersList = ResponseHandlersList.newBuilder()
-                                                                        .addAllSetOfResponseHandlers(value)
-                                                                        .build();
+            ResponseHandlersList responseHandlersList = ResponseHandlersList.newBuilder().addAllSetOfResponseHandlers(value).build();
             responseHandlers.put(key, responseHandlersList);
         }
         this.message = OutboundInboundMessage.newBuilder()
-                            .setHeader(header)
-                            .putAllRequestHeaders(requestHeaders)
-                            .putAllResponseHandlers(responseHandlers)
-                            .setVersion(version.toString())
-                            .setStatus(ByteString.copyFrom(status))
-                            .setRequestId(requestId)
-                            .setClusterStateRequest(clusterStateReq)
-                            .setAction(action)
-                            .addAllFeatures(Arrays.asList(features))
-                            .setIsProtobuf(true)
-                            .build();
-                            
+            .setHeader(header)
+            .putAllRequestHeaders(requestHeaders)
+            .putAllResponseHandlers(responseHandlers)
+            .setVersion(version.toString())
+            .setStatus(ByteString.copyFrom(status))
+            .setRequestId(requestId)
+            .setClusterStateRequest(clusterStateReq)
+            .setAction(action)
+            .addAllFeatures(Arrays.asList(features))
+            .setIsProtobuf(true)
+            .build();
+
     }
 
-    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, ClusterStateResponse clusterStateRes, Set<String> features, String action) {
+    public ProtobufOutboundMessage(
+        long requestId,
+        byte[] status,
+        Version version,
+        ThreadContext threadContext,
+        ClusterStateResponse clusterStateRes,
+        Set<String> features,
+        String action
+    ) {
         Header header = Header.newBuilder()
-                            .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
-                            .setRequestId(requestId)
-                            .setStatus(ByteString.copyFrom(status))
-                            .setVersionId(version.id)
-                            .build();
+            .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
+            .setRequestId(requestId)
+            .setStatus(ByteString.copyFrom(status))
+            .setVersionId(version.id)
+            .build();
         Map<String, String> requestHeaders = threadContext.getHeaders();
         Map<String, List<String>> responseHeaders = threadContext.getResponseHeaders();
         Map<String, ResponseHandlersList> responseHandlers = new HashMap<>();
         for (Map.Entry<String, List<String>> entry : responseHeaders.entrySet()) {
             String key = entry.getKey();
             List<String> value = entry.getValue();
-            ResponseHandlersList responseHandlersList = ResponseHandlersList.newBuilder()
-                                                                        .addAllSetOfResponseHandlers(value)
-                                                                        .build();
+            ResponseHandlersList responseHandlersList = ResponseHandlersList.newBuilder().addAllSetOfResponseHandlers(value).build();
             responseHandlers.put(key, responseHandlersList);
         }
         this.message = OutboundInboundMessage.newBuilder()
-                            .setHeader(header)
-                            .putAllRequestHeaders(requestHeaders)
-                            .putAllResponseHandlers(responseHandlers)
-                            .setVersion(version.toString())
-                            .setStatus(ByteString.copyFrom(status))
-                            .setRequestId(requestId)
-                            .setClusterStateResponse(clusterStateRes)
-                            .setAction(action)
-                            .addAllFeatures(features)
-                            .setIsProtobuf(true)
-                            .build();
-                            
+            .setHeader(header)
+            .putAllRequestHeaders(requestHeaders)
+            .putAllResponseHandlers(responseHandlers)
+            .setVersion(version.toString())
+            .setStatus(ByteString.copyFrom(status))
+            .setRequestId(requestId)
+            .setClusterStateResponse(clusterStateRes)
+            .setAction(action)
+            .addAllFeatures(features)
+            .setIsProtobuf(true)
+            .build();
+
     }
 
-    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, NodesInfoRequest nodesInfoReq, String[] features, String action) {
+    public ProtobufOutboundMessage(
+        long requestId,
+        byte[] status,
+        Version version,
+        ThreadContext threadContext,
+        NodesInfoRequest nodesInfoReq,
+        String[] features,
+        String action
+    ) {
         Header header = Header.newBuilder()
-                            .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
-                            .setRequestId(requestId)
-                            .setStatus(ByteString.copyFrom(status))
-                            .setVersionId(version.id)
-                            .build();
+            .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
+            .setRequestId(requestId)
+            .setStatus(ByteString.copyFrom(status))
+            .setVersionId(version.id)
+            .build();
         Map<String, String> requestHeaders = threadContext.getHeaders();
         Map<String, List<String>> responseHeaders = threadContext.getResponseHeaders();
         Map<String, ResponseHandlersList> responseHandlers = new HashMap<>();
         for (Map.Entry<String, List<String>> entry : responseHeaders.entrySet()) {
             String key = entry.getKey();
             List<String> value = entry.getValue();
-            ResponseHandlersList responseHandlersList = ResponseHandlersList.newBuilder()
-                                                                        .addAllSetOfResponseHandlers(value)
-                                                                        .build();
+            ResponseHandlersList responseHandlersList = ResponseHandlersList.newBuilder().addAllSetOfResponseHandlers(value).build();
             responseHandlers.put(key, responseHandlersList);
         }
         this.message = OutboundInboundMessage.newBuilder()
-                            .setHeader(header)
-                            .putAllRequestHeaders(requestHeaders)
-                            .putAllResponseHandlers(responseHandlers)
-                            .setVersion(version.toString())
-                            .setStatus(ByteString.copyFrom(status))
-                            .setRequestId(requestId)
-                            .setNodesInfoRequest(nodesInfoReq)
-                            .setAction(action)
-                            .addAllFeatures(Arrays.asList(features))
-                            .setIsProtobuf(true)
-                            .build();
-                            
+            .setHeader(header)
+            .putAllRequestHeaders(requestHeaders)
+            .putAllResponseHandlers(responseHandlers)
+            .setVersion(version.toString())
+            .setStatus(ByteString.copyFrom(status))
+            .setRequestId(requestId)
+            .setNodesInfoRequest(nodesInfoReq)
+            .setAction(action)
+            .addAllFeatures(Arrays.asList(features))
+            .setIsProtobuf(true)
+            .build();
+
     }
 
-    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, NodesInfo nodesInfoRes, Set<String> features, String action) {
+    public ProtobufOutboundMessage(
+        long requestId,
+        byte[] status,
+        Version version,
+        ThreadContext threadContext,
+        NodesInfo nodesInfoRes,
+        Set<String> features,
+        String action
+    ) {
         Header header = Header.newBuilder()
-                            .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
-                            .setRequestId(requestId)
-                            .setStatus(ByteString.copyFrom(status))
-                            .setVersionId(version.id)
-                            .build();
+            .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
+            .setRequestId(requestId)
+            .setStatus(ByteString.copyFrom(status))
+            .setVersionId(version.id)
+            .build();
         Map<String, String> requestHeaders = threadContext.getHeaders();
         Map<String, List<String>> responseHeaders = threadContext.getResponseHeaders();
         Map<String, ResponseHandlersList> responseHandlers = new HashMap<>();
         for (Map.Entry<String, List<String>> entry : responseHeaders.entrySet()) {
             String key = entry.getKey();
             List<String> value = entry.getValue();
-            ResponseHandlersList responseHandlersList = ResponseHandlersList.newBuilder()
-                                                                        .addAllSetOfResponseHandlers(value)
-                                                                        .build();
+            ResponseHandlersList responseHandlersList = ResponseHandlersList.newBuilder().addAllSetOfResponseHandlers(value).build();
             responseHandlers.put(key, responseHandlersList);
         }
         this.message = OutboundInboundMessage.newBuilder()
-                            .setHeader(header)
-                            .putAllRequestHeaders(requestHeaders)
-                            .putAllResponseHandlers(responseHandlers)
-                            .setVersion(version.toString())
-                            .setStatus(ByteString.copyFrom(status))
-                            .setRequestId(requestId)
-                            .setNodesInfoResponse(nodesInfoRes)
-                            .setAction(action)
-                            .addAllFeatures(features)
-                            .setIsProtobuf(true)
-                            .build();
-                            
+            .setHeader(header)
+            .putAllRequestHeaders(requestHeaders)
+            .putAllResponseHandlers(responseHandlers)
+            .setVersion(version.toString())
+            .setStatus(ByteString.copyFrom(status))
+            .setRequestId(requestId)
+            .setNodesInfoResponse(nodesInfoRes)
+            .setAction(action)
+            .addAllFeatures(features)
+            .setIsProtobuf(true)
+            .build();
+
     }
 
-    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, NodesStatsRequest nodesStatsReq, String[] features, String action) {
+    public ProtobufOutboundMessage(
+        long requestId,
+        byte[] status,
+        Version version,
+        ThreadContext threadContext,
+        NodesStatsRequest nodesStatsReq,
+        String[] features,
+        String action
+    ) {
         Header header = Header.newBuilder()
-                            .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
-                            .setRequestId(requestId)
-                            .setStatus(ByteString.copyFrom(status))
-                            .setVersionId(version.id)
-                            .build();
+            .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
+            .setRequestId(requestId)
+            .setStatus(ByteString.copyFrom(status))
+            .setVersionId(version.id)
+            .build();
         Map<String, String> requestHeaders = threadContext.getHeaders();
         Map<String, List<String>> responseHeaders = threadContext.getResponseHeaders();
         Map<String, ResponseHandlersList> responseHandlers = new HashMap<>();
         for (Map.Entry<String, List<String>> entry : responseHeaders.entrySet()) {
             String key = entry.getKey();
             List<String> value = entry.getValue();
-            ResponseHandlersList responseHandlersList = ResponseHandlersList.newBuilder()
-                                                                        .addAllSetOfResponseHandlers(value)
-                                                                        .build();
+            ResponseHandlersList responseHandlersList = ResponseHandlersList.newBuilder().addAllSetOfResponseHandlers(value).build();
             responseHandlers.put(key, responseHandlersList);
         }
         this.message = OutboundInboundMessage.newBuilder()
-                            .setHeader(header)
-                            .putAllRequestHeaders(requestHeaders)
-                            .putAllResponseHandlers(responseHandlers)
-                            .setVersion(version.toString())
-                            .setStatus(ByteString.copyFrom(status))
-                            .setRequestId(requestId)
-                            .setNodesStatsRequest(nodesStatsReq)
-                            .setAction(action)
-                            .addAllFeatures(Arrays.asList(features))
-                            .setIsProtobuf(true)
-                            .build();
-                            
+            .setHeader(header)
+            .putAllRequestHeaders(requestHeaders)
+            .putAllResponseHandlers(responseHandlers)
+            .setVersion(version.toString())
+            .setStatus(ByteString.copyFrom(status))
+            .setRequestId(requestId)
+            .setNodesStatsRequest(nodesStatsReq)
+            .setAction(action)
+            .addAllFeatures(Arrays.asList(features))
+            .setIsProtobuf(true)
+            .build();
+
     }
 
-    public ProtobufOutboundMessage(long requestId, byte[] status, Version version, ThreadContext threadContext, NodesStats nodesStatsRes, Set<String> features, String action) {
+    public ProtobufOutboundMessage(
+        long requestId,
+        byte[] status,
+        Version version,
+        ThreadContext threadContext,
+        NodesStats nodesStatsRes,
+        Set<String> features,
+        String action
+    ) {
         Header header = Header.newBuilder()
-                            .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
-                            .setRequestId(requestId)
-                            .setStatus(ByteString.copyFrom(status))
-                            .setVersionId(version.id)
-                            .build();
+            .addAllPrefix(Arrays.asList(ByteString.copyFrom(PREFIX)))
+            .setRequestId(requestId)
+            .setStatus(ByteString.copyFrom(status))
+            .setVersionId(version.id)
+            .build();
         Map<String, String> requestHeaders = threadContext.getHeaders();
         Map<String, List<String>> responseHeaders = threadContext.getResponseHeaders();
         Map<String, ResponseHandlersList> responseHandlers = new HashMap<>();
         for (Map.Entry<String, List<String>> entry : responseHeaders.entrySet()) {
             String key = entry.getKey();
             List<String> value = entry.getValue();
-            ResponseHandlersList responseHandlersList = ResponseHandlersList.newBuilder()
-                                                                        .addAllSetOfResponseHandlers(value)
-                                                                        .build();
+            ResponseHandlersList responseHandlersList = ResponseHandlersList.newBuilder().addAllSetOfResponseHandlers(value).build();
             responseHandlers.put(key, responseHandlersList);
         }
         this.message = OutboundInboundMessage.newBuilder()
-                            .setHeader(header)
-                            .putAllRequestHeaders(requestHeaders)
-                            .putAllResponseHandlers(responseHandlers)
-                            .setVersion(version.toString())
-                            .setStatus(ByteString.copyFrom(status))
-                            .setRequestId(requestId)
-                            .setNodesStatsResponse(nodesStatsRes)
-                            .setAction(action)
-                            .addAllFeatures(features)
-                            .setIsProtobuf(true)
-                            .build();
-                            
+            .setHeader(header)
+            .putAllRequestHeaders(requestHeaders)
+            .putAllResponseHandlers(responseHandlers)
+            .setVersion(version.toString())
+            .setStatus(ByteString.copyFrom(status))
+            .setRequestId(requestId)
+            .setNodesStatsResponse(nodesStatsRes)
+            .setAction(action)
+            .addAllFeatures(features)
+            .setIsProtobuf(true)
+            .build();
+
     }
 
     public ProtobufOutboundMessage(byte[] data) throws InvalidProtocolBufferException {
diff --git a/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java b/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java
index 43e820c209d47..d53e58f9cc5e1 100644
--- a/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java
+++ b/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java
@@ -233,9 +233,9 @@ public Object getCacheKey() {
 
         // @Override
         // public void sendRequestProtobuf(long requestId, String action, TransportRequest request,
-        //         TransportRequestOptions options) throws IOException, TransportException {
-        //     // TODO Auto-generated method stub
-        //     throw new UnsupportedOperationException("Unimplemented method 'sendRequestProtobuf'");
+        // TransportRequestOptions options) throws IOException, TransportException {
+        // // TODO Auto-generated method stub
+        // throw new UnsupportedOperationException("Unimplemented method 'sendRequestProtobuf'");
         // }
     }
 }
diff --git a/server/src/main/java/org/opensearch/transport/TcpTransport.java b/server/src/main/java/org/opensearch/transport/TcpTransport.java
index ae81e6a708ca1..2bb2ab009a8ad 100644
--- a/server/src/main/java/org/opensearch/transport/TcpTransport.java
+++ b/server/src/main/java/org/opensearch/transport/TcpTransport.java
@@ -404,12 +404,12 @@ public Map<String, BoundTransportAddress> profileBoundAddresses() {
 
     // @Override
     // public BoundTransportAddress boundProtobufAddress() {
-    //     return this.protobufBoundAddress;
+    // return this.protobufBoundAddress;
     // }
 
     // @Override
     // public Map<String, BoundTransportAddress> profileProtobufBoundAddresses() {
-    //     return unmodifiableMap(new HashMap<>(profileProtobufBoundAddresses));
+    // return unmodifiableMap(new HashMap<>(profileProtobufBoundAddresses));
     // }
 
     @Override
@@ -528,40 +528,40 @@ private BoundTransportAddress createBoundTransportAddress(ProfileSettings profil
     }
 
     // private BoundTransportAddress createProtobufBoundTransportAddress(BoundTransportAddress boundTransportAddress) {
-    //     TransportAddress[] transportBoundAddresses = boundTransportAddress.boundAddresses();
-    //     TransportAddress publishAddress = boundTransportAddress.publishAddress();
-    //     TransportAddress[] transportBoundAddressesProtobuf = new TransportAddress[transportBoundAddresses.length];
-    //     for (int i = 0; i < transportBoundAddresses.length; i++) {
-    //         transportBoundAddressesProtobuf[i] = new TransportAddress(transportBoundAddresses[i].address());
-    //     }
-    //     return new BoundTransportAddress(transportBoundAddressesProtobuf, new TransportAddress(publishAddress.address()));
-    //     // String[] boundAddressesHostStrings = new String[boundAddresses.size()];
-    //     // TransportAddress[] transportBoundAddresses = new TransportAddress[boundAddresses.size()];
-    //     // for (int i = 0; i < boundAddresses.size(); i++) {
-    //     // InetSocketAddress boundAddress = boundAddresses.get(i);
-    //     // boundAddressesHostStrings[i] = boundAddress.getHostString();
-    //     // transportBoundAddresses[i] = new TransportAddress(boundAddress);
-    //     // }
-
-    //     // List<String> publishHosts = profileSettings.publishHosts;
-    //     // if (profileSettings.isDefaultProfile == false && publishHosts.isEmpty()) {
-    //     // publishHosts = Arrays.asList(boundAddressesHostStrings);
-    //     // }
-    //     // if (publishHosts.isEmpty()) {
-    //     // publishHosts = NetworkService.GLOBAL_NETWORK_PUBLISH_HOST_SETTING.get(settings);
-    //     // }
-
-    //     // final InetAddress publishInetAddress;
-    //     // try {
-    //     // publishInetAddress = networkService.resolvePublishHostAddresses(publishHosts.toArray(Strings.EMPTY_ARRAY));
-    //     // } catch (Exception e) {
-    //     // throw new BindTransportException("Failed to resolve publish address", e);
-    //     // }
-
-    //     // final int publishPort = resolvePublishPort(profileSettings, boundAddresses, publishInetAddress);
-    //     // final TransportAddress publishAddress = new TransportAddress(new InetSocketAddress(publishInetAddress,
-    //     // publishPort));
-    //     // return new BoundTransportAddress(transportBoundAddresses, publishAddress);
+    // TransportAddress[] transportBoundAddresses = boundTransportAddress.boundAddresses();
+    // TransportAddress publishAddress = boundTransportAddress.publishAddress();
+    // TransportAddress[] transportBoundAddressesProtobuf = new TransportAddress[transportBoundAddresses.length];
+    // for (int i = 0; i < transportBoundAddresses.length; i++) {
+    // transportBoundAddressesProtobuf[i] = new TransportAddress(transportBoundAddresses[i].address());
+    // }
+    // return new BoundTransportAddress(transportBoundAddressesProtobuf, new TransportAddress(publishAddress.address()));
+    // // String[] boundAddressesHostStrings = new String[boundAddresses.size()];
+    // // TransportAddress[] transportBoundAddresses = new TransportAddress[boundAddresses.size()];
+    // // for (int i = 0; i < boundAddresses.size(); i++) {
+    // // InetSocketAddress boundAddress = boundAddresses.get(i);
+    // // boundAddressesHostStrings[i] = boundAddress.getHostString();
+    // // transportBoundAddresses[i] = new TransportAddress(boundAddress);
+    // // }
+
+    // // List<String> publishHosts = profileSettings.publishHosts;
+    // // if (profileSettings.isDefaultProfile == false && publishHosts.isEmpty()) {
+    // // publishHosts = Arrays.asList(boundAddressesHostStrings);
+    // // }
+    // // if (publishHosts.isEmpty()) {
+    // // publishHosts = NetworkService.GLOBAL_NETWORK_PUBLISH_HOST_SETTING.get(settings);
+    // // }
+
+    // // final InetAddress publishInetAddress;
+    // // try {
+    // // publishInetAddress = networkService.resolvePublishHostAddresses(publishHosts.toArray(Strings.EMPTY_ARRAY));
+    // // } catch (Exception e) {
+    // // throw new BindTransportException("Failed to resolve publish address", e);
+    // // }
+
+    // // final int publishPort = resolvePublishPort(profileSettings, boundAddresses, publishInetAddress);
+    // // final TransportAddress publishAddress = new TransportAddress(new InetSocketAddress(publishInetAddress,
+    // // publishPort));
+    // // return new BoundTransportAddress(transportBoundAddresses, publishAddress);
     // }
 
     // package private for tests
@@ -836,6 +836,7 @@ public void inboundMessageProtobuf(TcpChannel channel, BytesReference message) {
             onException(channel, e);
         }
     }
+
     /**
      * Validates the first 6 bytes of the message header and returns the length of the message. If 6 bytes
      * are not available, it returns -1.
diff --git a/server/src/main/java/org/opensearch/transport/Transport.java b/server/src/main/java/org/opensearch/transport/Transport.java
index 40b5e35dab80e..7e95f83b44042 100644
--- a/server/src/main/java/org/opensearch/transport/Transport.java
+++ b/server/src/main/java/org/opensearch/transport/Transport.java
@@ -138,9 +138,9 @@ interface Connection extends Closeable {
          */
         void sendRequest(long requestId, String action, TransportRequest request, TransportRequestOptions options) throws IOException,
             TransportException;
-        
+
         // /**
-        //  * Sends the request to the node this connection is associated with
+        // * Sends the request to the node this connection is associated with
         // * @param requestId see {@link ResponseHandlers#add(ResponseContext)} for details
         // * @param action the action to execute
         // * @param request the request to send
@@ -148,7 +148,7 @@ void sendRequest(long requestId, String action, TransportRequest request, Transp
         // * @throws NodeNotConnectedException if the given node is not connected
         // */
         // void sendRequestProtobuf(long requestId, String action, TransportRequest request, TransportRequestOptions options)
-        //     throws IOException, TransportException;
+        // throws IOException, TransportException;
 
         /**
          * The listener's {@link ActionListener#onResponse(Object)} method will be called when this
@@ -181,53 +181,53 @@ default Object getCacheKey() {
     }
 
     // /**
-    //  * A unidirectional connection to a {@link DiscoveryNode}
+    // * A unidirectional connection to a {@link DiscoveryNode}
     // */
     // interface ProtobufConnection extends Closeable {
-    //     /**
-    //      * The node this connection is associated with
-    //     */
-    //     DiscoveryNode getNode();
-
-    //     /**
-    //      * Sends the request to the node this connection is associated with
-    //     * @param requestId see {@link ResponseHandlers#add(ResponseContext)} for details
-    //     * @param action the action to execute
-    //     * @param request the request to send
-    //     * @param options request options to apply
-    //     * @throws NodeNotConnectedException if the given node is not connected
-    //     */
-    //     void sendRequest(long requestId, String action, TransportRequest request, TransportRequestOptions options)
-    //         throws IOException, TransportException;
-
-    //     /**
-    //      * The listener's {@link ActionListener#onResponse(Object)} method will be called when this
-    //     * connection is closed. No implementations currently throw an exception during close, so
-    //     * {@link ActionListener#onFailure(Exception)} will not be called.
-    //     *
-    //     * @param listener to be called
-    //     */
-    //     void addCloseListener(ActionListener<Void> listener);
-
-    //     boolean isClosed();
-
-    //     /**
-    //      * Returns the version of the node this connection was established with.
-    //     */
-    //     default Version getVersion() {
-    //         return getNode().getVersion();
-    //     }
-
-    //     /**
-    //      * Returns a key that this connection can be cached on. Delegating subclasses must delegate method call to
-    //     * the original connection.
-    //     */
-    //     default Object getCacheKey() {
-    //         return this;
-    //     }
-
-    //     @Override
-    //     void close();
+    // /**
+    // * The node this connection is associated with
+    // */
+    // DiscoveryNode getNode();
+
+    // /**
+    // * Sends the request to the node this connection is associated with
+    // * @param requestId see {@link ResponseHandlers#add(ResponseContext)} for details
+    // * @param action the action to execute
+    // * @param request the request to send
+    // * @param options request options to apply
+    // * @throws NodeNotConnectedException if the given node is not connected
+    // */
+    // void sendRequest(long requestId, String action, TransportRequest request, TransportRequestOptions options)
+    // throws IOException, TransportException;
+
+    // /**
+    // * The listener's {@link ActionListener#onResponse(Object)} method will be called when this
+    // * connection is closed. No implementations currently throw an exception during close, so
+    // * {@link ActionListener#onFailure(Exception)} will not be called.
+    // *
+    // * @param listener to be called
+    // */
+    // void addCloseListener(ActionListener<Void> listener);
+
+    // boolean isClosed();
+
+    // /**
+    // * Returns the version of the node this connection was established with.
+    // */
+    // default Version getVersion() {
+    // return getNode().getVersion();
+    // }
+
+    // /**
+    // * Returns a key that this connection can be cached on. Delegating subclasses must delegate method call to
+    // * the original connection.
+    // */
+    // default Object getCacheKey() {
+    // return this;
+    // }
+
+    // @Override
+    // void close();
     // }
 
     /**
@@ -262,34 +262,34 @@ public String action() {
     }
 
     // /**
-    //  * This class represents a response context that encapsulates the actual response handler, the action and the connection it was
+    // * This class represents a response context that encapsulates the actual response handler, the action and the connection it was
     // * executed on.
     // */
     // final class ProtobufResponseContext<T extends TransportResponse> {
 
-    //     private final ProtobufTransportResponseHandler<T> handler;
+    // private final ProtobufTransportResponseHandler<T> handler;
 
-    //     private final Connection connection;
+    // private final Connection connection;
 
-    //     private final String action;
+    // private final String action;
 
-    //     ProtobufResponseContext(ProtobufTransportResponseHandler<T> handler, Connection connection, String action) {
-    //         this.handler = handler;
-    //         this.connection = connection;
-    //         this.action = action;
-    //     }
+    // ProtobufResponseContext(ProtobufTransportResponseHandler<T> handler, Connection connection, String action) {
+    // this.handler = handler;
+    // this.connection = connection;
+    // this.action = action;
+    // }
 
-    //     public ProtobufTransportResponseHandler<T> handler() {
-    //         return handler;
-    //     }
+    // public ProtobufTransportResponseHandler<T> handler() {
+    // return handler;
+    // }
 
-    //     public Connection connection() {
-    //         return this.connection;
-    //     }
+    // public Connection connection() {
+    // return this.connection;
+    // }
 
-    //     public String action() {
-    //         return this.action;
-    //     }
+    // public String action() {
+    // return this.action;
+    // }
     // }
 
     /**
@@ -372,84 +372,84 @@ public TransportResponseHandler<? extends TransportResponse> onResponseReceived(
     }
 
     // /**
-    //  * This class is a registry that allows
+    // * This class is a registry that allows
     // */
     // final class ProtobufResponseHandlers {
-    //     private final ConcurrentMapLong<ProtobufResponseContext<? extends TransportResponse>> handlers = ConcurrentCollections
-    //         .newConcurrentMapLongWithAggressiveConcurrency();
-    //     private final AtomicLong requestIdGenerator = new AtomicLong();
-
-    //     /**
-    //      * Returns <code>true</code> if the give request ID has a context associated with it.
-    //     */
-    //     public boolean contains(long requestId) {
-    //         return handlers.containsKey(requestId);
-    //     }
-
-    //     /**
-    //      * Removes and return the {@link ResponseContext} for the given request ID or returns
-    //     * <code>null</code> if no context is associated with this request ID.
-    //     */
-    //     public ProtobufResponseContext<? extends TransportResponse> remove(long requestId) {
-    //         return handlers.remove(requestId);
-    //     }
-
-    //     /**
-    //      * Adds a new response context and associates it with a new request ID.
-    //     * @return the new request ID
-    //     * @see Connection#sendRequestProtobuf(long, String, TransportRequest, TransportRequestOptions)
-    //     */
-    //     public long add(ProtobufResponseContext<? extends TransportResponse> holder) {
-    //         long requestId = newRequestId();
-    //         ProtobufResponseContext<? extends TransportResponse> existing = handlers.put(requestId, holder);
-    //         assert existing == null : "request ID already in use: " + requestId;
-    //         return requestId;
-    //     }
-
-    //     /**
-    //      * Returns a new request ID to use when sending a message via {@link Connection#sendRequestProtobuf(long, String,
-    //     * TransportRequest, TransportRequestOptions)}
-    //     */
-    //     long newRequestId() {
-    //         return requestIdGenerator.incrementAndGet();
-    //     }
-
-    //     /**
-    //      * Removes and returns all {@link ResponseContext} instances that match the predicate
-    //     */
-    //     public List<ProtobufResponseContext<? extends TransportResponse>> prune(
-    //         Predicate<ProtobufResponseContext<? extends TransportResponse>> predicate
-    //     ) {
-    //         final List<ProtobufResponseContext<? extends TransportResponse>> holders = new ArrayList<>();
-    //         for (Map.Entry<Long, ProtobufResponseContext<? extends TransportResponse>> entry : handlers.entrySet()) {
-    //             ProtobufResponseContext<? extends TransportResponse> holder = entry.getValue();
-    //             if (predicate.test(holder)) {
-    //                 ProtobufResponseContext<? extends TransportResponse> remove = handlers.remove(entry.getKey());
-    //                 if (remove != null) {
-    //                     holders.add(holder);
-    //                 }
-    //             }
-    //         }
-    //         return holders;
-    //     }
-
-    //     /**
-    //      * called by the {@link Transport} implementation when a response or an exception has been received for a previously
-    //     * sent request (before any processing or deserialization was done). Returns the appropriate response handler or null if not
-    //     * found.
-    //     */
-    //     public ProtobufTransportResponseHandler<? extends TransportResponse> onResponseReceived(
-    //         final long requestId,
-    //         final ProtobufTransportMessageListener listener
-    //     ) {
-    //         ProtobufResponseContext<? extends TransportResponse> context = handlers.remove(requestId);
-    //         listener.onResponseReceived(requestId, context);
-    //         if (context == null) {
-    //             return null;
-    //         } else {
-    //             return context.handler();
-    //         }
-    //     }
+    // private final ConcurrentMapLong<ProtobufResponseContext<? extends TransportResponse>> handlers = ConcurrentCollections
+    // .newConcurrentMapLongWithAggressiveConcurrency();
+    // private final AtomicLong requestIdGenerator = new AtomicLong();
+
+    // /**
+    // * Returns <code>true</code> if the give request ID has a context associated with it.
+    // */
+    // public boolean contains(long requestId) {
+    // return handlers.containsKey(requestId);
+    // }
+
+    // /**
+    // * Removes and return the {@link ResponseContext} for the given request ID or returns
+    // * <code>null</code> if no context is associated with this request ID.
+    // */
+    // public ProtobufResponseContext<? extends TransportResponse> remove(long requestId) {
+    // return handlers.remove(requestId);
+    // }
+
+    // /**
+    // * Adds a new response context and associates it with a new request ID.
+    // * @return the new request ID
+    // * @see Connection#sendRequestProtobuf(long, String, TransportRequest, TransportRequestOptions)
+    // */
+    // public long add(ProtobufResponseContext<? extends TransportResponse> holder) {
+    // long requestId = newRequestId();
+    // ProtobufResponseContext<? extends TransportResponse> existing = handlers.put(requestId, holder);
+    // assert existing == null : "request ID already in use: " + requestId;
+    // return requestId;
+    // }
+
+    // /**
+    // * Returns a new request ID to use when sending a message via {@link Connection#sendRequestProtobuf(long, String,
+    // * TransportRequest, TransportRequestOptions)}
+    // */
+    // long newRequestId() {
+    // return requestIdGenerator.incrementAndGet();
+    // }
+
+    // /**
+    // * Removes and returns all {@link ResponseContext} instances that match the predicate
+    // */
+    // public List<ProtobufResponseContext<? extends TransportResponse>> prune(
+    // Predicate<ProtobufResponseContext<? extends TransportResponse>> predicate
+    // ) {
+    // final List<ProtobufResponseContext<? extends TransportResponse>> holders = new ArrayList<>();
+    // for (Map.Entry<Long, ProtobufResponseContext<? extends TransportResponse>> entry : handlers.entrySet()) {
+    // ProtobufResponseContext<? extends TransportResponse> holder = entry.getValue();
+    // if (predicate.test(holder)) {
+    // ProtobufResponseContext<? extends TransportResponse> remove = handlers.remove(entry.getKey());
+    // if (remove != null) {
+    // holders.add(holder);
+    // }
+    // }
+    // }
+    // return holders;
+    // }
+
+    // /**
+    // * called by the {@link Transport} implementation when a response or an exception has been received for a previously
+    // * sent request (before any processing or deserialization was done). Returns the appropriate response handler or null if not
+    // * found.
+    // */
+    // public ProtobufTransportResponseHandler<? extends TransportResponse> onResponseReceived(
+    // final long requestId,
+    // final ProtobufTransportMessageListener listener
+    // ) {
+    // ProtobufResponseContext<? extends TransportResponse> context = handlers.remove(requestId);
+    // listener.onResponseReceived(requestId, context);
+    // if (context == null) {
+    // return null;
+    // } else {
+    // return context.handler();
+    // }
+    // }
     // }
 
     /**
@@ -461,8 +461,8 @@ final class RequestHandlers {
 
         private volatile Map<String, RequestHandlerRegistry<? extends TransportRequest>> requestHandlers = Collections.emptyMap();
 
-        private volatile Map<String, ProtobufRequestHandlerRegistry<? extends TransportRequest>> protobufRequestHandlers =
-            Collections.emptyMap();
+        private volatile Map<String, ProtobufRequestHandlerRegistry<? extends TransportRequest>> protobufRequestHandlers = Collections
+            .emptyMap();
 
         synchronized <Request extends TransportRequest> void registerHandler(RequestHandlerRegistry<Request> reg) {
             if (requestHandlers.containsKey(reg.getAction())) {
@@ -490,8 +490,7 @@ public <T extends TransportRequest> RequestHandlerRegistry<T> getHandler(String
     */
     final class ProtobufRequestHandlers {
 
-        private volatile Map<String, ProtobufRequestHandlerRegistry<? extends TransportRequest>> requestHandlers = Collections
-            .emptyMap();
+        private volatile Map<String, ProtobufRequestHandlerRegistry<? extends TransportRequest>> requestHandlers = Collections.emptyMap();
 
         synchronized <Request extends TransportRequest> void registerHandler(ProtobufRequestHandlerRegistry<Request> reg) {
             if (requestHandlers.containsKey(reg.getAction())) {
diff --git a/server/src/main/java/org/opensearch/transport/TransportInterceptor.java b/server/src/main/java/org/opensearch/transport/TransportInterceptor.java
index 6ea5ed3f4f492..0d722c1748af3 100644
--- a/server/src/main/java/org/opensearch/transport/TransportInterceptor.java
+++ b/server/src/main/java/org/opensearch/transport/TransportInterceptor.java
@@ -97,27 +97,28 @@ <T extends TransportResponse> void sendRequest(
     }
 
     // /**
-    //  * This is called up-front providing the actual low level {@link AsyncSender} that performs the low level send request.
+    // * This is called up-front providing the actual low level {@link AsyncSender} that performs the low level send request.
     // * The returned sender is used to send all requests that come in via
     // * {@link TransportService#sendRequestProtobuf(DiscoveryNode, String, TransportRequest, TransportResponseHandler)} or
-    // * {@link TransportService#sendRequestProtobuf(DiscoveryNode, String, TransportRequest, TransportRequestOptions, TransportResponseHandler)}.
+    // * {@link TransportService#sendRequestProtobuf(DiscoveryNode, String, TransportRequest, TransportRequestOptions,
+    // TransportResponseHandler)}.
     // * This allows plugins to perform actions on each send request including modifying the request context etc.
     // */
     // default AsyncSenderProtobuf interceptSenderProotbuf(AsyncSenderProtobuf sender) {
-    //     return sender;
+    // return sender;
     // }
 
     // /**
-    //  * A simple interface to decorate
+    // * A simple interface to decorate
     // * {@link #sendRequest(Transport.Connection, String, TransportRequest, TransportRequestOptions, TransportResponseHandler)}
     // */
     // interface AsyncSenderProtobuf {
-    //     <T extends TransportResponse> void sendRequest(
-    //         Transport.Connection connection,
-    //         String action,
-    //         TransportRequest request,
-    //         TransportRequestOptions options,
-    //         TransportResponseHandler<T> handler
-    //     );
+    // <T extends TransportResponse> void sendRequest(
+    // Transport.Connection connection,
+    // String action,
+    // TransportRequest request,
+    // TransportRequestOptions options,
+    // TransportResponseHandler<T> handler
+    // );
     // }
 }
diff --git a/server/src/main/java/org/opensearch/transport/TransportMessage.java b/server/src/main/java/org/opensearch/transport/TransportMessage.java
index 66502662d1860..2a2ae65f8a693 100644
--- a/server/src/main/java/org/opensearch/transport/TransportMessage.java
+++ b/server/src/main/java/org/opensearch/transport/TransportMessage.java
@@ -65,8 +65,8 @@ public TransportMessage() {}
      */
     public TransportMessage(StreamInput in) {}
 
-     /**
-     * Constructs a new transport message with the data from the {@link byte[]}. This is
+    /**
+    * Constructs a new transport message with the data from the {@link byte[]}. This is
     * currently a no-op
     */
     public TransportMessage(byte[] in) {}
diff --git a/server/src/main/java/org/opensearch/transport/TransportRequest.java b/server/src/main/java/org/opensearch/transport/TransportRequest.java
index c13e6710d8ad4..a868476733208 100644
--- a/server/src/main/java/org/opensearch/transport/TransportRequest.java
+++ b/server/src/main/java/org/opensearch/transport/TransportRequest.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.transport;
 
-import org.opensearch.action.admin.cluster.state.ProtobufClusterStateRequest;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.tasks.ProtobufTaskAwareRequest;
@@ -113,8 +112,8 @@ public TaskId getParentTask() {
         return parentTaskId;
     }
 
-     /**
-     * Get a reference to the task that created this request. Defaults to {@link TaskId#EMPTY_TASK_ID}, meaning "there is no parent".
+    /**
+    * Get a reference to the task that created this request. Defaults to {@link TaskId#EMPTY_TASK_ID}, meaning "there is no parent".
     */
     @Override
     public ProtobufTaskId getProtobufParentTask() {
diff --git a/server/src/main/java/org/opensearch/transport/TransportService.java b/server/src/main/java/org/opensearch/transport/TransportService.java
index 1da343aeeaec8..6be50134ef0f0 100644
--- a/server/src/main/java/org/opensearch/transport/TransportService.java
+++ b/server/src/main/java/org/opensearch/transport/TransportService.java
@@ -39,7 +39,6 @@
 import org.opensearch.Version;
 import org.opensearch.action.ActionListener;
 import org.opensearch.action.ActionListenerResponseHandler;
-import org.opensearch.action.ProtobufActionListenerResponseHandler;
 import org.opensearch.action.support.PlainActionFuture;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.node.DiscoveryNode;
diff --git a/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java b/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java
index 2af8f395fcb34..d2dcf93134a4e 100644
--- a/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java
@@ -49,8 +49,6 @@
 import org.opensearch.common.lifecycle.LifecycleListener;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.ProtobufTransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.MockLogAppender;
@@ -59,21 +57,16 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ConnectTransportException;
 import org.opensearch.transport.ConnectionProfile;
-import org.opensearch.transport.ProtobufConnectionProfile;
-// import org.opensearch.transport.ProtobufTransportMessageListener;
 import org.opensearch.transport.TransportRequest;
-import org.opensearch.transport.ProtobufTransportStats;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportMessageListener;
-import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestOptions;
 import org.opensearch.transport.TransportService;
 import org.opensearch.transport.TransportStats;
 import org.junit.After;
 import org.junit.Before;
 
-import java.net.UnknownHostException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
@@ -695,71 +688,6 @@ public RequestHandlers getRequestHandlers() {
             return requestHandlers;
         }
 
-        // @Override
-        // public void setMessageListenerProtobuf(ProtobufTransportMessageListener listener) {}
-
-        // @Override
-        // public BoundTransportAddress boundProtobufAddress() {
-        //     return null;
-        // }
-
-        // @Override
-        // public Map<String, BoundTransportAddress> profileProtobufBoundAddresses() {
-        //     return null;
-        // }
-
-        // @Override
-        // public ProtobufTransportAddress[] addressesFromStringProtobuf(String address) throws UnknownHostException {
-        //     return new ProtobufTransportAddress[0];
-        // }
-
-        // @Override
-        // public void openProtobufConnection(
-        //     DiscoveryNode node,
-        //     ProtobufConnectionProfile profile,
-        //     ActionListener<ProtobufConnection> listener
-        // ) {
-        //     if (profile == null && randomConnectionExceptions && randomBoolean()) {
-        //         threadPool.generic().execute(() -> listener.onFailure(new ConnectTransportException(node, "simulated")));
-        //     } else {
-        //         threadPool.generic().execute(() -> listener.onResponse(new ProtobufConnection() {
-        //             @Override
-        //             public DiscoveryNode getNode() {
-        //                 return node;
-        //             }
-
-        //             @Override
-        //             public void sendRequest(
-        //                 long requestId,
-        //                 String action,
-        //                 TransportRequest request,
-        //                 TransportRequestOptions options
-        //             ) throws TransportException {}
-
-        //             @Override
-        //             public void addCloseListener(ActionListener<Void> listener) {}
-
-        //             @Override
-        //             public void close() {}
-
-        //             @Override
-        //             public boolean isClosed() {
-        //                 return false;
-        //             }
-        //         }));
-        //     }
-        // }
-
-        @Override
-        public ProtobufTransportStats getProtobufStats() {
-            throw new UnsupportedOperationException();
-        }
-
-        // @Override
-        // public ProtobufResponseHandlers getProtobufResponseHandlers() {
-        //     return protobufResponseHandlers;
-        // }
-
         @Override
         public ProtobufRequestHandlers getProtobufRequestHandlers() {
             return protobufRequestHandlers;
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/CoordinatorTests.java b/server/src/test/java/org/opensearch/cluster/coordination/CoordinatorTests.java
index da0e20fb0010e..8c9095cd78914 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/CoordinatorTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/CoordinatorTests.java
@@ -1443,7 +1443,7 @@ public void testSingleNodeDiscoveryStabilisesEvenWhenDisrupted() {
         }
     }
 
-    private static class BrokenCustom extends AbstractDiffable<ClusterState.Custom, ClusterState> implements ClusterState.Custom {
+    private static class BrokenCustom extends AbstractDiffable<ClusterState.Custom> implements ClusterState.Custom {
 
         static final String EXCEPTION_MESSAGE = "simulated";
 
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/NoOpClusterApplier.java b/server/src/test/java/org/opensearch/cluster/coordination/NoOpClusterApplier.java
index a8f3a5d7d4ec0..3dc35b88b4ff4 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/NoOpClusterApplier.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/NoOpClusterApplier.java
@@ -32,7 +32,6 @@
 package org.opensearch.cluster.coordination;
 
 import org.opensearch.cluster.ClusterState;
-import org.opensearch.cluster.ProtobufClusterState;
 import org.opensearch.cluster.service.ClusterApplier;
 
 import java.util.function.Supplier;
diff --git a/server/src/test/java/org/opensearch/cluster/serialization/DiffableTests.java b/server/src/test/java/org/opensearch/cluster/serialization/DiffableTests.java
index 326c0fe55163c..515c7c79b07c2 100644
--- a/server/src/test/java/org/opensearch/cluster/serialization/DiffableTests.java
+++ b/server/src/test/java/org/opensearch/cluster/serialization/DiffableTests.java
@@ -297,7 +297,7 @@ public String read(StreamInput in, K key) throws IOException {
         };
     }
 
-    public static class TestDiffable extends AbstractDiffable<TestDiffable, TestDiffable> {
+    public static class TestDiffable extends AbstractDiffable<TestDiffable> {
 
         private final String value;
 
diff --git a/server/src/test/java/org/opensearch/common/network/NetworkModuleTests.java b/server/src/test/java/org/opensearch/common/network/NetworkModuleTests.java
index f52efbe0c5848..958368ba4384a 100644
--- a/server/src/test/java/org/opensearch/common/network/NetworkModuleTests.java
+++ b/server/src/test/java/org/opensearch/common/network/NetworkModuleTests.java
@@ -45,8 +45,6 @@
 import org.opensearch.http.HttpServerTransport;
 import org.opensearch.http.HttpStats;
 import org.opensearch.http.NullDispatcher;
-import org.opensearch.http.ProtobufHttpInfo;
-import org.opensearch.http.ProtobufHttpStats;
 import org.opensearch.core.indices.breaker.CircuitBreakerService;
 import org.opensearch.plugins.NetworkPlugin;
 import org.opensearch.test.OpenSearchTestCase;
@@ -106,15 +104,6 @@ public HttpStats stats() {
             return null;
         }
 
-        @Override
-        public ProtobufHttpInfo protobufInfo() {
-            return null;
-        }
-
-        @Override
-        public ProtobufHttpStats protobufStats() {
-            return null;
-        }
     }
 
     public void testRegisterTransport() {
diff --git a/server/src/test/java/org/opensearch/index/shard/SegmentReplicationIndexShardTests.java b/server/src/test/java/org/opensearch/index/shard/SegmentReplicationIndexShardTests.java
index 12b7341349442..4bdad5aa78c25 100644
--- a/server/src/test/java/org/opensearch/index/shard/SegmentReplicationIndexShardTests.java
+++ b/server/src/test/java/org/opensearch/index/shard/SegmentReplicationIndexShardTests.java
@@ -104,7 +104,7 @@ protected Settings getIndexSettings() {
     /**
      * Validates happy path of segment replication where primary index docs which are replicated to replica shards. Assertions
      * made on doc count on both primary and replica.
-     * @throws Exception
+     * @throws Exception exception
      */
     public void testReplication() throws Exception {
         try (ReplicationGroup shards = createGroup(1, getIndexSettings(), indexMapping, new NRTReplicationEngineFactory());) {
diff --git a/server/src/test/java/org/opensearch/index/shard/SegmentReplicationWithNodeToNodeIndexShardTests.java b/server/src/test/java/org/opensearch/index/shard/SegmentReplicationWithNodeToNodeIndexShardTests.java
index 69846fbbe1dd4..1f40068c11da4 100644
--- a/server/src/test/java/org/opensearch/index/shard/SegmentReplicationWithNodeToNodeIndexShardTests.java
+++ b/server/src/test/java/org/opensearch/index/shard/SegmentReplicationWithNodeToNodeIndexShardTests.java
@@ -353,7 +353,7 @@ public void testReplicaReceivesGenIncrease() throws Exception {
     /**
      * Verifies that commits on replica engine resulting from engine or reader close does not cleanup the temporary
      * replication files from ongoing round of segment replication
-     * @throws Exception
+     * @throws Exception exception
      */
     public void testTemporaryFilesNotCleanup() throws Exception {
         String mappings = "{ \"" + MapperService.SINGLE_MAPPING_NAME + "\": { \"properties\": { \"foo\": { \"type\": \"keyword\"} }}}";
diff --git a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationSourceServiceTests.java b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationSourceServiceTests.java
index 85252473365f7..d56a02b7fd71f 100644
--- a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationSourceServiceTests.java
+++ b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationSourceServiceTests.java
@@ -301,6 +301,12 @@ public String executor() {
                 public CheckpointInfoResponse read(StreamInput in) throws IOException {
                     return new CheckpointInfoResponse(in);
                 }
+
+                @Override
+                public TransportResponse read(byte[] in) throws IOException {
+                    // TODO Auto-generated method stub
+                    throw new UnsupportedOperationException("Unimplemented method 'read'");
+                }
             }
         );
     }
diff --git a/server/src/test/java/org/opensearch/rest/RestControllerTests.java b/server/src/test/java/org/opensearch/rest/RestControllerTests.java
index 1d54ff6012da9..9c3ff07ab9555 100644
--- a/server/src/test/java/org/opensearch/rest/RestControllerTests.java
+++ b/server/src/test/java/org/opensearch/rest/RestControllerTests.java
@@ -54,8 +54,6 @@
 import org.opensearch.http.HttpServerTransport;
 import org.opensearch.http.HttpStats;
 import org.opensearch.identity.IdentityService;
-import org.opensearch.http.ProtobufHttpInfo;
-import org.opensearch.http.ProtobufHttpStats;
 import org.opensearch.indices.breaker.HierarchyCircuitBreakerService;
 import org.opensearch.rest.action.admin.indices.RestCreateIndexAction;
 import org.opensearch.test.OpenSearchTestCase;
@@ -694,15 +692,6 @@ public HttpStats stats() {
             return null;
         }
 
-        @Override
-        public ProtobufHttpInfo protobufInfo() {
-            return null;
-        }
-
-        @Override
-        public ProtobufHttpStats protobufStats() {
-            return null;
-        }
     }
 
     public static final class AssertingChannel extends AbstractRestChannel {
diff --git a/server/src/test/java/org/opensearch/transport/InboundPipelineTests.java b/server/src/test/java/org/opensearch/transport/InboundPipelineTests.java
index 9d9d2051e7382..d2c6fdcc588b4 100644
--- a/server/src/test/java/org/opensearch/transport/InboundPipelineTests.java
+++ b/server/src/test/java/org/opensearch/transport/InboundPipelineTests.java
@@ -105,7 +105,14 @@ public void testPipelineHandling() throws IOException {
         final TestCircuitBreaker circuitBreaker = new TestCircuitBreaker();
         circuitBreaker.startBreaking();
         final InboundAggregator aggregator = new InboundAggregator(() -> circuitBreaker, canTripBreaker);
-        final InboundPipeline pipeline = new InboundPipeline(statsTracker, millisSupplier, decoder, aggregator, messageHandler, messageHandlerProtobuf);
+        final InboundPipeline pipeline = new InboundPipeline(
+            statsTracker,
+            millisSupplier,
+            decoder,
+            aggregator,
+            messageHandler,
+            messageHandlerProtobuf
+        );
         final FakeTcpChannel channel = new FakeTcpChannel();
 
         final int iterations = randomIntBetween(5, 10);
@@ -222,7 +229,14 @@ public void testDecodeExceptionIsPropagated() throws IOException {
         final InboundDecoder decoder = new InboundDecoder(Version.CURRENT, PageCacheRecycler.NON_RECYCLING_INSTANCE);
         final Supplier<CircuitBreaker> breaker = () -> new NoopCircuitBreaker("test");
         final InboundAggregator aggregator = new InboundAggregator(breaker, (Predicate<String>) action -> true);
-        final InboundPipeline pipeline = new InboundPipeline(statsTracker, millisSupplier, decoder, aggregator, messageHandler, messageHandlerProtobuf);
+        final InboundPipeline pipeline = new InboundPipeline(
+            statsTracker,
+            millisSupplier,
+            decoder,
+            aggregator,
+            messageHandler,
+            messageHandlerProtobuf
+        );
 
         try (BytesStreamOutput streamOutput = new BytesStreamOutput()) {
             String actionName = "actionName";
@@ -277,7 +291,14 @@ public void testEnsureBodyIsNotPrematurelyReleased() throws IOException {
         final InboundDecoder decoder = new InboundDecoder(Version.CURRENT, PageCacheRecycler.NON_RECYCLING_INSTANCE);
         final Supplier<CircuitBreaker> breaker = () -> new NoopCircuitBreaker("test");
         final InboundAggregator aggregator = new InboundAggregator(breaker, (Predicate<String>) action -> true);
-        final InboundPipeline pipeline = new InboundPipeline(statsTracker, millisSupplier, decoder, aggregator, messageHandler, messageHandlerProtobuf);
+        final InboundPipeline pipeline = new InboundPipeline(
+            statsTracker,
+            millisSupplier,
+            decoder,
+            aggregator,
+            messageHandler,
+            messageHandlerProtobuf
+        );
 
         try (BytesStreamOutput streamOutput = new BytesStreamOutput()) {
             String actionName = "actionName";
diff --git a/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java b/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
index 268e689630231..c3d4a64b10baf 100644
--- a/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
+++ b/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
@@ -102,9 +102,7 @@ public void setUp() throws Exception {
             } catch (IOException e) {
                 throw new AssertionError(e);
             }
-        }, (c, m) -> {
-            protobufMessage.set(m);
-        });
+        }, (c, m) -> { protobufMessage.set(m); });
     }
 
     @After
diff --git a/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java b/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java
index 89f0ee6699bad..49eb893f78efe 100644
--- a/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java
@@ -57,7 +57,7 @@ public static class TestPlugin extends Plugin {}
         new TransportAddress[] { DUMMY_TRANSPORT_ADDRESS },
         DUMMY_TRANSPORT_ADDRESS
     );
-    
+
     private static final HttpInfo DUMMY_HTTP_INFO = new HttpInfo(DUMMY_BOUND_ADDRESS, 0);
     private static final HttpStats DUMMY_HTTP_STATS = new HttpStats(0, 0);
 
diff --git a/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java b/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
index 8932e9c59c434..8944c838c2cdc 100644
--- a/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
@@ -41,13 +41,10 @@
 import org.opensearch.transport.ConnectionProfile;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.Transport;
-import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportMessageListener;
 import org.opensearch.transport.TransportRequestOptions;
 import org.opensearch.transport.TransportStats;
 
-import java.io.IOException;
-import java.net.UnknownHostException;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
@@ -104,7 +101,7 @@ public void sendRequest(long requestId, String action, TransportRequest request,
 
             // @Override
             // public void sendRequestProtobuf(long requestId, String action, TransportRequest request,
-            //         TransportRequestOptions options) throws IOException, TransportException {
+            // TransportRequestOptions options) throws IOException, TransportException {
 
             // }
         });
diff --git a/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java b/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
index a1e49be32b0d7..71256e36a1b30 100644
--- a/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
@@ -282,9 +282,9 @@ public Transport.Connection getConnection() {
 
         // @Override
         // public void sendRequestProtobuf(long requestId, String action, TransportRequest request,
-        //         TransportRequestOptions options) throws IOException, TransportException {
-        //     // TODO Auto-generated method stub
-        //     throw new UnsupportedOperationException("Unimplemented method 'sendRequestProtobuf'");
+        // TransportRequestOptions options) throws IOException, TransportException {
+        // // TODO Auto-generated method stub
+        // throw new UnsupportedOperationException("Unimplemented method 'sendRequestProtobuf'");
         // }
     }
 

From d409e71b0561deb0c6e916a698ea5d4a59624b0d Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Thu, 3 Aug 2023 00:42:36 +0000
Subject: [PATCH 30/37] Cleaning up code

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../core/common/bytes/BytesArray.java         |   1 -
 .../action/ActionListenerResponseHandler.java |   1 -
 .../org/opensearch/action/ActionModule.java   |  14 --
 .../cluster/node/info/ProtobufNodeInfo.java   |  34 ----
 .../node/info/ProtobufNodesInfoRequest.java   |   5 -
 .../node/info/ProtobufNodesInfoResponse.java  |  24 ---
 .../node/info/TransportNodesInfoAction.java   |   3 +-
 .../cluster/state/ClusterStateRequest.java    |  16 --
 .../state/ProtobufClusterStateRequest.java    |  25 ---
 .../state/TransportClusterStateAction.java    |   1 +
 .../datastream/GetDataStreamAction.java       |   1 -
 .../admin/indices/rollover/RolloverInfo.java  |   1 -
 .../node/TransportBroadcastByNodeAction.java  |   1 -
 ...terManagerNodeOperationRequestBuilder.java |  75 -------
 ...anagerNodeReadOperationRequestBuilder.java |  42 ----
 .../client/ProtobufAdminClient.java           |  24 ---
 .../opensearch/cluster/AbstractDiffable.java  |   1 -
 .../org/opensearch/cluster/ClusterModule.java |   6 -
 .../org/opensearch/cluster/ProtobufDiff.java  |  24 ---
 .../opensearch/cluster/ProtobufDiffable.java  |  25 ---
 .../cluster/block/ClusterBlocks.java          |   1 -
 .../cluster/coordination/Coordinator.java     |   1 -
 .../PublicationTransportHandler.java          |   3 +-
 .../cluster/metadata/AliasMetadata.java       |   1 -
 .../cluster/metadata/ComponentTemplate.java   |   1 -
 .../metadata/ComposableIndexTemplate.java     |   1 -
 .../cluster/metadata/DataStream.java          |   1 -
 .../cluster/metadata/MappingMetadata.java     |   1 -
 .../opensearch/cluster/metadata/Template.java |   1 -
 .../cluster/node/DiscoveryNode.java           |   2 +-
 .../cluster/node/DiscoveryNodes.java          |   1 +
 .../service/ClusterApplierService.java        |   1 -
 .../common/network/NetworkModule.java         |  15 --
 .../org/opensearch/common/unit/SizeValue.java |   8 -
 .../extensions/ExtensionsManager.java         |   1 -
 .../rest/RestSendToExtensionAction.java       |   1 -
 .../index/seqno/RetentionLease.java           |   1 -
 .../index/seqno/RetentionLeaseStats.java      |   1 -
 .../index/warmer/ShardIndexWarmerService.java |   1 -
 .../ingest/PipelineConfiguration.java         |   2 -
 .../main/java/org/opensearch/node/Node.java   |  36 +---
 .../opensearch/node/ProtobufNodeService.java  |   7 -
 .../node/ProtobufReportingService.java        |  30 ---
 .../node/ResponseCollectorService.java        |  24 +++
 .../rest/ClientAgnosticRestHandler.java       |  27 ---
 .../rest/ProtobufDeprecationRestHandler.java  | 105 ----------
 .../org/opensearch/rest/RestBaseHandler.java  | 187 ------------------
 .../org/opensearch/rest/RestController.java   |  12 --
 .../rest/action/cat/RestNodesAction.java      |   1 +
 .../opensearch/script/StoredScriptSource.java |   1 -
 .../support/AggregationUsageService.java      |   1 -
 .../pipeline/PipelineConfiguration.java       |   1 -
 .../tasks/ProtobufCancellableTask.java        |   2 -
 .../org/opensearch/tasks/ProtobufTask.java    |   2 -
 .../tasks/ProtobufTaskAwareRequest.java       |   2 -
 .../org/opensearch/tasks/ProtobufTaskId.java  |   2 -
 .../opensearch/tasks/ProtobufTaskInfo.java    |   2 -
 .../tasks/ProtobufTaskResourceStats.java      |   2 -
 .../opensearch/tasks/ProtobufTaskResult.java  |   2 -
 .../org/opensearch/tasks/TaskManager.java     |  23 ---
 .../EmptyTransportResponseHandler.java        |   3 +-
 .../opensearch/transport/InboundHandler.java  |   1 -
 .../opensearch/transport/InboundMessage.java  |   1 -
 .../opensearch/transport/InboundPipeline.java |   1 -
 .../opensearch/transport/OutboundHandler.java |  41 +---
 .../opensearch/transport/OutboundMessage.java |  27 ---
 .../transport/ProtobufOutboundMessage.java    |   1 -
 .../transport/RemoteClusterService.java       |   3 -
 .../transport/RemoteConnectionManager.java    |   7 -
 .../org/opensearch/transport/TcpHeader.java   |   1 -
 .../opensearch/transport/TcpTransport.java    |  57 ------
 .../org/opensearch/transport/Transport.java   | 173 ----------------
 .../transport/TransportInterceptor.java       |  26 ---
 .../transport/TransportService.java           |   3 -
 .../cluster/NodeConnectionsServiceTests.java  |   1 -
 .../coordination/NoOpClusterApplier.java      |   5 -
 .../cluster/serialization/DiffableTests.java  |   1 -
 .../common/network/NetworkModuleTests.java    |   1 -
 .../opensearch/rest/RestControllerTests.java  |   1 -
 .../transport/OutboundHandlerTests.java       |   1 -
 .../opensearch/test/MockHttpTransport.java    |   2 -
 .../test/transport/FakeTransport.java         |   6 -
 .../test/transport/StubbableTransport.java    |   7 -
 83 files changed, 42 insertions(+), 1166 deletions(-)
 delete mode 100644 server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeOperationRequestBuilder.java
 delete mode 100644 server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadOperationRequestBuilder.java
 delete mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufDiff.java
 delete mode 100644 server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java
 delete mode 100644 server/src/main/java/org/opensearch/node/ProtobufReportingService.java
 delete mode 100644 server/src/main/java/org/opensearch/rest/ClientAgnosticRestHandler.java
 delete mode 100644 server/src/main/java/org/opensearch/rest/ProtobufDeprecationRestHandler.java
 delete mode 100644 server/src/main/java/org/opensearch/rest/RestBaseHandler.java

diff --git a/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesArray.java b/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesArray.java
index 39447b63f9730..ae04ddcc19eee 100644
--- a/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesArray.java
+++ b/libs/core/src/main/java/org/opensearch/core/common/bytes/BytesArray.java
@@ -143,5 +143,4 @@ public StreamInput streamInput() {
     public void writeTo(OutputStream os) throws IOException {
         os.write(bytes, offset, length);
     }
-
 }
diff --git a/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java b/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java
index fe98f7d373639..69d7ea9e4a3cc 100644
--- a/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java
+++ b/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java
@@ -36,7 +36,6 @@
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportResponseHandler;
-
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponse;
 
diff --git a/server/src/main/java/org/opensearch/action/ActionModule.java b/server/src/main/java/org/opensearch/action/ActionModule.java
index d12944ef59725..1b15a5fec8df1 100644
--- a/server/src/main/java/org/opensearch/action/ActionModule.java
+++ b/server/src/main/java/org/opensearch/action/ActionModule.java
@@ -1129,20 +1129,6 @@ public void initProtobufRestHandlers() {
 
         // CAT API
         registerHandler.accept(new ProtobufRestNodesAction());
-
-        // for (ActionPlugin plugin : actionPlugins) {
-        // for (ProtobufActionPlugin handler : plugin.getRestHandlers(
-        // settings,
-        // restController,
-        // clusterSettings,
-        // indexScopedSettings,
-        // settingsFilter,
-        // indexNameExpressionResolver,
-        // nodesInCluster
-        // )) {
-        // registerHandler.accept(handler);
-        // }
-        // }
         registerHandler.accept(new ProtobufRestCatAction(catActions));
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
index 830f4432149fc..7c6ac6606cb43 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodeInfo.java
@@ -22,7 +22,6 @@
 import org.opensearch.monitor.jvm.JvmInfo;
 import org.opensearch.monitor.os.OsInfo;
 import org.opensearch.monitor.process.ProcessInfo;
-import org.opensearch.node.ProtobufReportingService;
 import org.opensearch.search.aggregations.support.AggregationInfo;
 import org.opensearch.search.pipeline.SearchPipelineInfo;
 import org.opensearch.server.proto.NodesInfoProto;
@@ -31,8 +30,6 @@
 
 import java.io.IOException;
 import java.io.OutputStream;
-import java.util.HashMap;
-import java.util.Map;
 
 /**
  * Node information (static, does not change over time).
@@ -49,13 +46,6 @@ public class ProtobufNodeInfo extends ProtobufBaseNodeResponse {
 
     private NodesInfoProto.NodesInfo nodesInfoResponse;
 
-    /**
-     * Do not expose this map to other classes. For type safety, use {@link #getInfo(Class)}
-    * to retrieve items from this map and {@link #addInfoIfNonNull(Class, ProtobufReportingService.ProtobufInfo)}
-    * to retrieve items from it.
-    */
-    private Map<Class<? extends ProtobufReportingService.ProtobufInfo>, ProtobufReportingService.ProtobufInfo> infoMap = new HashMap<>();
-
     @Nullable
     private ByteSizeValue totalIndexingBuffer;
 
@@ -132,35 +122,11 @@ public Settings getSettings() {
         return this.settings;
     }
 
-    /**
-     * Get a particular info object, e.g. {@link JvmInfo} or {@link OsInfo}. This
-    * generic method handles all casting in order to spare client classes the
-    * work of explicit casts. This {@link NodeInfo} class guarantees type
-    * safety for these stored info blocks.
-    *
-    * @param clazz Class for retrieval.
-    * @param <T>   Specific subtype of ReportingService.ProtobufInfo to retrieve.
-    * @return      An object of type T.
-    */
-    public <T extends ProtobufReportingService.ProtobufInfo> T getInfo(Class<T> clazz) {
-        return clazz.cast(infoMap.get(clazz));
-    }
-
     @Nullable
     public ByteSizeValue getTotalIndexingBuffer() {
         return totalIndexingBuffer;
     }
 
-    /**
-     * Add a value to the map of information blocks. This method guarantees the
-    * type safety of the storage of heterogeneous types of reporting service information.
-    */
-    private <T extends ProtobufReportingService.ProtobufInfo> void addInfoIfNonNull(Class<T> clazz, T info) {
-        if (info != null) {
-            infoMap.put(clazz, info);
-        }
-    }
-
     public static ProtobufNodeInfo.Builder builder(Version version, Build build, DiscoveryNode node) {
         return new Builder(version, build, node);
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
index daa606f29559a..12c59b03189b2 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoRequest.java
@@ -6,11 +6,6 @@
  * compatible open source license.
  */
 
-/*
- * Modifications Copyright OpenSearch Contributors. See
- * GitHub history for details.
- */
-
 package org.opensearch.action.admin.cluster.node.info;
 
 import org.opensearch.action.support.nodes.ProtobufBaseNodesRequest;
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
index 716e74788a2f0..08d00d57084d7 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/ProtobufNodesInfoResponse.java
@@ -6,30 +6,6 @@
 * 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.action.admin.cluster.node.info;
 
 import org.opensearch.action.FailedNodeException;
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
index 64cd1a887ac12..2c4f8522a5a5c 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
@@ -106,7 +106,7 @@ protected NodeInfo newNodeResponse(StreamInput in) throws IOException {
     protected NodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
         NodesInfoRequest request = nodeRequest.request;
         Set<String> metrics = request.requestedMetrics();
-        NodeInfo nodeInfo = nodeService.info(
+        return nodeService.info(
             metrics.contains(NodesInfoRequest.Metric.SETTINGS.metricName()),
             metrics.contains(NodesInfoRequest.Metric.OS.metricName()),
             metrics.contains(NodesInfoRequest.Metric.PROCESS.metricName()),
@@ -120,7 +120,6 @@ protected NodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
             metrics.contains(NodesInfoRequest.Metric.INDICES.metricName()),
             metrics.contains(NodesInfoRequest.Metric.SEARCH_PIPELINES.metricName())
         );
-        return nodeInfo;
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateRequest.java
index c8cd4cab26708..bc6724d3081d6 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateRequest.java
@@ -209,20 +209,4 @@ public ClusterStateRequest waitForMetadataVersion(long waitForMetadataVersion) {
         this.waitForMetadataVersion = waitForMetadataVersion;
         return this;
     }
-
-    @Override
-    public String toString() {
-        StringBuilder builder = new StringBuilder();
-        builder.append("ClusterStateRequest[");
-        builder.append("routingTable=").append(routingTable());
-        builder.append(",nodes=").append(nodes());
-        builder.append(",metadata=").append(metadata());
-        builder.append(",blocks=").append(blocks());
-        builder.append(",customs=").append(customs());
-        builder.append(",indices=").append(indices());
-        builder.append(",indicesOptions=").append(indicesOptions());
-        builder.append(",waitForTimeout=").append(waitForTimeout());
-        builder.append(",waitForMetadataVersion=").append(waitForMetadataVersion());
-        return builder.append("]").toString();
-    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
index 59784af00a70b..9df8e80f4d336 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ProtobufClusterStateRequest.java
@@ -151,16 +151,6 @@ public ProtobufClusterStateRequest indices(String... indices) {
         return this;
     }
 
-    // @Override
-    // public IndicesOptions indicesOptions() {
-    // return this.clusterStateRequest.;
-    // }
-
-    // public final ProtobufClusterStateRequest indicesOptions(IndicesOptions indicesOptions) {
-    // this.indicesOptions = indicesOptions;
-    // return this;
-    // }
-
     @Override
     public boolean includeDataStreams() {
         return true;
@@ -210,21 +200,6 @@ public ProtobufClusterStateRequest waitForMetadataVersion(long waitForMetadataVe
         return this;
     }
 
-    @Override
-    public String toString() {
-        StringBuilder builder = new StringBuilder();
-        builder.append("ProtobufClusterStateRequest[");
-        builder.append("routingTable=").append(routingTable());
-        builder.append(",nodes=").append(nodes());
-        builder.append(",metadata=").append(metadata());
-        builder.append(",blocks=").append(blocks());
-        builder.append(",customs=").append(customs());
-        builder.append(",indices=").append(indices());
-        builder.append(",waitForTimeout=").append(waitForTimeout());
-        builder.append(",waitForMetadataVersion=").append(waitForMetadataVersion());
-        return builder.append("]").toString();
-    }
-
     @Override
     public IndicesOptions indicesOptions() {
         // TODO Auto-generated method stub
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
index 05e817b4e9339..e57d2cf1b9803 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
@@ -120,6 +120,7 @@ protected void clusterManagerOperation(
         final ClusterState state,
         final ActionListener<ClusterStateResponse> listener
     ) throws IOException {
+
         final Predicate<ClusterState> acceptableClusterStatePredicate = request.waitForMetadataVersion() == null
             ? clusterState -> true
             : clusterState -> clusterState.metadata().version() >= request.waitForMetadataVersion();
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/datastream/GetDataStreamAction.java b/server/src/main/java/org/opensearch/action/admin/indices/datastream/GetDataStreamAction.java
index 2013a50fb084f..543783b3de367 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/datastream/GetDataStreamAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/datastream/GetDataStreamAction.java
@@ -235,7 +235,6 @@ public boolean equals(Object o) {
             public int hashCode() {
                 return Objects.hash(dataStream, dataStreamStatus, indexTemplate);
             }
-
         }
 
         private final List<DataStreamInfo> dataStreams;
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverInfo.java b/server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverInfo.java
index e64a3ff5a4de0..f58c842be374b 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverInfo.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/rollover/RolloverInfo.java
@@ -151,5 +151,4 @@ public boolean equals(Object obj) {
     public String toString() {
         return Strings.toString(XContentType.JSON, this);
     }
-
 }
diff --git a/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java b/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
index 754194734bc52..308da88f99d27 100644
--- a/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
@@ -66,7 +66,6 @@
 import org.opensearch.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
-
 import org.opensearch.transport.TransportRequestOptions;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeOperationRequestBuilder.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeOperationRequestBuilder.java
deleted file mode 100644
index 99713bdc02969..0000000000000
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeOperationRequestBuilder.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.action.support.clustermanager;
-
-import org.opensearch.action.ProtobufActionRequestBuilder;
-import org.opensearch.action.ProtobufActionResponse;
-import org.opensearch.action.ProtobufActionType;
-import org.opensearch.client.ProtobufOpenSearchClient;
-import org.opensearch.common.unit.TimeValue;
-
-/**
- * Base request builder for cluster-manager node operations
-*
-* @opensearch.internal
-*/
-public abstract class ProtobufClusterManagerNodeOperationRequestBuilder<
-    Request extends ProtobufClusterManagerNodeRequest<Request>,
-    Response extends ProtobufActionResponse,
-    RequestBuilder extends ProtobufClusterManagerNodeOperationRequestBuilder<Request, Response, RequestBuilder>> extends
-    ProtobufActionRequestBuilder<Request, Response> {
-
-    protected ProtobufClusterManagerNodeOperationRequestBuilder(
-        ProtobufOpenSearchClient client,
-        ProtobufActionType<Response> action,
-        Request request
-    ) {
-        super(client, action, request);
-    }
-
-    /**
-     * Sets the cluster-manager node timeout in case the cluster-manager has not yet been discovered.
-    */
-    @SuppressWarnings("unchecked")
-    public final RequestBuilder setClusterManagerNodeTimeout(TimeValue timeout) {
-        request.clusterManagerNodeTimeout(timeout);
-        return (RequestBuilder) this;
-    }
-
-    /**
-     * Sets the cluster-manager node timeout in case the cluster-manager has not yet been discovered.
-    *
-    * @deprecated As of 2.1, because supporting inclusive language, replaced by {@link #setClusterManagerNodeTimeout(TimeValue)}
-    */
-    @SuppressWarnings("unchecked")
-    @Deprecated
-    public final RequestBuilder setMasterNodeTimeout(TimeValue timeout) {
-        return setClusterManagerNodeTimeout(timeout);
-    }
-
-    /**
-     * Sets the cluster-manager node timeout in case the cluster-manager has not yet been discovered.
-    */
-    @SuppressWarnings("unchecked")
-    public final RequestBuilder setClusterManagerNodeTimeout(String timeout) {
-        request.clusterManagerNodeTimeout(timeout);
-        return (RequestBuilder) this;
-    }
-
-    /**
-     * Sets the cluster-manager node timeout in case the cluster-manager has not yet been discovered.
-    *
-    * @deprecated As of 2.1, because supporting inclusive language, replaced by {@link #setClusterManagerNodeTimeout(String)}
-    */
-    @SuppressWarnings("unchecked")
-    @Deprecated
-    public final RequestBuilder setMasterNodeTimeout(String timeout) {
-        return setClusterManagerNodeTimeout(timeout);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadOperationRequestBuilder.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadOperationRequestBuilder.java
deleted file mode 100644
index 18c270292d135..0000000000000
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ProtobufClusterManagerNodeReadOperationRequestBuilder.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.action.support.clustermanager;
-
-import org.opensearch.action.ProtobufActionResponse;
-import org.opensearch.action.ProtobufActionType;
-import org.opensearch.client.ProtobufOpenSearchClient;
-
-/**
- * Base request builder for cluster-manager node read operations that can be executed on the local node as well
-*
-* @opensearch.internal
-*/
-public abstract class ProtobufClusterManagerNodeReadOperationRequestBuilder<
-    Request extends ProtobufClusterManagerNodeReadRequest<Request>,
-    Response extends ProtobufActionResponse,
-    RequestBuilder extends ProtobufClusterManagerNodeReadOperationRequestBuilder<Request, Response, RequestBuilder>> extends
-    ProtobufClusterManagerNodeOperationRequestBuilder<Request, Response, RequestBuilder> {
-
-    protected ProtobufClusterManagerNodeReadOperationRequestBuilder(
-        ProtobufOpenSearchClient client,
-        ProtobufActionType<Response> action,
-        Request request
-    ) {
-        super(client, action, request);
-    }
-
-    /**
-     * Specifies if the request should be executed on local node rather than on master
-    */
-    @SuppressWarnings("unchecked")
-    public final RequestBuilder setLocal(boolean local) {
-        request.local(local);
-        return (RequestBuilder) this;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/client/ProtobufAdminClient.java b/server/src/main/java/org/opensearch/client/ProtobufAdminClient.java
index 81cda3c4bc3b9..2b3ab327d1829 100644
--- a/server/src/main/java/org/opensearch/client/ProtobufAdminClient.java
+++ b/server/src/main/java/org/opensearch/client/ProtobufAdminClient.java
@@ -6,30 +6,6 @@
 * 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.client;
 
 /**
diff --git a/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java b/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java
index 6350b888e503f..74af3472433ba 100644
--- a/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java
+++ b/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java
@@ -109,5 +109,4 @@ public T apply(T part) {
             }
         }
     }
-
 }
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterModule.java b/server/src/main/java/org/opensearch/cluster/ClusterModule.java
index bd34d75c30c84..a0f20adf154c4 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterModule.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterModule.java
@@ -151,7 +151,6 @@ public ClusterModule(
         this.shardsAllocator = createShardsAllocator(settings, clusterService.getClusterSettings(), clusterPlugins);
         this.clusterService = clusterService;
         this.indexNameExpressionResolver = new IndexNameExpressionResolver(threadContext);
-        // this.protobufIndexNameExpressionResolver = new ProtobufIndexNameExpressionResolver(threadContext);
         this.allocationService = new AllocationService(allocationDeciders, shardsAllocator, clusterInfoService, snapshotsInfoService);
     }
 
@@ -344,10 +343,6 @@ public IndexNameExpressionResolver getIndexNameExpressionResolver() {
         return indexNameExpressionResolver;
     }
 
-    // public ProtobufIndexNameExpressionResolver getProtobufIndexNameExpressionResolver() {
-    // return protobufIndexNameExpressionResolver;
-    // }
-
     // TODO: this is public so allocation benchmark can access the default deciders...can we do that in another way?
     /** Return a new {@link AllocationDecider} instance with builtin deciders as well as those from plugins. */
     public static Collection<AllocationDecider> createAllocationDeciders(
@@ -431,7 +426,6 @@ protected void configure() {
         bind(MetadataUpdateSettingsService.class).asEagerSingleton();
         bind(MetadataIndexTemplateService.class).asEagerSingleton();
         bind(IndexNameExpressionResolver.class).toInstance(indexNameExpressionResolver);
-        // bind(ProtobufIndexNameExpressionResolver.class).toInstance(protobufIndexNameExpressionResolver);
         bind(DelayedAllocationService.class).asEagerSingleton();
         bind(ShardStateAction.class).asEagerSingleton();
         bind(NodeMappingRefreshAction.class).asEagerSingleton();
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufDiff.java b/server/src/main/java/org/opensearch/cluster/ProtobufDiff.java
deleted file mode 100644
index 0ac12cb4718c0..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/ProtobufDiff.java
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.cluster;
-
-import org.opensearch.core.common.io.stream.ProtobufWriteable;
-
-/**
- * Represents difference between states of cluster state parts
-*
-* @opensearch.internal
-*/
-public interface ProtobufDiff<T> extends ProtobufWriteable {
-
-    /**
-     * Applies difference to the specified part and returns the resulted part
-    */
-    T apply(T part);
-}
diff --git a/server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java b/server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java
deleted file mode 100644
index 26c9987871240..0000000000000
--- a/server/src/main/java/org/opensearch/cluster/ProtobufDiffable.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.cluster;
-
-import org.opensearch.core.common.io.stream.ProtobufWriteable;
-
-/**
- * Cluster state part, changes in which can be serialized
-*
-* @opensearch.internal
-*/
-public interface ProtobufDiffable<T> extends ProtobufWriteable {
-
-    /**
-     * Returns serializable object representing differences between this and previousState
-    */
-    ProtobufDiff<T> protobufDiff(T previousState);
-
-}
diff --git a/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java b/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java
index 40ce43b748cc9..33d55e6e747a3 100644
--- a/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java
+++ b/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java
@@ -478,5 +478,4 @@ public ClusterBlocks build() {
             return new ClusterBlocks(unmodifiableSet(new HashSet<>(global)), indicesBuilder);
         }
     }
-
 }
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
index 37240141705a6..1c38e68c43466 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
@@ -611,7 +611,6 @@ private void handleJoinRequest(JoinRequest joinRequest, JoinHelper.JoinCallback
                 processJoinRequest(joinRequest, joinCallback);
             }
         }, joinCallback::onFailure));
-
     }
 
     // package private for tests
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java b/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
index 87a5ca8d53f5c..41a54fda7cfc2 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
@@ -52,7 +52,6 @@
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequestOptions;
 import org.opensearch.transport.TransportResponse;
-import org.opensearch.transport.TransportResponse.Empty;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
@@ -383,7 +382,7 @@ public String executor() {
                     }
 
                     @Override
-                    public Empty read(byte[] in) throws IOException {
+                    public TransportResponse.Empty read(byte[] in) throws IOException {
                         // TODO Auto-generated method stub
                         throw new UnsupportedOperationException("Unimplemented method 'read'");
                     }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/AliasMetadata.java b/server/src/main/java/org/opensearch/cluster/metadata/AliasMetadata.java
index 78a4b34c18318..27ecca0358bd8 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/AliasMetadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/AliasMetadata.java
@@ -431,5 +431,4 @@ public static AliasMetadata fromXContent(XContentParser parser) throws IOExcepti
             return builder.build();
         }
     }
-
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/ComponentTemplate.java b/server/src/main/java/org/opensearch/cluster/metadata/ComponentTemplate.java
index 00babadfc351a..52096422248a5 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/ComponentTemplate.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/ComponentTemplate.java
@@ -168,5 +168,4 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         builder.endObject();
         return builder;
     }
-
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java b/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java
index 37294b3f8ce46..15e5cb5873719 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java
@@ -358,5 +358,4 @@ public int hashCode() {
             return Objects.hash(timestampField);
         }
     }
-
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/DataStream.java b/server/src/main/java/org/opensearch/cluster/metadata/DataStream.java
index edf5d65fea2ad..76e1a0197bc1c 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/DataStream.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/DataStream.java
@@ -318,5 +318,4 @@ public int hashCode() {
             return Objects.hash(name);
         }
     }
-
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/MappingMetadata.java b/server/src/main/java/org/opensearch/cluster/metadata/MappingMetadata.java
index 162c1d5a38b40..c77d2d6b8b2b3 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/MappingMetadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/MappingMetadata.java
@@ -191,5 +191,4 @@ public MappingMetadata(StreamInput in) throws IOException {
     public static Diff<MappingMetadata> readDiffFrom(StreamInput in) throws IOException {
         return readDiffFrom(MappingMetadata::new, in);
     }
-
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/Template.java b/server/src/main/java/org/opensearch/cluster/metadata/Template.java
index f48dc1ab2a9ef..45d11dd9250e8 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/Template.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/Template.java
@@ -214,5 +214,4 @@ private static Map<String, Object> reduceMapping(Map<String, Object> mapping) {
             return mapping;
         }
     }
-
 }
diff --git a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
index 4fca11bd88447..d6ba0199d193c 100644
--- a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
+++ b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
@@ -545,7 +545,7 @@ private static Map<String, DiscoveryNodeRole> rolesToMap(final Stream<DiscoveryN
         return Collections.unmodifiableMap(roles.collect(Collectors.toMap(DiscoveryNodeRole::roleName, Function.identity())));
     }
 
-    public static Map<String, DiscoveryNodeRole> roleMap = rolesToMap(DiscoveryNodeRole.BUILT_IN_ROLES.stream());
+    private static Map<String, DiscoveryNodeRole> roleMap = rolesToMap(DiscoveryNodeRole.BUILT_IN_ROLES.stream());
 
     public static DiscoveryNodeRole getRoleFromRoleName(final String roleName) {
         // As we are supporting dynamic role, should make role name case-insensitive to avoid confusion of role name like "Data"/"DATA"
diff --git a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java
index b20519ae644fa..060c7c5eb8d1a 100644
--- a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java
+++ b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java
@@ -43,6 +43,7 @@
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.util.set.Sets;
 import org.opensearch.core.common.Strings;
+
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java b/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
index 219477ea15c67..c03f5ae619edf 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
@@ -123,7 +123,6 @@ public ClusterApplierService(String nodeName, Settings settings, ClusterSettings
         this.clusterSettings = clusterSettings;
         this.threadPool = threadPool;
         this.state = new AtomicReference<>();
-        // this.protobufState = new AtomicReference<>();
         this.nodeName = nodeName;
 
         this.slowTaskLoggingThreshold = CLUSTER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING.get(settings);
diff --git a/server/src/main/java/org/opensearch/common/network/NetworkModule.java b/server/src/main/java/org/opensearch/common/network/NetworkModule.java
index 2f4e8799d239d..8829d6035be31 100644
--- a/server/src/main/java/org/opensearch/common/network/NetworkModule.java
+++ b/server/src/main/java/org/opensearch/common/network/NetworkModule.java
@@ -318,21 +318,6 @@ public AsyncSender interceptSender(AsyncSender sender) {
         }
     }
 
-    // /**
-    // * Registers a new {@link TransportInterceptor}
-    // */
-    // private void registerTransportInterceptor(TransportInterceptor interceptor) {
-    // this.TransportInterceptors.add(Objects.requireNonNull(interceptor, "interceptor must not be null"));
-    // }
-
-    // /**
-    // * Returns a composite {@link TransportInterceptor} containing all registered interceptors
-    // * @see #registerTransportInterceptor(TransportInterceptor)
-    // */
-    // public TransportInterceptor getTransportInterceptor() {
-    // return new ProtobufCompositeTransportInterceptor(this.TransportInterceptors);
-    // }
-
     static final class ProtobufCompositeTransportInterceptor implements TransportInterceptor {
         final List<TransportInterceptor> transportInterceptors;
 
diff --git a/server/src/main/java/org/opensearch/common/unit/SizeValue.java b/server/src/main/java/org/opensearch/common/unit/SizeValue.java
index 7e499f5860a7f..766199ebbc8f8 100644
--- a/server/src/main/java/org/opensearch/common/unit/SizeValue.java
+++ b/server/src/main/java/org/opensearch/common/unit/SizeValue.java
@@ -72,14 +72,6 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeVLong(singles());
     }
 
-    public long getSize() {
-        return size;
-    }
-
-    public SizeUnit getSizeUnit() {
-        return sizeUnit;
-    }
-
     public long singles() {
         return sizeUnit.toSingles(size);
     }
diff --git a/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java b/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
index edef4d0b13605..ea13cfc324734 100644
--- a/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
+++ b/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
@@ -55,7 +55,6 @@
 import org.opensearch.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
-
 import org.opensearch.env.EnvironmentSettingsResponse;
 
 /**
diff --git a/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java b/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java
index eb7b4ce81a59e..6368bd7ff8da8 100644
--- a/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java
+++ b/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java
@@ -27,7 +27,6 @@
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
-
 import org.opensearch.http.HttpRequest;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java
index 620e7dc70c66b..5d4483e4a2930 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLease.java
@@ -40,7 +40,6 @@
 import org.opensearch.core.xcontent.ToXContentObject;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
-
 import org.opensearch.core.xcontent.XContent;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java
index bf5f3a7943b00..a1ed615b83a14 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseStats.java
@@ -37,7 +37,6 @@
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
-
 import org.opensearch.core.xcontent.XContent;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/index/warmer/ShardIndexWarmerService.java b/server/src/main/java/org/opensearch/index/warmer/ShardIndexWarmerService.java
index 099b55dd52d03..ff8f31297d47d 100644
--- a/server/src/main/java/org/opensearch/index/warmer/ShardIndexWarmerService.java
+++ b/server/src/main/java/org/opensearch/index/warmer/ShardIndexWarmerService.java
@@ -71,5 +71,4 @@ public void onPostWarm(long tookInNanos) {
     public WarmerStats stats() {
         return new WarmerStats(current.count(), warmerMetric.count(), TimeUnit.NANOSECONDS.toMillis(warmerMetric.sum()));
     }
-
 }
diff --git a/server/src/main/java/org/opensearch/ingest/PipelineConfiguration.java b/server/src/main/java/org/opensearch/ingest/PipelineConfiguration.java
index 40a78bce2bf02..3b918592053c1 100644
--- a/server/src/main/java/org/opensearch/ingest/PipelineConfiguration.java
+++ b/server/src/main/java/org/opensearch/ingest/PipelineConfiguration.java
@@ -45,7 +45,6 @@
 import org.opensearch.core.xcontent.ObjectParser;
 import org.opensearch.core.xcontent.ToXContentObject;
 import org.opensearch.core.xcontent.XContentBuilder;
-
 import org.opensearch.common.xcontent.XContentHelper;
 import org.opensearch.common.xcontent.XContentType;
 
@@ -184,5 +183,4 @@ public int hashCode() {
         result = 31 * result + getConfigAsMap().hashCode();
         return result;
     }
-
 }
diff --git a/server/src/main/java/org/opensearch/node/Node.java b/server/src/main/java/org/opensearch/node/Node.java
index afb0daf14a591..acdbcc1b5bb7a 100644
--- a/server/src/main/java/org/opensearch/node/Node.java
+++ b/server/src/main/java/org/opensearch/node/Node.java
@@ -228,8 +228,6 @@
 import org.opensearch.tasks.TaskResultsService;
 import org.opensearch.threadpool.ExecutorBuilder;
 import org.opensearch.threadpool.ThreadPool;
-// import org.opensearch.transport.ProtobufTransportInterceptor;
-// import org.opensearch.transport.ProtobufTransportService;
 import org.opensearch.transport.RemoteClusterService;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportInterceptor;
@@ -812,21 +810,6 @@ protected Node(
                 )
                 .collect(Collectors.toList());
 
-            // ActionModule actionModule = new ActionModule(
-            // settings,
-            // clusterModule.getIndexNameExpressionResolver(),
-            // settingsModule.getIndexScopedSettings(),
-            // settingsModule.getClusterSettings(),
-            // settingsModule.getSettingsFilter(),
-            // threadPool,
-            // pluginsService.filterPlugins(ActionPlugin.class),
-            // client,
-            // circuitBreakerService,
-            // usageService,
-            // systemIndices
-            // );
-            // modules.add(actionModule);
-
             ActionModule protobufActionModule = new ActionModule(
                 settings,
                 clusterModule.getIndexNameExpressionResolver(),
@@ -894,16 +877,14 @@ protected Node(
             );
             TopNSearchTasksLogger taskConsumer = new TopNSearchTasksLogger(settings, settingsModule.getClusterSettings());
             transportService.getTaskManager().registerTaskResourceConsumer(taskConsumer);
-            // if (FeatureFlags.isEnabled(FeatureFlags.EXTENSIONS)) {
-            // this.extensionsManager.initializeServicesAndRestHandler(
-            // actionModule,
-            // settingsModule,
-            // transportService,
-            // clusterService,
-            // environment.settings(),
-            // client
-            // );
-            // }
+            this.extensionsManager.initializeServicesAndRestHandler(
+                protobufActionModule,
+                settingsModule,
+                transportService,
+                clusterService,
+                environment.settings(),
+                client
+            );
             final GatewayMetaState gatewayMetaState = new GatewayMetaState();
             final ResponseCollectorService responseCollectorService = new ResponseCollectorService(clusterService);
             final SearchTransportService searchTransportService = new SearchTransportService(
@@ -1162,7 +1143,6 @@ protected Node(
                     .toInstance(new SearchPhaseController(namedWriteableRegistry, searchService::aggReduceContextBuilder));
                 b.bind(Transport.class).toInstance(transport);
                 b.bind(TransportService.class).toInstance(transportService);
-                // b.bind(ProtobufTransportService.class).toInstance(protobufTransportService);
                 b.bind(NetworkService.class).toInstance(networkService);
                 b.bind(UpdateHelper.class).toInstance(new UpdateHelper(scriptService));
                 b.bind(MetadataIndexUpgradeService.class).toInstance(metadataIndexUpgradeService);
diff --git a/server/src/main/java/org/opensearch/node/ProtobufNodeService.java b/server/src/main/java/org/opensearch/node/ProtobufNodeService.java
index c7cc351fce7cd..7c2a1554c6ef9 100644
--- a/server/src/main/java/org/opensearch/node/ProtobufNodeService.java
+++ b/server/src/main/java/org/opensearch/node/ProtobufNodeService.java
@@ -206,13 +206,6 @@ public ProtobufNodeStats stats(
             discoveryStats ? discovery.stats() : null,
             ingest ? ingestService.stats() : null,
             adaptiveSelection ? responseCollectorService.getAdaptiveStats(searchTransportService.getPendingSearchRequests()) : null
-            // scriptCache ? scriptService.cacheStats() : null,
-            // indexingPressure ? this.indexingPressureService.nodeStats() : null,
-            // shardIndexingPressure ? this.indexingPressureService.shardStats(indices) : null,
-            // searchBackpressure ? this.searchBackpressureService.nodeStats() : null,
-            // clusterManagerThrottling ? this.clusterService.getClusterManagerService().getThrottlingStats() : null,
-            // weightedRoutingStats ? WeightedRoutingStats.getInstance() : null,
-            // fileCacheStats && fileCache != null ? fileCache.fileCacheStats() : null
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/node/ProtobufReportingService.java b/server/src/main/java/org/opensearch/node/ProtobufReportingService.java
deleted file mode 100644
index dc2648adaae27..0000000000000
--- a/server/src/main/java/org/opensearch/node/ProtobufReportingService.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.node;
-
-import org.opensearch.core.common.io.stream.ProtobufWriteable;
-import org.opensearch.core.xcontent.ToXContent;
-
-/**
- * Node reporting service
-*
-* @opensearch.internal
-*/
-public interface ProtobufReportingService<I extends ProtobufReportingService.ProtobufInfo> {
-    I protobufInfo();
-
-    /**
-     * Information interface.
-    *
-    * @opensearch.internal
-    */
-    interface ProtobufInfo extends ProtobufWriteable, ToXContent {
-
-    }
-}
diff --git a/server/src/main/java/org/opensearch/node/ResponseCollectorService.java b/server/src/main/java/org/opensearch/node/ResponseCollectorService.java
index 011f74d8a96e5..90cdba94901da 100644
--- a/server/src/main/java/org/opensearch/node/ResponseCollectorService.java
+++ b/server/src/main/java/org/opensearch/node/ResponseCollectorService.java
@@ -6,6 +6,30 @@
  * 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.node;
 
 import org.opensearch.cluster.ClusterChangedEvent;
diff --git a/server/src/main/java/org/opensearch/rest/ClientAgnosticRestHandler.java b/server/src/main/java/org/opensearch/rest/ClientAgnosticRestHandler.java
deleted file mode 100644
index f37b1f3cee272..0000000000000
--- a/server/src/main/java/org/opensearch/rest/ClientAgnosticRestHandler.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.rest;
-
-/**
- * Handler for REST requests
-*
-* @opensearch.api
-*/
-@FunctionalInterface
-public interface ClientAgnosticRestHandler<T> {
-
-    /**
-     * Handles a rest request.
-    * @param request The request to handle
-    * @param channel The channel to write the request response to
-    * @param client A client to use to make internal requests on behalf of the original request
-    */
-    void handleRequest(RestRequest request, RestChannel channel, T client) throws Exception;
-
-}
diff --git a/server/src/main/java/org/opensearch/rest/ProtobufDeprecationRestHandler.java b/server/src/main/java/org/opensearch/rest/ProtobufDeprecationRestHandler.java
deleted file mode 100644
index 01b4b9240a136..0000000000000
--- a/server/src/main/java/org/opensearch/rest/ProtobufDeprecationRestHandler.java
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * 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.
- */
-
-package org.opensearch.rest;
-
-import org.opensearch.client.node.ProtobufNodeClient;
-import org.opensearch.core.common.Strings;
-import org.opensearch.common.logging.DeprecationLogger;
-
-import java.util.Objects;
-
-/**
- * {@code ProtobufDeprecationRestHandler} provides a proxy for any existing {@link ProtobufRestHandler} so that usage of the handler can be
- * logged using the {@link DeprecationLogger}.
- *
- * @opensearch.api
- */
-public class ProtobufDeprecationRestHandler implements ProtobufRestHandler {
-
-    private final ProtobufRestHandler handler;
-    private final String deprecationMessage;
-    private final DeprecationLogger deprecationLogger;
-
-    /**
-     * Create a {@link ProtobufDeprecationRestHandler} that encapsulates the {@code handler} using the {@code deprecationLogger} to log
-     * deprecation {@code warning}.
-     *
-     * @param handler The rest handler to deprecate (it's possible that the handler is reused with a different name!)
-     * @param deprecationMessage The message to warn users with when they use the {@code handler}
-     * @param deprecationLogger The deprecation logger
-     * @throws NullPointerException if any parameter except {@code deprecationMessage} is {@code null}
-     * @throws IllegalArgumentException if {@code deprecationMessage} is not a valid header
-     */
-    public ProtobufDeprecationRestHandler(ProtobufRestHandler handler, String deprecationMessage, DeprecationLogger deprecationLogger) {
-        this.handler = Objects.requireNonNull(handler);
-        this.deprecationMessage = requireValidHeader(deprecationMessage);
-        this.deprecationLogger = Objects.requireNonNull(deprecationLogger);
-    }
-
-    /**
-     * {@inheritDoc}
-     * <p>
-     * Usage is logged via the {@link DeprecationLogger} so that the actual response can be notified of deprecation as well.
-     */
-    @Override
-    public void handleRequest(RestRequest request, RestChannel channel, ProtobufNodeClient client) throws Exception {
-        deprecationLogger.deprecate("deprecated_route", deprecationMessage);
-
-        handler.handleRequest(request, channel, client);
-    }
-
-    @Override
-    public boolean supportsContentStream() {
-        return handler.supportsContentStream();
-    }
-
-    /**
-     * This does a very basic pass at validating that a header's value contains only expected characters according to RFC-5987, and those
-     * that it references.
-     * <p>
-     * https://tools.ietf.org/html/rfc5987
-     * <p>
-     * This is only expected to be used for assertions. The idea is that only readable US-ASCII characters are expected; the rest must be
-     * encoded with percent encoding, which makes checking for a valid character range very simple.
-     *
-     * @param value The header value to check
-     * @return {@code true} if the {@code value} is not obviously wrong.
-     */
-    public static boolean validHeaderValue(String value) {
-        if (Strings.hasText(value) == false) {
-            return false;
-        }
-
-        for (int i = 0; i < value.length(); i++) {
-            char c = value.charAt(i);
-
-            // 32 = ' ' (31 = unit separator); 126 = '~' (127 = DEL)
-            if (c < 32 || c > 126) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    /**
-     * Throw an exception if the {@code value} is not a {@link #validHeaderValue(String) valid header}.
-     *
-     * @param value The header value to check
-     * @return Always {@code value}.
-     * @throws IllegalArgumentException if {@code value} is not a {@link #validHeaderValue(String) valid header}.
-     */
-    public static String requireValidHeader(String value) {
-        if (validHeaderValue(value) == false) {
-            throw new IllegalArgumentException("header value must contain only US ASCII text");
-        }
-
-        return value;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/rest/RestBaseHandler.java b/server/src/main/java/org/opensearch/rest/RestBaseHandler.java
deleted file mode 100644
index cb9a39f394a5f..0000000000000
--- a/server/src/main/java/org/opensearch/rest/RestBaseHandler.java
+++ /dev/null
@@ -1,187 +0,0 @@
-/*
-* 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.
-*/
-
-package org.opensearch.rest;
-
-import org.opensearch.core.xcontent.XContent;
-import org.opensearch.rest.RestRequest.Method;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.stream.Collectors;
-
-/**
- * Handler for REST requests
-*
-* @opensearch.api
-*/
-@FunctionalInterface
-public interface RestBaseHandler<T> {
-
-    /**
-     * Handles a rest request.
-    * @param request The request to handle
-    * @param channel The channel to write the request response to
-    * @param client A client to use to make internal requests on behalf of the original request
-    */
-    void handleRequest(RestRequest request, RestChannel channel, T client) throws Exception;
-
-    default boolean canTripCircuitBreaker() {
-        return true;
-    }
-
-    /**
-     * Indicates if the RestHandler supports content as a stream. A stream would be multiple objects delineated by
-     * {@link XContent#streamSeparator()}. If a handler returns true this will affect the types of content that can be sent to
-     * this endpoint.
-     */
-    default boolean supportsContentStream() {
-        return false;
-    }
-
-    /**
-     * Indicates if the RestHandler supports working with pooled buffers. If the request handler will not escape the return
-     * {@link RestRequest#content()} or any buffers extracted from it then there is no need to make a copies of any pooled buffers in the
-     * {@link RestRequest} instance before passing a request to this handler. If this instance does not support pooled/unsafe buffers
-     * {@link RestRequest#ensureSafeBuffers()} should be called on any request before passing it to {@link #handleRequest}.
-     *
-     * @return true iff the handler supports requests that make use of pooled buffers
-     */
-    default boolean allowsUnsafeBuffers() {
-        return false;
-    }
-
-    // /**
-    // * The list of {@link Route}s that this RestHandler is responsible for handling.
-    // */
-    // default List<Route> routes() {
-    // return Collections.emptyList();
-    // }
-
-    /**
-     * A list of routes handled by this RestHandler that are deprecated and do not have a direct
-     * replacement. If changing the {@code path} or {@code method} of a route,
-     * use {@link #replacedRoutes()}.
-     */
-    default List<DeprecatedRoute> deprecatedRoutes() {
-        return Collections.emptyList();
-    }
-
-    /**
-     * A list of routes handled by this RestHandler that have had their {@code path} and/or
-     * {@code method} changed. The pre-existing {@code route} will be registered
-     * as deprecated alongside the updated {@code route}.
-     */
-    default List<ReplacedRoute> replacedRoutes() {
-        return Collections.emptyList();
-    }
-
-    /**
-     * Route for the request.
-    *
-    * @opensearch.internal
-    */
-    class Route {
-
-        private final String path;
-        private final Method method;
-
-        public Route(Method method, String path) {
-            this.path = path;
-            this.method = method;
-        }
-
-        public String getPath() {
-            return path;
-        }
-
-        public Method getMethod() {
-            return method;
-        }
-    }
-
-    /**
-     * Represents an API that has been deprecated and is slated for removal.
-    */
-    class DeprecatedRoute extends Route {
-
-        private final String deprecationMessage;
-
-        public DeprecatedRoute(Method method, String path, String deprecationMessage) {
-            super(method, path);
-            this.deprecationMessage = deprecationMessage;
-        }
-
-        public String getDeprecationMessage() {
-            return deprecationMessage;
-        }
-    }
-
-    /**
-     * Represents an API that has had its {@code path} or {@code method} changed. Holds both the
-    * new and previous {@code path} and {@code method} combination.
-    */
-    class ReplacedRoute extends Route {
-
-        private final String deprecatedPath;
-        private final Method deprecatedMethod;
-
-        /**
-         * Construct replaced routes using new and deprocated methods and new and deprecated paths
-        * @param method route method
-        * @param path new route path
-        * @param deprecatedMethod deprecated method
-        * @param deprecatedPath deprecated path
-        */
-        public ReplacedRoute(Method method, String path, Method deprecatedMethod, String deprecatedPath) {
-            super(method, path);
-            this.deprecatedMethod = deprecatedMethod;
-            this.deprecatedPath = deprecatedPath;
-        }
-
-        /**
-         * Construct replaced routes using route method, new and deprecated paths
-        * This constructor can be used when both new and deprecated paths use the same method
-        * @param method route method
-        * @param path new route path
-        * @param deprecatedPath deprecated path
-        */
-        public ReplacedRoute(Method method, String path, String deprecatedPath) {
-            this(method, path, method, deprecatedPath);
-        }
-
-        /**
-         * Construct replaced routes using route, new and deprecated prefixes
-        * @param route route
-        * @param prefix new route prefix
-        * @param deprecatedPrefix deprecated prefix
-        */
-        public ReplacedRoute(Route route, String prefix, String deprecatedPrefix) {
-            this(route.getMethod(), prefix + route.getPath(), deprecatedPrefix + route.getPath());
-        }
-
-        public String getDeprecatedPath() {
-            return deprecatedPath;
-        }
-
-        public Method getDeprecatedMethod() {
-            return deprecatedMethod;
-        }
-    }
-
-    /**
-     * Construct replaced routes using routes template and prefixes for new and deprecated paths
-    * @param routes routes
-    * @param prefix new prefix
-    * @param deprecatedPrefix deprecated prefix
-    * @return new list of API routes prefixed with the prefix string
-    */
-    static List<ReplacedRoute> replaceRoutes(List<Route> routes, final String prefix, final String deprecatedPrefix) {
-        return routes.stream().map(route -> new ReplacedRoute(route, prefix, deprecatedPrefix)).collect(Collectors.toList());
-    }
-}
diff --git a/server/src/main/java/org/opensearch/rest/RestController.java b/server/src/main/java/org/opensearch/rest/RestController.java
index 9d76594591655..08d2c865ee01f 100644
--- a/server/src/main/java/org/opensearch/rest/RestController.java
+++ b/server/src/main/java/org/opensearch/rest/RestController.java
@@ -304,18 +304,6 @@ public void registerHandler(final RestHandler restHandler) {
      */
     public void registerProtobufHandler(final ProtobufRestHandler restHandler) {
         restHandler.routes().forEach(route -> registerProtobufHandler(route.getMethod(), route.getPath(), restHandler));
-        // restHandler.deprecatedRoutes()
-        // .forEach(route -> registerAsDeprecatedHandler(route.getMethod(), route.getPath(), restHandler, route.getDeprecationMessage()));
-        // restHandler.replacedRoutes()
-        // .forEach(
-        // route -> registerWithDeprecatedHandler(
-        // route.getMethod(),
-        // route.getPath(),
-        // restHandler,
-        // route.getDeprecatedMethod(),
-        // route.getDeprecatedPath()
-        // )
-        // );
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
index 88ae0dd74c087..b54c8955283a2 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
@@ -354,6 +354,7 @@ Table buildTable(
         NodesInfoResponse nodesInfo,
         NodesStatsResponse nodesStats
     ) {
+
         DiscoveryNodes nodes = state.getState().nodes();
         String clusterManagerId = nodes.getClusterManagerNodeId();
         Table table = getTableWithHeader(req);
diff --git a/server/src/main/java/org/opensearch/script/StoredScriptSource.java b/server/src/main/java/org/opensearch/script/StoredScriptSource.java
index e335545c2f0e7..9d3af9e4c9caf 100644
--- a/server/src/main/java/org/opensearch/script/StoredScriptSource.java
+++ b/server/src/main/java/org/opensearch/script/StoredScriptSource.java
@@ -53,7 +53,6 @@
 import org.opensearch.common.xcontent.XContentFactory;
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.core.xcontent.XContentParser.Token;
-
 import org.opensearch.common.xcontent.XContentType;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/search/aggregations/support/AggregationUsageService.java b/server/src/main/java/org/opensearch/search/aggregations/support/AggregationUsageService.java
index 6124b3306954c..eba64998014e2 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/support/AggregationUsageService.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/support/AggregationUsageService.java
@@ -118,5 +118,4 @@ public Map<String, Object> getUsageStats() {
     public AggregationInfo info() {
         return info;
     }
-
 }
diff --git a/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java b/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java
index 9aa8786b5185f..33686139039b9 100644
--- a/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java
+++ b/server/src/main/java/org/opensearch/search/pipeline/PipelineConfiguration.java
@@ -162,5 +162,4 @@ public int hashCode() {
         result = 31 * result + getConfigAsMap().hashCode();
         return result;
     }
-
 }
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufCancellableTask.java b/server/src/main/java/org/opensearch/tasks/ProtobufCancellableTask.java
index fad1565390cd3..57245f8a13d7b 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufCancellableTask.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufCancellableTask.java
@@ -5,8 +5,6 @@
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
 *
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
 */
 
 package org.opensearch.tasks;
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTask.java b/server/src/main/java/org/opensearch/tasks/ProtobufTask.java
index 5b62b0d37a751..857abb26febc1 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTask.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTask.java
@@ -5,8 +5,6 @@
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
 *
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
 */
 
 package org.opensearch.tasks;
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskAwareRequest.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskAwareRequest.java
index a569c1b848240..4e55ecbc5b4ea 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskAwareRequest.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskAwareRequest.java
@@ -5,8 +5,6 @@
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
 *
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
 */
 
 package org.opensearch.tasks;
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
index 2c59d42658382..ec20aa83ebe12 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskId.java
@@ -5,8 +5,6 @@
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
 *
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
 */
 
 package org.opensearch.tasks;
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
index 17662779ccba3..32ecfb818b156 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskInfo.java
@@ -5,8 +5,6 @@
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
 *
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
 */
 
 package org.opensearch.tasks;
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java
index 12530e69df7d8..3de0ff44afbe0 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResourceStats.java
@@ -5,8 +5,6 @@
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
 *
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
 */
 
 package org.opensearch.tasks;
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
index 37b91dbd8ec15..633eaba2364c7 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskResult.java
@@ -5,8 +5,6 @@
 * this file be licensed under the Apache-2.0 license or a
 * compatible open source license.
 *
-* Modifications Copyright OpenSearch Contributors. See
-* GitHub history for details.
 */
 
 package org.opensearch.tasks;
diff --git a/server/src/main/java/org/opensearch/tasks/TaskManager.java b/server/src/main/java/org/opensearch/tasks/TaskManager.java
index 551dbae919be2..abc598dff8055 100644
--- a/server/src/main/java/org/opensearch/tasks/TaskManager.java
+++ b/server/src/main/java/org/opensearch/tasks/TaskManager.java
@@ -910,29 +910,6 @@ public void applyClusterState(ClusterChangedEvent event) {
         }
     }
 
-    // @Override
-    // public void applyProtobufClusterState(ProtobufClusterChangedEvent event) {
-    // lastDiscoveryNodes = event.state().getNodes();
-    // if (event.nodesRemoved()) {
-    // synchronized (banedParentsProtobuf) {
-    // lastDiscoveryNodes = event.state().getNodes();
-    // // Remove all bans that were registered by nodes that are no longer in the cluster state
-    // Iterator<ProtobufTaskId> banIterator = banedParentsProtobuf.keySet().iterator();
-    // while (banIterator.hasNext()) {
-    // ProtobufTaskId taskId = banIterator.next();
-    // if (lastDiscoveryNodes.nodeExists(taskId.getNodeId()) == false) {
-    // logger.debug(
-    // "Removing ban for the parent [{}] on the node [{}], reason: the parent node is gone",
-    // taskId,
-    // event.state().getNodes().getLocalNode()
-    // );
-    // banIterator.remove();
-    // }
-    // }
-    // }
-    // }
-    // }
-
     /**
      * Blocks the calling thread, waiting for the task to vanish from the TaskManager.
      */
diff --git a/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java
index 45232d3cb58a7..d799b9b078137 100644
--- a/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java
+++ b/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java
@@ -36,7 +36,6 @@
 
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.TransportResponse.Empty;
 
 /**
  * Handler for empty transport response
@@ -70,7 +69,7 @@ public String executor() {
     }
 
     @Override
-    public Empty read(byte[] in) throws IOException {
+    public TransportResponse.Empty read(byte[] in) throws IOException {
         // TODO Auto-generated method stub
         throw new UnsupportedOperationException("Unimplemented method 'read'");
     }
diff --git a/server/src/main/java/org/opensearch/transport/InboundHandler.java b/server/src/main/java/org/opensearch/transport/InboundHandler.java
index 8d569429c0f20..3e4ea2bab2109 100644
--- a/server/src/main/java/org/opensearch/transport/InboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/InboundHandler.java
@@ -91,7 +91,6 @@ public class InboundHandler {
     private final Transport.ProtobufRequestHandlers protobufRequestHandlers;
 
     private volatile TransportMessageListener messageListener = TransportMessageListener.NOOP_LISTENER;
-    // private volatile ProtobufTransportMessageListener protobufMessageListener = ProtobufTransportMessageListener.NOOP_LISTENER;
 
     private volatile long slowLogThresholdMs = Long.MAX_VALUE;
 
diff --git a/server/src/main/java/org/opensearch/transport/InboundMessage.java b/server/src/main/java/org/opensearch/transport/InboundMessage.java
index dc8b3954f7916..e19e5b45025aa 100644
--- a/server/src/main/java/org/opensearch/transport/InboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/InboundMessage.java
@@ -37,7 +37,6 @@
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.lease.Releasables;
-import org.opensearch.common.util.io.IOUtils;
 
 import java.io.IOException;
 
diff --git a/server/src/main/java/org/opensearch/transport/InboundPipeline.java b/server/src/main/java/org/opensearch/transport/InboundPipeline.java
index 7b5a4771e3551..a5631576d294f 100644
--- a/server/src/main/java/org/opensearch/transport/InboundPipeline.java
+++ b/server/src/main/java/org/opensearch/transport/InboundPipeline.java
@@ -198,7 +198,6 @@ private void forwardFragments(TcpChannel channel, ArrayList<Object> fragments) t
     }
 
     private void forwardFragmentsProtobuf(TcpChannel channel, ReleasableBytesReference reference) throws IOException {
-        // ProtobufOutboundMessage message = new ProtobufOutboundMessage(BytesReference.toBytes(reference));
         messageHandlerProtobuf.accept(channel, reference);
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/OutboundHandler.java b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
index a4581b0378964..9728776010769 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
@@ -211,7 +211,6 @@ void sendResponse(
         ActionListener<Void> listener = ActionListener.wrap(() -> messageListener.onResponseSent(requestId, action, response));
         String canonicalName = response.getClass().getCanonicalName();
         if (canonicalName.contains("ProtobufClusterState")) {
-            // ExampleProtoRequest exampleProtoRequest = new ExampleProtoRequest(1, "message");
             ProtobufClusterStateResponse protobufClusterStateResponse = (ProtobufClusterStateResponse) response;
             byte[] bytes = new byte[1];
             bytes[0] = 1;
@@ -293,13 +292,7 @@ private void sendMessage(TcpChannel channel, OutboundMessage networkMessage, Act
 
     private void sendProtobufMessage(TcpChannel channel, ProtobufOutboundMessage message, ActionListener<Void> listener)
         throws IOException {
-        TryMessageSerializer serializer = new TryMessageSerializer(message, bigArrays);
-        SendContext sendContext = new SendContext(channel, serializer, listener, serializer);
-        internalSend(channel, sendContext);
-    }
-
-    private void sendMessage1(TcpChannel channel, OutboundMessage networkMessage, ActionListener<Void> listener) throws IOException {
-        MessageSerializer1 serializer = new MessageSerializer1(networkMessage, bigArrays);
+        ProtobufMessageSerializer serializer = new ProtobufMessageSerializer(message, bigArrays);
         SendContext sendContext = new SendContext(channel, serializer, listener, serializer);
         internalSend(channel, sendContext);
     }
@@ -353,13 +346,13 @@ public void close() {
         }
     }
 
-    private static class TryMessageSerializer implements CheckedSupplier<BytesReference, IOException>, Releasable {
+    private static class ProtobufMessageSerializer implements CheckedSupplier<BytesReference, IOException>, Releasable {
 
         private final ProtobufOutboundMessage message;
         private final BigArrays bigArrays;
         private volatile ReleasableBytesStreamOutput bytesStreamOutput;
 
-        private TryMessageSerializer(ProtobufOutboundMessage message, BigArrays bigArrays) {
+        private ProtobufMessageSerializer(ProtobufOutboundMessage message, BigArrays bigArrays) {
             this.message = message;
             this.bigArrays = bigArrays;
         }
@@ -383,34 +376,6 @@ public void close() {
         }
     }
 
-    /**
-     * Internal message serializer
-     *
-     * @opensearch.internal
-     */
-    private static class MessageSerializer1 implements CheckedSupplier<BytesReference, IOException>, Releasable {
-
-        private final OutboundMessage message;
-        private final BigArrays bigArrays;
-        private volatile ReleasableBytesStreamOutput bytesStreamOutput;
-
-        private MessageSerializer1(OutboundMessage message, BigArrays bigArrays) {
-            this.message = message;
-            this.bigArrays = bigArrays;
-        }
-
-        @Override
-        public BytesReference get() throws IOException {
-            bytesStreamOutput = new ReleasableBytesStreamOutput(bigArrays);
-            return message.serialize1(bytesStreamOutput);
-        }
-
-        @Override
-        public void close() {
-            IOUtils.closeWhileHandlingException(bytesStreamOutput);
-        }
-    }
-
     private class SendContext extends NotifyOnceListener<Void> implements CheckedSupplier<BytesReference, IOException> {
 
         private final TcpChannel channel;
diff --git a/server/src/main/java/org/opensearch/transport/OutboundMessage.java b/server/src/main/java/org/opensearch/transport/OutboundMessage.java
index c3c6e418a9c70..d969351425acd 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundMessage.java
@@ -84,33 +84,6 @@ BytesReference serialize(BytesStreamOutput bytesStream) throws IOException {
         return reference;
     }
 
-    BytesReference serialize1(BytesStreamOutput bytesStream) throws IOException {
-        bytesStream.setVersion(version);
-        // bytesStream.skip(TcpHeader.headerSize(version));
-
-        // The compressible bytes stream will not close the underlying bytes stream
-        BytesReference reference;
-        int variableHeaderLength = -1;
-        final long preHeaderPosition = bytesStream.position();
-        writeVariableHeader(bytesStream);
-        variableHeaderLength = Math.toIntExact(bytesStream.position() - preHeaderPosition);
-
-        try (CompressibleBytesOutputStream stream = new CompressibleBytesOutputStream(bytesStream, TransportStatus.isCompress(status))) {
-            stream.setVersion(version);
-            stream.setFeatures(bytesStream.getFeatures());
-
-            if (variableHeaderLength == -1) {
-                writeVariableHeader(stream);
-            }
-            reference = writeMessage(stream);
-        }
-
-        bytesStream.seek(0);
-        final int contentSize = reference.length() - TcpHeader.headerSize(version);
-        TcpHeader.writeHeader(bytesStream, requestId, status, version, contentSize, variableHeaderLength);
-        return reference;
-    }
-
     protected void writeVariableHeader(StreamOutput stream) throws IOException {
         threadContext.writeTo(stream);
     }
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java b/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
index 55745e06351b5..b034035997627 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufOutboundMessage.java
@@ -280,7 +280,6 @@ public ProtobufOutboundMessage(byte[] data) throws InvalidProtocolBufferExceptio
     }
 
     public void writeTo(OutputStream out) throws IOException {
-        // super.writeTo(out);
         out.write(this.message.toByteArray());
     }
 
diff --git a/server/src/main/java/org/opensearch/transport/RemoteClusterService.java b/server/src/main/java/org/opensearch/transport/RemoteClusterService.java
index 6385a9cec2a6e..60e166a4e300c 100644
--- a/server/src/main/java/org/opensearch/transport/RemoteClusterService.java
+++ b/server/src/main/java/org/opensearch/transport/RemoteClusterService.java
@@ -150,13 +150,10 @@ public boolean isEnabled() {
     private final TransportService transportService;
     private final Map<String, RemoteClusterConnection> remoteClusters = ConcurrentCollections.newConcurrentMap();
 
-    private final TransportService TransportService;
-
     RemoteClusterService(Settings settings, TransportService transportService) {
         super(settings);
         this.enabled = DiscoveryNode.isRemoteClusterClient(settings);
         this.transportService = transportService;
-        this.TransportService = null;
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java b/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java
index d53e58f9cc5e1..4da23175c4a0e 100644
--- a/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java
+++ b/server/src/main/java/org/opensearch/transport/RemoteConnectionManager.java
@@ -230,12 +230,5 @@ public Version getVersion() {
         public Object getCacheKey() {
             return connection.getCacheKey();
         }
-
-        // @Override
-        // public void sendRequestProtobuf(long requestId, String action, TransportRequest request,
-        // TransportRequestOptions options) throws IOException, TransportException {
-        // // TODO Auto-generated method stub
-        // throw new UnsupportedOperationException("Unimplemented method 'sendRequestProtobuf'");
-        // }
     }
 }
diff --git a/server/src/main/java/org/opensearch/transport/TcpHeader.java b/server/src/main/java/org/opensearch/transport/TcpHeader.java
index a52d577b624b5..78353a9a80403 100644
--- a/server/src/main/java/org/opensearch/transport/TcpHeader.java
+++ b/server/src/main/java/org/opensearch/transport/TcpHeader.java
@@ -91,5 +91,4 @@ public static void writeHeader(
         assert variableHeaderSize != -1 : "Variable header size not set";
         output.writeInt(variableHeaderSize);
     }
-
 }
diff --git a/server/src/main/java/org/opensearch/transport/TcpTransport.java b/server/src/main/java/org/opensearch/transport/TcpTransport.java
index 2bb2ab009a8ad..216f80d99632f 100644
--- a/server/src/main/java/org/opensearch/transport/TcpTransport.java
+++ b/server/src/main/java/org/opensearch/transport/TcpTransport.java
@@ -39,7 +39,6 @@
 import org.opensearch.action.ActionListener;
 import org.opensearch.action.support.ThreadedActionListener;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.Booleans;
 import org.opensearch.core.common.breaker.CircuitBreaker;
 import org.opensearch.core.common.bytes.BytesArray;
@@ -57,8 +56,6 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.transport.BoundTransportAddress;
 import org.opensearch.common.transport.PortsRange;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.common.unit.TimeValue;
@@ -138,7 +135,6 @@ public abstract class TcpTransport extends AbstractLifecycleComponent implements
     private final CircuitBreakerService circuitBreakerService;
 
     private final ConcurrentMap<String, BoundTransportAddress> profileBoundAddresses = newConcurrentMap();
-    private final ConcurrentMap<String, BoundTransportAddress> profileProtobufBoundAddresses = newConcurrentMap();
     private final Map<String, List<TcpServerChannel>> serverChannels = newConcurrentMap();
     private final Set<TcpChannel> acceptedChannels = ConcurrentCollections.newConcurrentSet();
 
@@ -146,7 +142,6 @@ public abstract class TcpTransport extends AbstractLifecycleComponent implements
     // connections while no connect operations is going on
     private final ReadWriteLock closeLock = new ReentrantReadWriteLock();
     private volatile BoundTransportAddress boundAddress;
-    private volatile BoundTransportAddress protobufBoundAddress;
 
     private final TransportHandshaker handshaker;
     private final TransportKeepAlive keepAlive;
@@ -154,7 +149,6 @@ public abstract class TcpTransport extends AbstractLifecycleComponent implements
     private final InboundHandler inboundHandler;
     private final ResponseHandlers responseHandlers = new ResponseHandlers();
     private final RequestHandlers requestHandlers = new RequestHandlers();
-    // private final ProtobufResponseHandlers protobufResponseHandlers = new ProtobufResponseHandlers();
     private final ProtobufRequestHandlers protobufRequestHandlers = new ProtobufRequestHandlers();
 
     private final AtomicLong outboundConnectionCount = new AtomicLong(); // also used as a correlation ID for open/close logs
@@ -324,7 +318,6 @@ public void sendRequest(long requestId, String action, TransportRequest request,
             TcpChannel channel = channel(options.type());
             outboundHandler.sendRequest(node, channel, requestId, action, request, options, getVersion(), compress, false);
         }
-
     }
 
     // This allows transport implementations to potentially override specific connection profiles. This
@@ -402,16 +395,6 @@ public Map<String, BoundTransportAddress> profileBoundAddresses() {
         return unmodifiableMap(new HashMap<>(profileBoundAddresses));
     }
 
-    // @Override
-    // public BoundTransportAddress boundProtobufAddress() {
-    // return this.protobufBoundAddress;
-    // }
-
-    // @Override
-    // public Map<String, BoundTransportAddress> profileProtobufBoundAddresses() {
-    // return unmodifiableMap(new HashMap<>(profileProtobufBoundAddresses));
-    // }
-
     @Override
     public List<String> getDefaultSeedAddresses() {
         List<String> local = new ArrayList<>();
@@ -450,14 +433,11 @@ protected void bindServer(ProfileSettings profileSettings) {
         }
 
         final BoundTransportAddress boundTransportAddress = createBoundTransportAddress(profileSettings, boundAddresses);
-        // final BoundTransportAddress protobufBoundTransportAddress = createProtobufBoundTransportAddress(boundTransportAddress);
 
         if (profileSettings.isDefaultProfile) {
             this.boundAddress = boundTransportAddress;
-            // this.protobufBoundAddress = protobufBoundTransportAddress;
         } else {
             profileBoundAddresses.put(profileSettings.profileName, boundTransportAddress);
-            // profileProtobufBoundAddresses.put(profileSettings.profileName, protobufBoundTransportAddress);
         }
     }
 
@@ -527,43 +507,6 @@ private BoundTransportAddress createBoundTransportAddress(ProfileSettings profil
         return new BoundTransportAddress(transportBoundAddresses, publishAddress);
     }
 
-    // private BoundTransportAddress createProtobufBoundTransportAddress(BoundTransportAddress boundTransportAddress) {
-    // TransportAddress[] transportBoundAddresses = boundTransportAddress.boundAddresses();
-    // TransportAddress publishAddress = boundTransportAddress.publishAddress();
-    // TransportAddress[] transportBoundAddressesProtobuf = new TransportAddress[transportBoundAddresses.length];
-    // for (int i = 0; i < transportBoundAddresses.length; i++) {
-    // transportBoundAddressesProtobuf[i] = new TransportAddress(transportBoundAddresses[i].address());
-    // }
-    // return new BoundTransportAddress(transportBoundAddressesProtobuf, new TransportAddress(publishAddress.address()));
-    // // String[] boundAddressesHostStrings = new String[boundAddresses.size()];
-    // // TransportAddress[] transportBoundAddresses = new TransportAddress[boundAddresses.size()];
-    // // for (int i = 0; i < boundAddresses.size(); i++) {
-    // // InetSocketAddress boundAddress = boundAddresses.get(i);
-    // // boundAddressesHostStrings[i] = boundAddress.getHostString();
-    // // transportBoundAddresses[i] = new TransportAddress(boundAddress);
-    // // }
-
-    // // List<String> publishHosts = profileSettings.publishHosts;
-    // // if (profileSettings.isDefaultProfile == false && publishHosts.isEmpty()) {
-    // // publishHosts = Arrays.asList(boundAddressesHostStrings);
-    // // }
-    // // if (publishHosts.isEmpty()) {
-    // // publishHosts = NetworkService.GLOBAL_NETWORK_PUBLISH_HOST_SETTING.get(settings);
-    // // }
-
-    // // final InetAddress publishInetAddress;
-    // // try {
-    // // publishInetAddress = networkService.resolvePublishHostAddresses(publishHosts.toArray(Strings.EMPTY_ARRAY));
-    // // } catch (Exception e) {
-    // // throw new BindTransportException("Failed to resolve publish address", e);
-    // // }
-
-    // // final int publishPort = resolvePublishPort(profileSettings, boundAddresses, publishInetAddress);
-    // // final TransportAddress publishAddress = new TransportAddress(new InetSocketAddress(publishInetAddress,
-    // // publishPort));
-    // // return new BoundTransportAddress(transportBoundAddresses, publishAddress);
-    // }
-
     // package private for tests
     static int resolvePublishPort(ProfileSettings profileSettings, List<InetSocketAddress> boundAddresses, InetAddress publishInetAddress) {
         int publishPort = profileSettings.publishPort;
diff --git a/server/src/main/java/org/opensearch/transport/Transport.java b/server/src/main/java/org/opensearch/transport/Transport.java
index 7e95f83b44042..89a7de4ff553d 100644
--- a/server/src/main/java/org/opensearch/transport/Transport.java
+++ b/server/src/main/java/org/opensearch/transport/Transport.java
@@ -139,17 +139,6 @@ interface Connection extends Closeable {
         void sendRequest(long requestId, String action, TransportRequest request, TransportRequestOptions options) throws IOException,
             TransportException;
 
-        // /**
-        // * Sends the request to the node this connection is associated with
-        // * @param requestId see {@link ResponseHandlers#add(ResponseContext)} for details
-        // * @param action the action to execute
-        // * @param request the request to send
-        // * @param options request options to apply
-        // * @throws NodeNotConnectedException if the given node is not connected
-        // */
-        // void sendRequestProtobuf(long requestId, String action, TransportRequest request, TransportRequestOptions options)
-        // throws IOException, TransportException;
-
         /**
          * The listener's {@link ActionListener#onResponse(Object)} method will be called when this
          * connection is closed. No implementations currently throw an exception during close, so
@@ -180,56 +169,6 @@ default Object getCacheKey() {
         void close();
     }
 
-    // /**
-    // * A unidirectional connection to a {@link DiscoveryNode}
-    // */
-    // interface ProtobufConnection extends Closeable {
-    // /**
-    // * The node this connection is associated with
-    // */
-    // DiscoveryNode getNode();
-
-    // /**
-    // * Sends the request to the node this connection is associated with
-    // * @param requestId see {@link ResponseHandlers#add(ResponseContext)} for details
-    // * @param action the action to execute
-    // * @param request the request to send
-    // * @param options request options to apply
-    // * @throws NodeNotConnectedException if the given node is not connected
-    // */
-    // void sendRequest(long requestId, String action, TransportRequest request, TransportRequestOptions options)
-    // throws IOException, TransportException;
-
-    // /**
-    // * The listener's {@link ActionListener#onResponse(Object)} method will be called when this
-    // * connection is closed. No implementations currently throw an exception during close, so
-    // * {@link ActionListener#onFailure(Exception)} will not be called.
-    // *
-    // * @param listener to be called
-    // */
-    // void addCloseListener(ActionListener<Void> listener);
-
-    // boolean isClosed();
-
-    // /**
-    // * Returns the version of the node this connection was established with.
-    // */
-    // default Version getVersion() {
-    // return getNode().getVersion();
-    // }
-
-    // /**
-    // * Returns a key that this connection can be cached on. Delegating subclasses must delegate method call to
-    // * the original connection.
-    // */
-    // default Object getCacheKey() {
-    // return this;
-    // }
-
-    // @Override
-    // void close();
-    // }
-
     /**
      * This class represents a response context that encapsulates the actual response handler, the action and the connection it was
      * executed on.
@@ -261,37 +200,6 @@ public String action() {
         }
     }
 
-    // /**
-    // * This class represents a response context that encapsulates the actual response handler, the action and the connection it was
-    // * executed on.
-    // */
-    // final class ProtobufResponseContext<T extends TransportResponse> {
-
-    // private final ProtobufTransportResponseHandler<T> handler;
-
-    // private final Connection connection;
-
-    // private final String action;
-
-    // ProtobufResponseContext(ProtobufTransportResponseHandler<T> handler, Connection connection, String action) {
-    // this.handler = handler;
-    // this.connection = connection;
-    // this.action = action;
-    // }
-
-    // public ProtobufTransportResponseHandler<T> handler() {
-    // return handler;
-    // }
-
-    // public Connection connection() {
-    // return this.connection;
-    // }
-
-    // public String action() {
-    // return this.action;
-    // }
-    // }
-
     /**
      * This class is a registry that allows
      */
@@ -371,87 +279,6 @@ public TransportResponseHandler<? extends TransportResponse> onResponseReceived(
         }
     }
 
-    // /**
-    // * This class is a registry that allows
-    // */
-    // final class ProtobufResponseHandlers {
-    // private final ConcurrentMapLong<ProtobufResponseContext<? extends TransportResponse>> handlers = ConcurrentCollections
-    // .newConcurrentMapLongWithAggressiveConcurrency();
-    // private final AtomicLong requestIdGenerator = new AtomicLong();
-
-    // /**
-    // * Returns <code>true</code> if the give request ID has a context associated with it.
-    // */
-    // public boolean contains(long requestId) {
-    // return handlers.containsKey(requestId);
-    // }
-
-    // /**
-    // * Removes and return the {@link ResponseContext} for the given request ID or returns
-    // * <code>null</code> if no context is associated with this request ID.
-    // */
-    // public ProtobufResponseContext<? extends TransportResponse> remove(long requestId) {
-    // return handlers.remove(requestId);
-    // }
-
-    // /**
-    // * Adds a new response context and associates it with a new request ID.
-    // * @return the new request ID
-    // * @see Connection#sendRequestProtobuf(long, String, TransportRequest, TransportRequestOptions)
-    // */
-    // public long add(ProtobufResponseContext<? extends TransportResponse> holder) {
-    // long requestId = newRequestId();
-    // ProtobufResponseContext<? extends TransportResponse> existing = handlers.put(requestId, holder);
-    // assert existing == null : "request ID already in use: " + requestId;
-    // return requestId;
-    // }
-
-    // /**
-    // * Returns a new request ID to use when sending a message via {@link Connection#sendRequestProtobuf(long, String,
-    // * TransportRequest, TransportRequestOptions)}
-    // */
-    // long newRequestId() {
-    // return requestIdGenerator.incrementAndGet();
-    // }
-
-    // /**
-    // * Removes and returns all {@link ResponseContext} instances that match the predicate
-    // */
-    // public List<ProtobufResponseContext<? extends TransportResponse>> prune(
-    // Predicate<ProtobufResponseContext<? extends TransportResponse>> predicate
-    // ) {
-    // final List<ProtobufResponseContext<? extends TransportResponse>> holders = new ArrayList<>();
-    // for (Map.Entry<Long, ProtobufResponseContext<? extends TransportResponse>> entry : handlers.entrySet()) {
-    // ProtobufResponseContext<? extends TransportResponse> holder = entry.getValue();
-    // if (predicate.test(holder)) {
-    // ProtobufResponseContext<? extends TransportResponse> remove = handlers.remove(entry.getKey());
-    // if (remove != null) {
-    // holders.add(holder);
-    // }
-    // }
-    // }
-    // return holders;
-    // }
-
-    // /**
-    // * called by the {@link Transport} implementation when a response or an exception has been received for a previously
-    // * sent request (before any processing or deserialization was done). Returns the appropriate response handler or null if not
-    // * found.
-    // */
-    // public ProtobufTransportResponseHandler<? extends TransportResponse> onResponseReceived(
-    // final long requestId,
-    // final ProtobufTransportMessageListener listener
-    // ) {
-    // ProtobufResponseContext<? extends TransportResponse> context = handlers.remove(requestId);
-    // listener.onResponseReceived(requestId, context);
-    // if (context == null) {
-    // return null;
-    // } else {
-    // return context.handler();
-    // }
-    // }
-    // }
-
     /**
      * Request handler implementations
      *
diff --git a/server/src/main/java/org/opensearch/transport/TransportInterceptor.java b/server/src/main/java/org/opensearch/transport/TransportInterceptor.java
index 0d722c1748af3..d09b9a55aaa6e 100644
--- a/server/src/main/java/org/opensearch/transport/TransportInterceptor.java
+++ b/server/src/main/java/org/opensearch/transport/TransportInterceptor.java
@@ -95,30 +95,4 @@ <T extends TransportResponse> void sendRequest(
             TransportResponseHandler<T> handler
         );
     }
-
-    // /**
-    // * This is called up-front providing the actual low level {@link AsyncSender} that performs the low level send request.
-    // * The returned sender is used to send all requests that come in via
-    // * {@link TransportService#sendRequestProtobuf(DiscoveryNode, String, TransportRequest, TransportResponseHandler)} or
-    // * {@link TransportService#sendRequestProtobuf(DiscoveryNode, String, TransportRequest, TransportRequestOptions,
-    // TransportResponseHandler)}.
-    // * This allows plugins to perform actions on each send request including modifying the request context etc.
-    // */
-    // default AsyncSenderProtobuf interceptSenderProotbuf(AsyncSenderProtobuf sender) {
-    // return sender;
-    // }
-
-    // /**
-    // * A simple interface to decorate
-    // * {@link #sendRequest(Transport.Connection, String, TransportRequest, TransportRequestOptions, TransportResponseHandler)}
-    // */
-    // interface AsyncSenderProtobuf {
-    // <T extends TransportResponse> void sendRequest(
-    // Transport.Connection connection,
-    // String action,
-    // TransportRequest request,
-    // TransportRequestOptions options,
-    // TransportResponseHandler<T> handler
-    // );
-    // }
 }
diff --git a/server/src/main/java/org/opensearch/transport/TransportService.java b/server/src/main/java/org/opensearch/transport/TransportService.java
index 6be50134ef0f0..cbd550396f5dd 100644
--- a/server/src/main/java/org/opensearch/transport/TransportService.java
+++ b/server/src/main/java/org/opensearch/transport/TransportService.java
@@ -226,11 +226,9 @@ public TransportService(
         taskManager = createTaskManager(settings, clusterSettings, threadPool, taskHeaders);
         this.interceptor = transportInterceptor;
         this.asyncSender = interceptor.interceptSender(this::sendRequestInternal);
-        // this.asyncSenderProtobuf = interceptor.interceptSenderProotbuf(this::sendRequestInternal);
         this.remoteClusterClient = DiscoveryNode.isRemoteClusterClient(settings);
         remoteClusterService = new RemoteClusterService(settings, this);
         responseHandlers = transport.getResponseHandlers();
-        // responseHandlersProtobuf = transport.getResponseHandlersProtobuf();
         if (clusterSettings != null) {
             clusterSettings.addSettingsUpdateConsumer(TransportSettings.TRACE_LOG_INCLUDE_SETTING, this::setTracerLogInclude);
             clusterSettings.addSettingsUpdateConsumer(TransportSettings.TRACE_LOG_EXCLUDE_SETTING, this::setTracerLogExclude);
@@ -303,7 +301,6 @@ void setTracerLogExclude(List<String> tracerLogExclude) {
     @Override
     protected void doStart() {
         transport.setMessageListener(this);
-        // transport.setMessageListenerProtobuf(this);
         connectionManager.addListener(this);
         transport.start();
         if (transport.boundAddress() != null && logger.isInfoEnabled()) {
diff --git a/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java b/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java
index d2dcf93134a4e..124ecd52ac538 100644
--- a/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java
@@ -592,7 +592,6 @@ public void connectToNode(DiscoveryNode node, ActionListener<Void> listener) thr
     private static final class MockTransport implements Transport {
         private final ResponseHandlers responseHandlers = new ResponseHandlers();
         private final RequestHandlers requestHandlers = new RequestHandlers();
-        // private final ProtobufResponseHandlers protobufResponseHandlers = new ProtobufResponseHandlers();
         private final ProtobufRequestHandlers protobufRequestHandlers = new ProtobufRequestHandlers();
         private volatile boolean randomConnectionExceptions = false;
         private final ThreadPool threadPool;
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/NoOpClusterApplier.java b/server/src/test/java/org/opensearch/cluster/coordination/NoOpClusterApplier.java
index 3dc35b88b4ff4..9b865ace3b082 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/NoOpClusterApplier.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/NoOpClusterApplier.java
@@ -46,9 +46,4 @@ public void setInitialState(ClusterState initialState) {
     public void onNewClusterState(String source, Supplier<ClusterState> clusterStateSupplier, ClusterApplyListener listener) {
         listener.onSuccess(source);
     }
-
-    // @Override
-    // public void setInitialProtobufState(ProtobufClusterState initialState) {
-
-    // }
 }
diff --git a/server/src/test/java/org/opensearch/cluster/serialization/DiffableTests.java b/server/src/test/java/org/opensearch/cluster/serialization/DiffableTests.java
index 515c7c79b07c2..ac2470e940916 100644
--- a/server/src/test/java/org/opensearch/cluster/serialization/DiffableTests.java
+++ b/server/src/test/java/org/opensearch/cluster/serialization/DiffableTests.java
@@ -337,7 +337,6 @@ public boolean equals(Object o) {
         public int hashCode() {
             return value != null ? value.hashCode() : 0;
         }
-
     }
 
 }
diff --git a/server/src/test/java/org/opensearch/common/network/NetworkModuleTests.java b/server/src/test/java/org/opensearch/common/network/NetworkModuleTests.java
index 958368ba4384a..f795df2f48b22 100644
--- a/server/src/test/java/org/opensearch/common/network/NetworkModuleTests.java
+++ b/server/src/test/java/org/opensearch/common/network/NetworkModuleTests.java
@@ -103,7 +103,6 @@ public HttpInfo info() {
         public HttpStats stats() {
             return null;
         }
-
     }
 
     public void testRegisterTransport() {
diff --git a/server/src/test/java/org/opensearch/rest/RestControllerTests.java b/server/src/test/java/org/opensearch/rest/RestControllerTests.java
index 9c3ff07ab9555..ea0ce54913a8d 100644
--- a/server/src/test/java/org/opensearch/rest/RestControllerTests.java
+++ b/server/src/test/java/org/opensearch/rest/RestControllerTests.java
@@ -691,7 +691,6 @@ public HttpInfo info() {
         public HttpStats stats() {
             return null;
         }
-
     }
 
     public static final class AssertingChannel extends AbstractRestChannel {
diff --git a/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java b/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
index c3d4a64b10baf..46b3c43104e99 100644
--- a/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
+++ b/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
@@ -313,5 +313,4 @@ public void onResponseSent(long requestId, String action, Exception error) {
 
         assertEquals("header_value", header.getHeaders().v1().get("header"));
     }
-
 }
diff --git a/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java b/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java
index 49eb893f78efe..e156449adc184 100644
--- a/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java
@@ -57,7 +57,6 @@ public static class TestPlugin extends Plugin {}
         new TransportAddress[] { DUMMY_TRANSPORT_ADDRESS },
         DUMMY_TRANSPORT_ADDRESS
     );
-
     private static final HttpInfo DUMMY_HTTP_INFO = new HttpInfo(DUMMY_BOUND_ADDRESS, 0);
     private static final HttpStats DUMMY_HTTP_STATS = new HttpStats(0, 0);
 
@@ -84,5 +83,4 @@ public HttpInfo info() {
     public HttpStats stats() {
         return DUMMY_HTTP_STATS;
     }
-
 }
diff --git a/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java b/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
index 8944c838c2cdc..9c15a6e0ab572 100644
--- a/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
@@ -98,12 +98,6 @@ public DiscoveryNode getNode() {
             public void sendRequest(long requestId, String action, TransportRequest request, TransportRequestOptions options) {
 
             }
-
-            // @Override
-            // public void sendRequestProtobuf(long requestId, String action, TransportRequest request,
-            // TransportRequestOptions options) throws IOException, TransportException {
-
-            // }
         });
     }
 
diff --git a/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java b/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
index 71256e36a1b30..b4675c9fcebf2 100644
--- a/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
@@ -279,13 +279,6 @@ public void close() {
         public Transport.Connection getConnection() {
             return connection;
         }
-
-        // @Override
-        // public void sendRequestProtobuf(long requestId, String action, TransportRequest request,
-        // TransportRequestOptions options) throws IOException, TransportException {
-        // // TODO Auto-generated method stub
-        // throw new UnsupportedOperationException("Unimplemented method 'sendRequestProtobuf'");
-        // }
     }
 
     @FunctionalInterface

From 967d26b8df46194bd198e22d6b3f25390425fd2a Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Thu, 3 Aug 2023 07:07:53 +0000
Subject: [PATCH 31/37] Improvements

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../action/cat/ProtobufRestNodesAction.java   | 70 +++++++++++--------
 1 file changed, 39 insertions(+), 31 deletions(-)

diff --git a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
index 25d9ccdeeb882..6e2ab8582d235 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/ProtobufRestNodesAction.java
@@ -340,29 +340,37 @@ Table buildTable(
             table.addCell(info == null ? null : info.getHash());
             table.addCell(info == null ? null : info.getJvmInfoVersion());
 
-            ByteSizeValue diskTotal = new ByteSizeValue(stats.getDiskTotal());
-            ByteSizeValue diskAvailable = new ByteSizeValue(stats.getDiskAvailable());
-            ByteSizeValue diskUsed = new ByteSizeValue(diskTotal.getBytes() - diskAvailable.getBytes());
-            double diskUsedRatio = diskTotal.getBytes() == 0 ? 1.0 : (double) diskUsed.getBytes() / diskTotal.getBytes();
-            String diskUsedPercent = String.format(Locale.ROOT, "%.2f", 100.0 * diskUsedRatio);
+            ByteSizeValue diskTotal = null;
+            ByteSizeValue diskUsed = null;
+            ByteSizeValue diskAvailable = null;
+            String diskUsedPercent = null;
+            if (stats != null) {
+                diskTotal = new ByteSizeValue(stats.getDiskTotal());
+                diskAvailable = new ByteSizeValue(stats.getDiskAvailable());
+                diskUsed = new ByteSizeValue(diskTotal.getBytes() - diskAvailable.getBytes());
+                double diskUsedRatio = diskTotal.getBytes() == 0 ? 1.0 : (double) diskUsed.getBytes() / diskTotal.getBytes();
+                diskUsedPercent = String.format(Locale.ROOT, "%.2f", 100.0 * diskUsedRatio);
+            }
 
             table.addCell(diskTotal);
             table.addCell(diskUsed);
             table.addCell(diskAvailable);
             table.addCell(diskUsedPercent);
 
-            table.addCell(new ByteSizeValue(stats.getJvmHeapUsed()));
-            table.addCell(stats.getJvmHeapUsedPercent());
-            table.addCell(info.getJvmHeapMax());
-            table.addCell(new ByteSizeValue(stats.getOsMemUsed()));
-            table.addCell(stats.getOsMemUsedPercent());
-            table.addCell(new ByteSizeValue(stats.getOsMemTotal()));
-            table.addCell(stats.getProcessOpenFileDescriptors());
-            table.addCell(calculatePercentage(stats.getProcessOpenFileDescriptors(), stats.getProcessMaxFileDescriptors()));
-            table.addCell(stats.getProcessMaxFileDescriptors());
-
-            table.addCell(stats.getOsCpuPercent());
-            boolean hasLoadAverage = stats.getOsCpuLoadAverageList() != null;
+            table.addCell(stats == null ? null : new ByteSizeValue(stats.getJvmHeapUsed()));
+            table.addCell(stats == null ? null : stats.getJvmHeapUsedPercent());
+            table.addCell(info == null ? null : info.getJvmHeapMax());
+            table.addCell(stats == null ? null : new ByteSizeValue(stats.getOsMemUsed()));
+            table.addCell(stats == null ? null : stats.getOsMemUsedPercent());
+            table.addCell(stats == null ? null : new ByteSizeValue(stats.getOsMemTotal()));
+            table.addCell(stats == null ? null : stats.getProcessOpenFileDescriptors());
+            table.addCell(
+                stats == null ? null : calculatePercentage(stats.getProcessOpenFileDescriptors(), stats.getProcessMaxFileDescriptors())
+            );
+            table.addCell(stats == null ? null : stats.getProcessMaxFileDescriptors());
+
+            table.addCell(stats == null ? null : stats.getOsCpuPercent());
+            boolean hasLoadAverage = stats != null && stats.getOsCpuLoadAverageList() != null;
             table.addCell(
                 !hasLoadAverage || stats.getOsCpuLoadAverage(0) == -1
                     ? null
@@ -378,7 +386,7 @@ Table buildTable(
                     ? null
                     : String.format(Locale.ROOT, "%.2f", stats.getOsCpuLoadAverage(2))
             );
-            table.addCell(new TimeValue(stats.getJvmUpTime()));
+            table.addCell(stats == null ? null : new TimeValue(stats.getJvmUpTime()));
 
             final String roles;
             final String allRoles;
@@ -410,28 +418,28 @@ Table buildTable(
             table.addCell(clusterManagerId == null ? "x" : clusterManagerId.equals(node.getNodeId()) ? "*" : "-");
             table.addCell(node.getNodeName());
 
-            table.addCell(stats.getCompletionStats() == null ? null : stats.getCompletionStats().getSize());
+            table.addCell(stats == null ? null : stats.getCompletionStats() == null ? null : stats.getCompletionStats().getSize());
 
-            table.addCell(stats.getFieldDataStats() == null ? null : stats.getFieldDataStats().getMemSize());
-            table.addCell(stats.getFieldDataStats() == null ? null : stats.getFieldDataStats().getEvictions());
+            table.addCell(stats == null ? null : stats.getFieldDataStats() == null ? null : stats.getFieldDataStats().getMemSize());
+            table.addCell(stats == null ? null : stats.getFieldDataStats() == null ? null : stats.getFieldDataStats().getEvictions());
 
-            QueryCacheStats fcStats = stats.getQueryCacheStats() == null ? null : stats.getQueryCacheStats();
+            QueryCacheStats fcStats = stats != null && stats.getQueryCacheStats() != null ? stats.getQueryCacheStats() : null;
             table.addCell(fcStats == null ? null : new ByteSizeValue(fcStats.getRamBytesUsed()));
             table.addCell(fcStats == null ? null : fcStats.getCacheCount() - fcStats.getCacheSize());
             table.addCell(fcStats == null ? null : fcStats.getHitCount());
             table.addCell(fcStats == null ? null : fcStats.getMissCount());
 
-            RequestCacheStats qcStats = stats.getRequestCacheStats() == null ? null : stats.getRequestCacheStats();
+            RequestCacheStats qcStats = stats != null && stats.getRequestCacheStats() != null ? stats.getRequestCacheStats() : null;
             table.addCell(qcStats == null ? null : new ByteSizeValue(qcStats.getMemorySize()));
             table.addCell(qcStats == null ? null : qcStats.getEvictions());
             table.addCell(qcStats == null ? null : qcStats.getHitCount());
             table.addCell(qcStats == null ? null : qcStats.getMissCount());
 
-            FlushStats flushStats = stats.getFlushStats() == null ? null : stats.getFlushStats();
+            FlushStats flushStats = stats != null && stats.getFlushStats() != null ? stats.getFlushStats() : null;
             table.addCell(flushStats == null ? null : flushStats.getTotal());
             table.addCell(flushStats == null ? null : flushStats.getTotalTimeInMillis());
 
-            GetStats getStats = stats.getGetStats() == null ? null : stats.getGetStats();
+            GetStats getStats = stats != null && stats.getGetStats() != null ? stats.getGetStats() : null;
             table.addCell(getStats == null ? null : getStats.getCurrent());
             table.addCell(getStats == null ? null : new TimeValue(getStats.getTime()));
             table.addCell(getStats == null ? null : getStats.getCount());
@@ -440,7 +448,7 @@ Table buildTable(
             table.addCell(getStats == null ? null : new TimeValue(getStats.getMissingTimeInMillis()));
             table.addCell(getStats == null ? null : getStats.getMissingCount());
 
-            IndexingStats indexingStats = stats.getIndexingStats() == null ? null : stats.getIndexingStats();
+            IndexingStats indexingStats = stats != null && stats.getIndexingStats() != null ? stats.getIndexingStats() : null;
             table.addCell(indexingStats == null ? null : indexingStats.getDeleteCurrent());
             table.addCell(indexingStats == null ? null : new TimeValue(indexingStats.getDeleteTimeInMillis()));
             table.addCell(indexingStats == null ? null : indexingStats.getDeleteCount());
@@ -449,7 +457,7 @@ Table buildTable(
             table.addCell(indexingStats == null ? null : indexingStats.getIndexCount());
             table.addCell(indexingStats == null ? null : indexingStats.getIndexFailedCount());
 
-            MergeStats mergeStats = stats.getMergeStats() == null ? null : stats.getMergeStats();
+            MergeStats mergeStats = stats != null && stats.getMergeStats() != null ? stats.getMergeStats() : null;
             table.addCell(mergeStats == null ? null : mergeStats.getCurrent());
             table.addCell(mergeStats == null ? null : mergeStats.getCurrentNumDocs());
             table.addCell(mergeStats == null ? null : new ByteSizeValue(mergeStats.getCurrentSizeInBytes()));
@@ -458,19 +466,19 @@ Table buildTable(
             table.addCell(mergeStats == null ? null : new ByteSizeValue(mergeStats.getTotalSizeInBytes()));
             table.addCell(mergeStats == null ? null : new TimeValue(mergeStats.getTotalTimeInMillis()));
 
-            RefreshStats refreshStats = stats.getRefreshStats() == null ? null : stats.getRefreshStats();
+            RefreshStats refreshStats = stats != null && stats.getRefreshStats() != null ? stats.getRefreshStats() : null;
             table.addCell(refreshStats == null ? null : refreshStats.getTotal());
             table.addCell(refreshStats == null ? null : new TimeValue(refreshStats.getTotalTimeInMillis()));
             table.addCell(refreshStats == null ? null : refreshStats.getExternalTotal());
             table.addCell(refreshStats == null ? null : new TimeValue(refreshStats.getExternalTotalTimeInMillis()));
             table.addCell(refreshStats == null ? null : refreshStats.getListeners());
 
-            ScriptStats scriptStats = stats == null ? null : stats.getScriptStats();
+            ScriptStats scriptStats = stats != null && stats.getScriptStats() != null ? stats.getScriptStats() : null;
             table.addCell(scriptStats == null ? null : scriptStats.getCompilations());
             table.addCell(scriptStats == null ? null : scriptStats.getCacheEvictions());
             table.addCell(scriptStats == null ? null : scriptStats.getCompilationLimitTriggered());
 
-            SearchStats searchStats = stats.getSearchStats() == null ? null : stats.getSearchStats();
+            SearchStats searchStats = stats != null && stats.getSearchStats() != null ? stats.getSearchStats() : null;
             table.addCell(searchStats == null ? null : searchStats.getFetchCurrent());
             table.addCell(searchStats == null ? null : new TimeValue(searchStats.getFetchTimeInMillis()));
             table.addCell(searchStats == null ? null : searchStats.getFetchCount());
@@ -485,7 +493,7 @@ Table buildTable(
             table.addCell(searchStats == null ? null : new TimeValue(searchStats.getPitTimeInMillis()));
             table.addCell(searchStats == null ? null : searchStats.getPitCount());
 
-            SegmentStats segmentsStats = stats.getSegmentStats() == null ? null : stats.getSegmentStats();
+            SegmentStats segmentsStats = stats != null && stats.getSegmentStats() != null ? stats.getSegmentStats() : null;
             table.addCell(segmentsStats == null ? null : segmentsStats.getCount());
             table.addCell(segmentsStats == null ? null : new ByteSizeValue(0L));
             table.addCell(segmentsStats == null ? null : new ByteSizeValue(segmentsStats.getIndexWriterMemoryInBytes()));

From 0e9a86e96b106cb966be9ccb1a3be8a0644110c2 Mon Sep 17 00:00:00 2001
From: Nick Knize <nknize@apache.org>
Date: Wed, 2 Aug 2023 15:01:24 -0500
Subject: [PATCH 32/37] [Refactor] Network and Transport common classes to
 Libraries (#9073)

This commit refactors the following network and transport libraries to
the opensearch common and core libraries respectively:

* o.o.common.network.Cidrs -> :libs:opensearch-common
* o.o.common.network.InetAddresses -> :libs:opensearch-common
* o.o.common.network.NetworkAddress -> :libs:opensearch-common
* o.o.common.transport.NetworkExceptionHelper -> :libs:opensearch-common
* o.o.common.transport.PortsRange -> :libs:opensearch-common

* o.o.common.transport.TransportAddress -> :libs:opensearch-core
* o.o.common.transport.BoundTransportAddress -> :libs:opensearch-core
* o.o.transport.TransportMessage -> :libs:opensearch-core
* o.o.transport.TransportResponse -> :libs:opensearch-core

The purpose is to reduce the change surface area of the core APIs to
minimize impact to downstream consumers while moving toward establishing
a formal API for cloud native or serverless implementations.

Signed-off-by: Nicholas Walter Knize <nknize@apache.org>
---
 .../benchmark/routing/allocation/Allocators.java       |  2 +-
 .../client/tasks/CancelTasksResponseTests.java         |  2 +-
 .../main/java/org/opensearch/common/network/Cidrs.java |  0
 .../org/opensearch/common/network/InetAddresses.java   |  0
 .../org/opensearch/common/network/NetworkAddress.java  |  0
 .../org/opensearch/common/network/package-info.java    | 10 ++++++++++
 .../common/transport/NetworkExceptionHelper.java       |  0
 .../org/opensearch/common/transport/PortsRange.java    |  0
 .../org/opensearch/common/transport/package-info.java  |  2 +-
 .../java/org/opensearch/common/network/CidrsTests.java |  0
 .../opensearch/common/network/InetAddressesTests.java  |  0
 .../opensearch/common/network/NetworkAddressTests.java |  0
 .../core}/common/transport/BoundTransportAddress.java  |  4 ++--
 .../core}/common/transport/TransportAddress.java       |  4 ++--
 .../opensearch/core/common/transport/package-info.java | 10 ++++++++++
 .../opensearch/core}/transport/TransportMessage.java   |  4 ++--
 .../opensearch/core}/transport/TransportResponse.java  |  2 +-
 .../org/opensearch/core/transport/package-info.java    | 10 ++++++++++
 .../index/reindex/ReindexFromRemoteWithAuthTests.java  |  2 +-
 .../java/org/opensearch/index/reindex/RetryTests.java  |  2 +-
 .../java/org/opensearch/http/netty4/Netty4Http2IT.java |  2 +-
 .../http/netty4/Netty4HttpRequestSizeLimitIT.java      |  2 +-
 .../org/opensearch/http/netty4/Netty4PipeliningIT.java |  2 +-
 .../netty4/Netty4TransportMultiPortIntegrationIT.java  |  4 ++--
 .../netty4/Netty4TransportPublishAddressIT.java        |  4 ++--
 .../opensearch/http/netty4/Netty4BadRequestTests.java  |  2 +-
 .../http/netty4/Netty4HttpServerPipeliningTests.java   |  2 +-
 .../http/netty4/Netty4HttpServerTransportTests.java    |  2 +-
 .../netty4/Netty4SizeHeaderFrameDecoderTests.java      |  2 +-
 .../transport/netty4/SimpleNetty4TransportTests.java   |  2 +-
 .../classic/AbstractAzureComputeServiceTestCase.java   |  2 +-
 .../azure/classic/AzureSeedHostsProvider.java          |  2 +-
 .../discovery/ec2/AwsEc2SeedHostsProvider.java         |  2 +-
 .../opensearch/discovery/ec2/Ec2DiscoveryTests.java    |  2 +-
 .../org/opensearch/discovery/ec2/Ec2RetriesTests.java  |  2 +-
 .../opensearch/discovery/gce/GceSeedHostsProvider.java |  2 +-
 .../opensearch/discovery/gce/GceDiscoveryTests.java    |  2 +-
 .../java/org/opensearch/http/nio/NioPipeliningIT.java  |  2 +-
 .../http/nio/NioHttpServerTransportTests.java          |  2 +-
 .../transport/nio/SimpleNioTransportTests.java         |  2 +-
 .../TransportReplicationActionRetryOnClosedNodeIT.java |  2 +-
 .../action/ActionListenerResponseHandler.java          |  2 +-
 .../java/org/opensearch/action/ActionResponse.java     |  2 +-
 .../action/admin/cluster/stats/ClusterStatsNodes.java  |  2 +-
 .../action/search/ClearScrollController.java           |  2 +-
 .../org/opensearch/action/search/DeletePitInfo.java    |  2 +-
 .../action/search/SearchTransportService.java          |  2 +-
 .../action/search/UpdatePitContextResponse.java        |  2 +-
 .../action/support/ChannelActionListener.java          |  2 +-
 .../support/broadcast/BroadcastShardResponse.java      |  2 +-
 .../broadcast/node/TransportBroadcastByNodeAction.java |  2 +-
 .../action/support/nodes/BaseNodeResponse.java         |  2 +-
 .../action/support/tasks/TransportTasksAction.java     |  2 +-
 .../main/java/org/opensearch/bootstrap/Bootstrap.java  |  2 +-
 .../java/org/opensearch/bootstrap/BootstrapChecks.java |  4 ++--
 .../opensearch/cluster/ClusterSettingsResponse.java    |  2 +-
 .../cluster/action/index/NodeMappingRefreshAction.java |  2 +-
 .../cluster/action/shard/ShardStateAction.java         |  2 +-
 .../coordination/ClusterFormationFailureHelper.java    |  2 +-
 .../opensearch/cluster/coordination/Coordinator.java   |  4 ++--
 .../cluster/coordination/FollowersChecker.java         |  2 +-
 .../opensearch/cluster/coordination/JoinHelper.java    |  4 ++--
 .../opensearch/cluster/coordination/LeaderChecker.java |  4 ++--
 .../opensearch/cluster/coordination/PeersResponse.java |  2 +-
 .../cluster/coordination/PreVoteResponse.java          |  2 +-
 .../opensearch/cluster/coordination/Publication.java   |  2 +-
 .../coordination/PublicationTransportHandler.java      |  2 +-
 .../cluster/coordination/PublishWithJoinResponse.java  |  2 +-
 .../org/opensearch/cluster/node/DiscoveryNode.java     |  2 +-
 .../opensearch/cluster/node/DiscoveryNodeFilters.java  |  2 +-
 .../org/opensearch/cluster/node/DiscoveryNodes.java    |  2 +-
 .../java/org/opensearch/discovery/DiscoveryModule.java |  2 +-
 .../discovery/FileBasedSeedHostsProvider.java          |  2 +-
 .../HandshakingTransportAddressConnector.java          |  2 +-
 .../discovery/InitializeExtensionResponse.java         |  2 +-
 .../main/java/org/opensearch/discovery/PeerFinder.java |  2 +-
 .../org/opensearch/discovery/SeedHostsProvider.java    |  2 +-
 .../org/opensearch/discovery/SeedHostsResolver.java    |  2 +-
 .../discovery/SettingsBasedSeedHostsProvider.java      |  2 +-
 .../opensearch/env/EnvironmentSettingsResponse.java    |  2 +-
 .../opensearch/extensions/AcknowledgedResponse.java    |  2 +-
 .../AddSettingsUpdateConsumerRequestHandler.java       |  2 +-
 .../opensearch/extensions/DiscoveryExtensionNode.java  |  2 +-
 .../extensions/ExtensionDependencyResponse.java        |  2 +-
 .../org/opensearch/extensions/ExtensionsManager.java   |  4 ++--
 .../action/ExtensionTransportActionsHandler.java       |  2 +-
 .../extensions/rest/RestActionsRequestHandler.java     |  2 +-
 .../rest/RestExecuteOnExtensionResponse.java           |  2 +-
 .../settings/CustomSettingsRequestHandler.java         |  2 +-
 .../gateway/LocalAllocateDangledIndices.java           |  2 +-
 .../opensearch/http/AbstractHttpServerTransport.java   |  4 ++--
 server/src/main/java/org/opensearch/http/HttpInfo.java |  4 ++--
 .../java/org/opensearch/http/HttpServerTransport.java  |  2 +-
 .../org/opensearch/index/IndicesModuleResponse.java    |  2 +-
 .../indices/recovery/PeerRecoveryTargetService.java    |  2 +-
 .../opensearch/indices/recovery/RecoveryResponse.java  |  2 +-
 .../recovery/RecoveryTranslogOperationsResponse.java   |  2 +-
 .../indices/recovery/RemoteRecoveryTargetHandler.java  |  2 +-
 .../indices/recovery/RetryableTransportClient.java     |  2 +-
 .../indices/replication/CheckpointInfoResponse.java    |  2 +-
 .../indices/replication/GetSegmentFilesResponse.java   |  2 +-
 .../replication/RemoteSegmentFileChunkWriter.java      |  2 +-
 .../replication/SegmentReplicationSourceService.java   |  2 +-
 .../replication/SegmentReplicationTargetService.java   |  2 +-
 .../indices/replication/common/ReplicationTarget.java  |  2 +-
 .../org/opensearch/indices/store/IndicesStore.java     |  2 +-
 server/src/main/java/org/opensearch/node/Node.java     |  4 ++--
 .../org/opensearch/node/NodeValidationException.java   |  2 +-
 .../java/org/opensearch/plugins/DiscoveryPlugin.java   |  3 ++-
 .../repositories/VerifyNodeRepositoryAction.java       |  2 +-
 .../opensearch/rest/action/cat/RestNodesAction.java    |  2 +-
 .../java/org/opensearch/search/SearchPhaseResult.java  |  2 +-
 .../org/opensearch/tasks/TaskCancellationService.java  |  2 +-
 .../opensearch/transport/ActionTransportException.java |  2 +-
 .../transport/EmptyTransportResponseHandler.java       |  1 +
 .../java/org/opensearch/transport/InboundHandler.java  |  3 ++-
 .../java/org/opensearch/transport/OutboundHandler.java |  3 ++-
 .../org/opensearch/transport/PlainTransportFuture.java |  1 +
 .../opensearch/transport/ProxyConnectionStrategy.java  |  2 +-
 .../opensearch/transport/RemoteTransportException.java |  2 +-
 .../opensearch/transport/SniffConnectionStrategy.java  |  2 +-
 .../org/opensearch/transport/TaskTransportChannel.java |  1 +
 .../java/org/opensearch/transport/TcpTransport.java    |  4 ++--
 .../org/opensearch/transport/TcpTransportChannel.java  |  1 +
 .../main/java/org/opensearch/transport/Transport.java  |  5 +++--
 .../org/opensearch/transport/TransportActionProxy.java |  1 +
 .../org/opensearch/transport/TransportChannel.java     |  1 +
 .../org/opensearch/transport/TransportHandshaker.java  |  1 +
 .../java/org/opensearch/transport/TransportInfo.java   |  4 ++--
 .../org/opensearch/transport/TransportInterceptor.java |  1 +
 .../opensearch/transport/TransportMessageListener.java |  1 +
 .../org/opensearch/transport/TransportRequest.java     |  1 +
 .../opensearch/transport/TransportResponseHandler.java |  1 +
 .../org/opensearch/transport/TransportService.java     |  5 +++--
 .../org/opensearch/ExceptionSerializationTests.java    |  2 +-
 .../admin/cluster/node/tasks/TaskManagerTestCase.java  |  2 +-
 .../admin/cluster/node/tasks/TestTaskPlugin.java       |  2 +-
 .../cluster/reroute/ClusterRerouteResponseTests.java   |  2 +-
 .../shards/ClusterSearchShardsResponseTests.java       |  2 +-
 .../TransportVerifyShardBeforeCloseActionTests.java    |  2 +-
 .../action/bulk/TransportShardBulkActionTests.java     |  2 +-
 .../action/search/ClearScrollControllerTests.java      |  2 +-
 .../action/search/TransportSearchActionTests.java      |  2 +-
 .../node/TransportBroadcastByNodeActionTests.java      |  2 +-
 .../support/replication/ReplicationOperationTests.java |  2 +-
 .../replication/TransportReplicationActionTests.java   |  2 +-
 .../TransportWriteActionForIndexingPressureTests.java  |  2 +-
 .../support/replication/TransportWriteActionTests.java |  2 +-
 .../org/opensearch/bootstrap/BootstrapChecksTests.java |  4 ++--
 .../java/org/opensearch/cluster/ClusterStateTests.java |  2 +-
 .../cluster/NodeConnectionsServiceTests.java           |  4 ++--
 .../cluster/action/shard/ShardStateActionTests.java    |  2 +-
 .../ClusterFormationFailureHelperTests.java            |  2 +-
 .../cluster/coordination/CoordinationStateTests.java   |  2 +-
 .../cluster/coordination/FollowersCheckerTests.java    |  4 ++--
 .../cluster/coordination/JoinHelperTests.java          |  2 +-
 .../cluster/coordination/LeaderCheckerTests.java       |  4 ++--
 .../opensearch/cluster/coordination/NodeJoinTests.java |  2 +-
 .../cluster/coordination/PublicationTests.java         |  2 +-
 .../cluster/node/DiscoveryNodeFiltersTests.java        |  2 +-
 .../opensearch/cluster/node/DiscoveryNodeTests.java    |  2 +-
 .../opensearch/cluster/node/DiscoveryNodesTests.java   |  2 +-
 .../opensearch/cluster/routing/RoutingNodeTests.java   |  2 +-
 .../opensearch/common/network/NetworkModuleTests.java  |  2 +-
 .../common/transport/BoundTransportAddressTests.java   |  2 ++
 .../discovery/FileBasedSeedHostsProviderTests.java     |  4 ++--
 .../HandshakingTransportAddressConnectorTests.java     |  2 +-
 .../discovery/InitializeExtensionRequestTests.java     |  2 +-
 .../java/org/opensearch/discovery/PeerFinderTests.java |  2 +-
 .../opensearch/discovery/SeedHostsResolverTests.java   |  4 ++--
 .../discovery/SettingsBasedSeedHostsProviderTests.java |  2 +-
 .../extensions/DiscoveryExtensionNodeTests.java        |  2 +-
 .../opensearch/extensions/ExtensionsManagerTests.java  |  4 ++--
 .../action/ExtensionTransportActionsHandlerTests.java  |  2 +-
 .../rest/RestSendToExtensionActionTests.java           |  2 +-
 .../org/opensearch/gateway/GatewayServiceTests.java    |  2 +-
 .../http/AbstractHttpServerTransportTests.java         |  2 +-
 .../test/java/org/opensearch/http/HttpInfoTests.java   |  4 ++--
 .../SegmentReplicationSourceServiceTests.java          |  2 +-
 .../SegmentReplicationTargetServiceTests.java          |  2 +-
 .../src/test/java/org/opensearch/node/NodeTests.java   |  2 +-
 .../opensearch/node/ResponseCollectorServiceTests.java |  2 +-
 .../opensearch/nodesinfo/NodeInfoStreamingTests.java   |  4 ++--
 .../org/opensearch/rest/BytesRestResponseTests.java    |  2 +-
 .../java/org/opensearch/rest/RestControllerTests.java  |  4 ++--
 .../rest/action/RestBuilderListenerTests.java          |  4 ++--
 .../opensearch/snapshots/SnapshotResiliencyTests.java  |  2 +-
 .../transport/ClusterConnectionManagerTests.java       |  2 +-
 .../org/opensearch/transport/InboundDecoderTests.java  |  1 +
 .../org/opensearch/transport/OutboundHandlerTests.java |  3 ++-
 .../transport/ProxyConnectionStrategyTests.java        |  2 +-
 .../transport/RemoteClusterConnectionTests.java        |  2 +-
 .../transport/RemoteConnectionManagerTests.java        |  2 +-
 .../transport/SniffConnectionStrategyTests.java        |  2 +-
 .../org/opensearch/transport/TcpTransportTests.java    |  2 +-
 .../transport/TransportActionProxyTests.java           |  1 +
 .../opensearch/transport/TransportHandshakerTests.java |  1 +
 .../org/opensearch/transport/TransportInfoTests.java   |  4 ++--
 .../TransportServiceDeserializationFailureTests.java   |  1 +
 .../coordination/AbstractCoordinatorTestCase.java      |  2 +-
 .../src/main/java/org/opensearch/node/MockNode.java    |  2 +-
 .../java/org/opensearch/test/ExternalTestCluster.java  |  2 +-
 .../java/org/opensearch/test/MockHttpTransport.java    |  4 ++--
 .../org/opensearch/test/OpenSearchIntegTestCase.java   |  2 +-
 .../java/org/opensearch/test/OpenSearchTestCase.java   |  2 +-
 .../test/disruption/DisruptableMockTransport.java      |  6 +++---
 .../org/opensearch/test/transport/FakeTransport.java   |  4 ++--
 .../org/opensearch/test/transport/MockTransport.java   |  4 ++--
 .../test/transport/MockTransportService.java           |  4 ++--
 .../test/transport/StubbableConnectionManager.java     |  2 +-
 .../opensearch/test/transport/StubbableTransport.java  |  4 ++--
 .../transport/AbstractSimpleTransportTestCase.java     |  5 +++--
 .../java/org/opensearch/transport/TestResponse.java    |  1 +
 .../org/opensearch/transport/TestTransportChannel.java |  1 +
 .../test/disruption/DisruptableMockTransportTests.java |  6 +++---
 .../test/disruption/NetworkDisruptionIT.java           |  2 +-
 .../transport/nio/SimpleMockNioTransportTests.java     |  2 +-
 217 files changed, 283 insertions(+), 227 deletions(-)
 rename {server => libs/common}/src/main/java/org/opensearch/common/network/Cidrs.java (100%)
 rename {server => libs/common}/src/main/java/org/opensearch/common/network/InetAddresses.java (100%)
 rename {server => libs/common}/src/main/java/org/opensearch/common/network/NetworkAddress.java (100%)
 create mode 100644 libs/common/src/main/java/org/opensearch/common/network/package-info.java
 rename {server => libs/common}/src/main/java/org/opensearch/common/transport/NetworkExceptionHelper.java (100%)
 rename {server => libs/common}/src/main/java/org/opensearch/common/transport/PortsRange.java (100%)
 rename {server => libs/common}/src/main/java/org/opensearch/common/transport/package-info.java (79%)
 rename {server => libs/common}/src/test/java/org/opensearch/common/network/CidrsTests.java (100%)
 rename {server => libs/common}/src/test/java/org/opensearch/common/network/InetAddressesTests.java (100%)
 rename {server => libs/common}/src/test/java/org/opensearch/common/network/NetworkAddressTests.java (100%)
 rename {server/src/main/java/org/opensearch => libs/core/src/main/java/org/opensearch/core}/common/transport/BoundTransportAddress.java (98%)
 rename {server/src/main/java/org/opensearch => libs/core/src/main/java/org/opensearch/core}/common/transport/TransportAddress.java (99%)
 create mode 100644 libs/core/src/main/java/org/opensearch/core/common/transport/package-info.java
 rename {server/src/main/java/org/opensearch => libs/core/src/main/java/org/opensearch/core}/transport/TransportMessage.java (95%)
 rename {server/src/main/java/org/opensearch => libs/core/src/main/java/org/opensearch/core}/transport/TransportResponse.java (98%)
 create mode 100644 libs/core/src/main/java/org/opensearch/core/transport/package-info.java

diff --git a/benchmarks/src/main/java/org/opensearch/benchmark/routing/allocation/Allocators.java b/benchmarks/src/main/java/org/opensearch/benchmark/routing/allocation/Allocators.java
index d700b9dab2cf3..25a7bf3d98f0a 100644
--- a/benchmarks/src/main/java/org/opensearch/benchmark/routing/allocation/Allocators.java
+++ b/benchmarks/src/main/java/org/opensearch/benchmark/routing/allocation/Allocators.java
@@ -45,7 +45,7 @@
 import org.opensearch.cluster.routing.allocation.decider.AllocationDeciders;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.set.Sets;
 import org.opensearch.gateway.GatewayAllocator;
 import org.opensearch.snapshots.EmptySnapshotsInfoService;
diff --git a/client/rest-high-level/src/test/java/org/opensearch/client/tasks/CancelTasksResponseTests.java b/client/rest-high-level/src/test/java/org/opensearch/client/tasks/CancelTasksResponseTests.java
index e6411b615df07..0e9bce7ce0b58 100644
--- a/client/rest-high-level/src/test/java/org/opensearch/client/tasks/CancelTasksResponseTests.java
+++ b/client/rest-high-level/src/test/java/org/opensearch/client/tasks/CancelTasksResponseTests.java
@@ -40,7 +40,7 @@
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.common.xcontent.XContentType;
diff --git a/server/src/main/java/org/opensearch/common/network/Cidrs.java b/libs/common/src/main/java/org/opensearch/common/network/Cidrs.java
similarity index 100%
rename from server/src/main/java/org/opensearch/common/network/Cidrs.java
rename to libs/common/src/main/java/org/opensearch/common/network/Cidrs.java
diff --git a/server/src/main/java/org/opensearch/common/network/InetAddresses.java b/libs/common/src/main/java/org/opensearch/common/network/InetAddresses.java
similarity index 100%
rename from server/src/main/java/org/opensearch/common/network/InetAddresses.java
rename to libs/common/src/main/java/org/opensearch/common/network/InetAddresses.java
diff --git a/server/src/main/java/org/opensearch/common/network/NetworkAddress.java b/libs/common/src/main/java/org/opensearch/common/network/NetworkAddress.java
similarity index 100%
rename from server/src/main/java/org/opensearch/common/network/NetworkAddress.java
rename to libs/common/src/main/java/org/opensearch/common/network/NetworkAddress.java
diff --git a/libs/common/src/main/java/org/opensearch/common/network/package-info.java b/libs/common/src/main/java/org/opensearch/common/network/package-info.java
new file mode 100644
index 0000000000000..92e4eac5bde42
--- /dev/null
+++ b/libs/common/src/main/java/org/opensearch/common/network/package-info.java
@@ -0,0 +1,10 @@
+/*
+ * 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.
+ */
+
+/** common network layer classes used across the code base */
+package org.opensearch.common.network;
diff --git a/server/src/main/java/org/opensearch/common/transport/NetworkExceptionHelper.java b/libs/common/src/main/java/org/opensearch/common/transport/NetworkExceptionHelper.java
similarity index 100%
rename from server/src/main/java/org/opensearch/common/transport/NetworkExceptionHelper.java
rename to libs/common/src/main/java/org/opensearch/common/transport/NetworkExceptionHelper.java
diff --git a/server/src/main/java/org/opensearch/common/transport/PortsRange.java b/libs/common/src/main/java/org/opensearch/common/transport/PortsRange.java
similarity index 100%
rename from server/src/main/java/org/opensearch/common/transport/PortsRange.java
rename to libs/common/src/main/java/org/opensearch/common/transport/PortsRange.java
diff --git a/server/src/main/java/org/opensearch/common/transport/package-info.java b/libs/common/src/main/java/org/opensearch/common/transport/package-info.java
similarity index 79%
rename from server/src/main/java/org/opensearch/common/transport/package-info.java
rename to libs/common/src/main/java/org/opensearch/common/transport/package-info.java
index abb8dfbb4e4f0..7d28ac6c60a14 100644
--- a/server/src/main/java/org/opensearch/common/transport/package-info.java
+++ b/libs/common/src/main/java/org/opensearch/common/transport/package-info.java
@@ -6,5 +6,5 @@
  * compatible open source license.
  */
 
-/** Base Transport utility package. */
+/** common transport layer classes used across the code base */
 package org.opensearch.common.transport;
diff --git a/server/src/test/java/org/opensearch/common/network/CidrsTests.java b/libs/common/src/test/java/org/opensearch/common/network/CidrsTests.java
similarity index 100%
rename from server/src/test/java/org/opensearch/common/network/CidrsTests.java
rename to libs/common/src/test/java/org/opensearch/common/network/CidrsTests.java
diff --git a/server/src/test/java/org/opensearch/common/network/InetAddressesTests.java b/libs/common/src/test/java/org/opensearch/common/network/InetAddressesTests.java
similarity index 100%
rename from server/src/test/java/org/opensearch/common/network/InetAddressesTests.java
rename to libs/common/src/test/java/org/opensearch/common/network/InetAddressesTests.java
diff --git a/server/src/test/java/org/opensearch/common/network/NetworkAddressTests.java b/libs/common/src/test/java/org/opensearch/common/network/NetworkAddressTests.java
similarity index 100%
rename from server/src/test/java/org/opensearch/common/network/NetworkAddressTests.java
rename to libs/common/src/test/java/org/opensearch/common/network/NetworkAddressTests.java
diff --git a/server/src/main/java/org/opensearch/common/transport/BoundTransportAddress.java b/libs/core/src/main/java/org/opensearch/core/common/transport/BoundTransportAddress.java
similarity index 98%
rename from server/src/main/java/org/opensearch/common/transport/BoundTransportAddress.java
rename to libs/core/src/main/java/org/opensearch/core/common/transport/BoundTransportAddress.java
index 3a9c337f2d950..8908a172395f2 100644
--- a/server/src/main/java/org/opensearch/common/transport/BoundTransportAddress.java
+++ b/libs/core/src/main/java/org/opensearch/core/common/transport/BoundTransportAddress.java
@@ -30,12 +30,12 @@
  * GitHub history for details.
  */
 
-package org.opensearch.common.transport;
+package org.opensearch.core.common.transport;
 
+import org.opensearch.common.network.InetAddresses;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
-import org.opensearch.common.network.InetAddresses;
 
 import java.io.IOException;
 
diff --git a/server/src/main/java/org/opensearch/common/transport/TransportAddress.java b/libs/core/src/main/java/org/opensearch/core/common/transport/TransportAddress.java
similarity index 99%
rename from server/src/main/java/org/opensearch/common/transport/TransportAddress.java
rename to libs/core/src/main/java/org/opensearch/core/common/transport/TransportAddress.java
index 737e8f3496143..1a853877ed0b9 100644
--- a/server/src/main/java/org/opensearch/common/transport/TransportAddress.java
+++ b/libs/core/src/main/java/org/opensearch/core/common/transport/TransportAddress.java
@@ -30,12 +30,12 @@
  * GitHub history for details.
  */
 
-package org.opensearch.common.transport;
+package org.opensearch.core.common.transport;
 
+import org.opensearch.common.network.NetworkAddress;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
-import org.opensearch.common.network.NetworkAddress;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 
diff --git a/libs/core/src/main/java/org/opensearch/core/common/transport/package-info.java b/libs/core/src/main/java/org/opensearch/core/common/transport/package-info.java
new file mode 100644
index 0000000000000..21d2abfce958a
--- /dev/null
+++ b/libs/core/src/main/java/org/opensearch/core/common/transport/package-info.java
@@ -0,0 +1,10 @@
+/*
+ * 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.
+ */
+
+/** Common / Base Transport classes used to implement the OpenSearch transport layer */
+package org.opensearch.core.common.transport;
diff --git a/server/src/main/java/org/opensearch/transport/TransportMessage.java b/libs/core/src/main/java/org/opensearch/core/transport/TransportMessage.java
similarity index 95%
rename from server/src/main/java/org/opensearch/transport/TransportMessage.java
rename to libs/core/src/main/java/org/opensearch/core/transport/TransportMessage.java
index 2a2ae65f8a693..28f1afc2bd115 100644
--- a/server/src/main/java/org/opensearch/transport/TransportMessage.java
+++ b/libs/core/src/main/java/org/opensearch/core/transport/TransportMessage.java
@@ -30,12 +30,12 @@
  * GitHub history for details.
  */
 
-package org.opensearch.transport;
+package org.opensearch.core.transport;
 
 import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.Writeable;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 
 /**
  * Message over the transport interface
diff --git a/server/src/main/java/org/opensearch/transport/TransportResponse.java b/libs/core/src/main/java/org/opensearch/core/transport/TransportResponse.java
similarity index 98%
rename from server/src/main/java/org/opensearch/transport/TransportResponse.java
rename to libs/core/src/main/java/org/opensearch/core/transport/TransportResponse.java
index 52f00a0b1abef..cc9d2996a43cc 100644
--- a/server/src/main/java/org/opensearch/transport/TransportResponse.java
+++ b/libs/core/src/main/java/org/opensearch/core/transport/TransportResponse.java
@@ -30,7 +30,7 @@
  * GitHub history for details.
  */
 
-package org.opensearch.transport;
+package org.opensearch.core.transport;
 
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
diff --git a/libs/core/src/main/java/org/opensearch/core/transport/package-info.java b/libs/core/src/main/java/org/opensearch/core/transport/package-info.java
new file mode 100644
index 0000000000000..91db839f40305
--- /dev/null
+++ b/libs/core/src/main/java/org/opensearch/core/transport/package-info.java
@@ -0,0 +1,10 @@
+/*
+ * 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.
+ */
+
+/** Core Transport Layer classes used across the OpenSearch core */
+package org.opensearch.core.transport;
diff --git a/modules/reindex/src/test/java/org/opensearch/index/reindex/ReindexFromRemoteWithAuthTests.java b/modules/reindex/src/test/java/org/opensearch/index/reindex/ReindexFromRemoteWithAuthTests.java
index 97f43b9439408..03d6fafccfea3 100644
--- a/modules/reindex/src/test/java/org/opensearch/index/reindex/ReindexFromRemoteWithAuthTests.java
+++ b/modules/reindex/src/test/java/org/opensearch/index/reindex/ReindexFromRemoteWithAuthTests.java
@@ -50,7 +50,7 @@
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.common.network.NetworkModule;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.core.xcontent.NamedXContentRegistry;
 import org.opensearch.env.Environment;
diff --git a/modules/reindex/src/test/java/org/opensearch/index/reindex/RetryTests.java b/modules/reindex/src/test/java/org/opensearch/index/reindex/RetryTests.java
index e239018e0ce31..89eb8fc7e15a3 100644
--- a/modules/reindex/src/test/java/org/opensearch/index/reindex/RetryTests.java
+++ b/modules/reindex/src/test/java/org/opensearch/index/reindex/RetryTests.java
@@ -42,7 +42,7 @@
 import org.opensearch.client.Client;
 import org.opensearch.core.common.bytes.BytesArray;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
 import org.opensearch.http.HttpInfo;
 import org.opensearch.index.query.QueryBuilders;
diff --git a/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/http/netty4/Netty4Http2IT.java b/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/http/netty4/Netty4Http2IT.java
index c066f3edf6900..baa306aa0624b 100644
--- a/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/http/netty4/Netty4Http2IT.java
+++ b/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/http/netty4/Netty4Http2IT.java
@@ -13,7 +13,7 @@
 import io.netty.util.ReferenceCounted;
 import org.opensearch.OpenSearchNetty4IntegTestCase;
 import org.opensearch.common.collect.Tuple;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.http.HttpServerTransport;
 import org.opensearch.test.OpenSearchIntegTestCase.ClusterScope;
 import org.opensearch.test.OpenSearchIntegTestCase.Scope;
diff --git a/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/http/netty4/Netty4HttpRequestSizeLimitIT.java b/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/http/netty4/Netty4HttpRequestSizeLimitIT.java
index 95440e28686e7..d01f72ac88c9d 100644
--- a/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/http/netty4/Netty4HttpRequestSizeLimitIT.java
+++ b/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/http/netty4/Netty4HttpRequestSizeLimitIT.java
@@ -38,7 +38,7 @@
 import org.opensearch.OpenSearchNetty4IntegTestCase;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.common.unit.ByteSizeUnit;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.http.HttpServerTransport;
diff --git a/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/http/netty4/Netty4PipeliningIT.java b/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/http/netty4/Netty4PipeliningIT.java
index 96193b0ecb954..d891284f53205 100644
--- a/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/http/netty4/Netty4PipeliningIT.java
+++ b/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/http/netty4/Netty4PipeliningIT.java
@@ -35,7 +35,7 @@
 import io.netty.handler.codec.http.FullHttpResponse;
 import io.netty.util.ReferenceCounted;
 import org.opensearch.OpenSearchNetty4IntegTestCase;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.http.HttpServerTransport;
 import org.opensearch.test.OpenSearchIntegTestCase.ClusterScope;
 import org.opensearch.test.OpenSearchIntegTestCase.Scope;
diff --git a/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/transport/netty4/Netty4TransportMultiPortIntegrationIT.java b/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/transport/netty4/Netty4TransportMultiPortIntegrationIT.java
index 3ff3938d23f65..4004d3d1a029d 100644
--- a/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/transport/netty4/Netty4TransportMultiPortIntegrationIT.java
+++ b/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/transport/netty4/Netty4TransportMultiPortIntegrationIT.java
@@ -36,8 +36,8 @@
 import org.opensearch.action.admin.cluster.node.info.NodesInfoResponse;
 import org.opensearch.common.network.NetworkAddress;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.test.OpenSearchIntegTestCase.ClusterScope;
 import org.opensearch.test.OpenSearchIntegTestCase.Scope;
 import org.opensearch.test.junit.annotations.Network;
diff --git a/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/transport/netty4/Netty4TransportPublishAddressIT.java b/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/transport/netty4/Netty4TransportPublishAddressIT.java
index e6604abf126da..4722cdb66be18 100644
--- a/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/transport/netty4/Netty4TransportPublishAddressIT.java
+++ b/modules/transport-netty4/src/internalClusterTest/java/org/opensearch/transport/netty4/Netty4TransportPublishAddressIT.java
@@ -38,8 +38,8 @@
 import org.opensearch.common.network.NetworkModule;
 import org.opensearch.common.network.NetworkUtils;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.transport.Netty4ModulePlugin;
 import org.opensearch.transport.TransportInfo;
diff --git a/modules/transport-netty4/src/test/java/org/opensearch/http/netty4/Netty4BadRequestTests.java b/modules/transport-netty4/src/test/java/org/opensearch/http/netty4/Netty4BadRequestTests.java
index 5fcfc4ee5e151..1b175d7991e32 100644
--- a/modules/transport-netty4/src/test/java/org/opensearch/http/netty4/Netty4BadRequestTests.java
+++ b/modules/transport-netty4/src/test/java/org/opensearch/http/netty4/Netty4BadRequestTests.java
@@ -38,7 +38,7 @@
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.MockBigArrays;
 import org.opensearch.common.util.MockPageCacheRecycler;
 import org.opensearch.common.util.concurrent.ThreadContext;
diff --git a/modules/transport-netty4/src/test/java/org/opensearch/http/netty4/Netty4HttpServerPipeliningTests.java b/modules/transport-netty4/src/test/java/org/opensearch/http/netty4/Netty4HttpServerPipeliningTests.java
index 6c8cf69afb148..ca8dfb616e313 100644
--- a/modules/transport-netty4/src/test/java/org/opensearch/http/netty4/Netty4HttpServerPipeliningTests.java
+++ b/modules/transport-netty4/src/test/java/org/opensearch/http/netty4/Netty4HttpServerPipeliningTests.java
@@ -45,7 +45,7 @@
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.MockBigArrays;
 import org.opensearch.common.util.MockPageCacheRecycler;
 import org.opensearch.http.HttpPipelinedRequest;
diff --git a/modules/transport-netty4/src/test/java/org/opensearch/http/netty4/Netty4HttpServerTransportTests.java b/modules/transport-netty4/src/test/java/org/opensearch/http/netty4/Netty4HttpServerTransportTests.java
index d23edfda829f9..af4ded2255c9c 100644
--- a/modules/transport-netty4/src/test/java/org/opensearch/http/netty4/Netty4HttpServerTransportTests.java
+++ b/modules/transport-netty4/src/test/java/org/opensearch/http/netty4/Netty4HttpServerTransportTests.java
@@ -64,7 +64,7 @@
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.MockBigArrays;
diff --git a/modules/transport-netty4/src/test/java/org/opensearch/transport/netty4/Netty4SizeHeaderFrameDecoderTests.java b/modules/transport-netty4/src/test/java/org/opensearch/transport/netty4/Netty4SizeHeaderFrameDecoderTests.java
index 5c1c5970a7cfb..db7347bf99345 100644
--- a/modules/transport-netty4/src/test/java/org/opensearch/transport/netty4/Netty4SizeHeaderFrameDecoderTests.java
+++ b/modules/transport-netty4/src/test/java/org/opensearch/transport/netty4/Netty4SizeHeaderFrameDecoderTests.java
@@ -36,7 +36,7 @@
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.MockPageCacheRecycler;
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.core.indices.breaker.NoneCircuitBreakerService;
diff --git a/modules/transport-netty4/src/test/java/org/opensearch/transport/netty4/SimpleNetty4TransportTests.java b/modules/transport-netty4/src/test/java/org/opensearch/transport/netty4/SimpleNetty4TransportTests.java
index ee2bf12a4246f..27bfaef15ca86 100644
--- a/modules/transport-netty4/src/test/java/org/opensearch/transport/netty4/SimpleNetty4TransportTests.java
+++ b/modules/transport-netty4/src/test/java/org/opensearch/transport/netty4/SimpleNetty4TransportTests.java
@@ -39,7 +39,7 @@
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.common.util.net.NetUtils;
diff --git a/plugins/discovery-azure-classic/src/internalClusterTest/java/org/opensearch/cloud/azure/classic/AbstractAzureComputeServiceTestCase.java b/plugins/discovery-azure-classic/src/internalClusterTest/java/org/opensearch/cloud/azure/classic/AbstractAzureComputeServiceTestCase.java
index f95f358532bac..d5d6aae23f344 100644
--- a/plugins/discovery-azure-classic/src/internalClusterTest/java/org/opensearch/cloud/azure/classic/AbstractAzureComputeServiceTestCase.java
+++ b/plugins/discovery-azure-classic/src/internalClusterTest/java/org/opensearch/cloud/azure/classic/AbstractAzureComputeServiceTestCase.java
@@ -47,7 +47,7 @@
 import org.opensearch.common.network.NetworkAddress;
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.discovery.azure.classic.AzureSeedHostsProvider;
 import org.opensearch.plugin.discovery.azure.classic.AzureDiscoveryPlugin;
 import org.opensearch.plugins.Plugin;
diff --git a/plugins/discovery-azure-classic/src/main/java/org/opensearch/discovery/azure/classic/AzureSeedHostsProvider.java b/plugins/discovery-azure-classic/src/main/java/org/opensearch/discovery/azure/classic/AzureSeedHostsProvider.java
index e2bc180876a17..89970fdfc322e 100644
--- a/plugins/discovery-azure-classic/src/main/java/org/opensearch/discovery/azure/classic/AzureSeedHostsProvider.java
+++ b/plugins/discovery-azure-classic/src/main/java/org/opensearch/discovery/azure/classic/AzureSeedHostsProvider.java
@@ -48,7 +48,7 @@
 import org.opensearch.common.network.NetworkAddress;
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.common.Strings;
 import org.opensearch.discovery.SeedHostsProvider;
diff --git a/plugins/discovery-ec2/src/main/java/org/opensearch/discovery/ec2/AwsEc2SeedHostsProvider.java b/plugins/discovery-ec2/src/main/java/org/opensearch/discovery/ec2/AwsEc2SeedHostsProvider.java
index 4afdff7d2c272..0724dbe4543b8 100644
--- a/plugins/discovery-ec2/src/main/java/org/opensearch/discovery/ec2/AwsEc2SeedHostsProvider.java
+++ b/plugins/discovery-ec2/src/main/java/org/opensearch/discovery/ec2/AwsEc2SeedHostsProvider.java
@@ -47,7 +47,7 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.apache.logging.log4j.util.Supplier;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.SingleObjectCache;
 import org.opensearch.discovery.SeedHostsProvider;
diff --git a/plugins/discovery-ec2/src/test/java/org/opensearch/discovery/ec2/Ec2DiscoveryTests.java b/plugins/discovery-ec2/src/test/java/org/opensearch/discovery/ec2/Ec2DiscoveryTests.java
index afa35f63ae4dc..07400f2126fe5 100644
--- a/plugins/discovery-ec2/src/test/java/org/opensearch/discovery/ec2/Ec2DiscoveryTests.java
+++ b/plugins/discovery-ec2/src/test/java/org/opensearch/discovery/ec2/Ec2DiscoveryTests.java
@@ -44,7 +44,7 @@
 import org.opensearch.common.io.Streams;
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.core.indices.breaker.NoneCircuitBreakerService;
 import org.opensearch.test.transport.MockTransportService;
diff --git a/plugins/discovery-ec2/src/test/java/org/opensearch/discovery/ec2/Ec2RetriesTests.java b/plugins/discovery-ec2/src/test/java/org/opensearch/discovery/ec2/Ec2RetriesTests.java
index ea10d03576d94..0f7a86bf76622 100644
--- a/plugins/discovery-ec2/src/test/java/org/opensearch/discovery/ec2/Ec2RetriesTests.java
+++ b/plugins/discovery-ec2/src/test/java/org/opensearch/discovery/ec2/Ec2RetriesTests.java
@@ -41,7 +41,7 @@
 import org.opensearch.common.io.Streams;
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.discovery.SeedHostsProvider;
 import org.opensearch.discovery.SeedHostsResolver;
diff --git a/plugins/discovery-gce/src/main/java/org/opensearch/discovery/gce/GceSeedHostsProvider.java b/plugins/discovery-gce/src/main/java/org/opensearch/discovery/gce/GceSeedHostsProvider.java
index dfd60f52730a6..3295273c83598 100644
--- a/plugins/discovery-gce/src/main/java/org/opensearch/discovery/gce/GceSeedHostsProvider.java
+++ b/plugins/discovery-gce/src/main/java/org/opensearch/discovery/gce/GceSeedHostsProvider.java
@@ -46,7 +46,7 @@
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Setting.Property;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.common.Strings;
 import org.opensearch.discovery.SeedHostsProvider;
diff --git a/plugins/discovery-gce/src/test/java/org/opensearch/discovery/gce/GceDiscoveryTests.java b/plugins/discovery-gce/src/test/java/org/opensearch/discovery/gce/GceDiscoveryTests.java
index 2ca1234bb8a04..c63085deb466f 100644
--- a/plugins/discovery-gce/src/test/java/org/opensearch/discovery/gce/GceDiscoveryTests.java
+++ b/plugins/discovery-gce/src/test/java/org/opensearch/discovery/gce/GceDiscoveryTests.java
@@ -37,7 +37,7 @@
 import org.opensearch.cloud.gce.GceMetadataService;
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.transport.MockTransportService;
 import org.opensearch.threadpool.TestThreadPool;
diff --git a/plugins/transport-nio/src/internalClusterTest/java/org/opensearch/http/nio/NioPipeliningIT.java b/plugins/transport-nio/src/internalClusterTest/java/org/opensearch/http/nio/NioPipeliningIT.java
index ac06bf03ed8cd..9afb8e37cd9a9 100644
--- a/plugins/transport-nio/src/internalClusterTest/java/org/opensearch/http/nio/NioPipeliningIT.java
+++ b/plugins/transport-nio/src/internalClusterTest/java/org/opensearch/http/nio/NioPipeliningIT.java
@@ -34,7 +34,7 @@
 
 import io.netty.handler.codec.http.FullHttpResponse;
 import org.opensearch.NioIntegTestCase;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.http.HttpServerTransport;
 import org.opensearch.test.OpenSearchIntegTestCase.ClusterScope;
 import org.opensearch.test.OpenSearchIntegTestCase.Scope;
diff --git a/plugins/transport-nio/src/test/java/org/opensearch/http/nio/NioHttpServerTransportTests.java b/plugins/transport-nio/src/test/java/org/opensearch/http/nio/NioHttpServerTransportTests.java
index 4d0db18d433ec..22bda4881c322 100644
--- a/plugins/transport-nio/src/test/java/org/opensearch/http/nio/NioHttpServerTransportTests.java
+++ b/plugins/transport-nio/src/test/java/org/opensearch/http/nio/NioHttpServerTransportTests.java
@@ -53,7 +53,7 @@
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.MockBigArrays;
diff --git a/plugins/transport-nio/src/test/java/org/opensearch/transport/nio/SimpleNioTransportTests.java b/plugins/transport-nio/src/test/java/org/opensearch/transport/nio/SimpleNioTransportTests.java
index d0e779edded7d..d7f603031ac17 100644
--- a/plugins/transport-nio/src/test/java/org/opensearch/transport/nio/SimpleNioTransportTests.java
+++ b/plugins/transport-nio/src/test/java/org/opensearch/transport/nio/SimpleNioTransportTests.java
@@ -39,7 +39,7 @@
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.MockPageCacheRecycler;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.common.util.net.NetUtils;
diff --git a/server/src/internalClusterTest/java/org/opensearch/action/support/replication/TransportReplicationActionRetryOnClosedNodeIT.java b/server/src/internalClusterTest/java/org/opensearch/action/support/replication/TransportReplicationActionRetryOnClosedNodeIT.java
index 9f60e65eca297..7d663dd70edd6 100644
--- a/server/src/internalClusterTest/java/org/opensearch/action/support/replication/TransportReplicationActionRetryOnClosedNodeIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/action/support/replication/TransportReplicationActionRetryOnClosedNodeIT.java
@@ -60,7 +60,7 @@
 import org.opensearch.transport.TransportInterceptor;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestOptions;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
diff --git a/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java b/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java
index 69d7ea9e4a3cc..fd6fabe37843f 100644
--- a/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java
+++ b/server/src/main/java/org/opensearch/action/ActionListenerResponseHandler.java
@@ -37,7 +37,7 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportException;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.Objects;
diff --git a/server/src/main/java/org/opensearch/action/ActionResponse.java b/server/src/main/java/org/opensearch/action/ActionResponse.java
index fd13971433d8b..e1d4da760b35b 100644
--- a/server/src/main/java/org/opensearch/action/ActionResponse.java
+++ b/server/src/main/java/org/opensearch/action/ActionResponse.java
@@ -33,7 +33,7 @@
 package org.opensearch.action;
 
 import org.opensearch.core.common.io.stream.StreamInput;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodes.java b/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodes.java
index bddb3fb746eb1..6dd7e09aeae0d 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodes.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodes.java
@@ -41,7 +41,7 @@
 import org.opensearch.common.metrics.OperationStats;
 import org.opensearch.common.network.NetworkModule;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.common.Strings;
diff --git a/server/src/main/java/org/opensearch/action/search/ClearScrollController.java b/server/src/main/java/org/opensearch/action/search/ClearScrollController.java
index eb0fa49a94050..c258b111fa1c6 100644
--- a/server/src/main/java/org/opensearch/action/search/ClearScrollController.java
+++ b/server/src/main/java/org/opensearch/action/search/ClearScrollController.java
@@ -41,7 +41,7 @@
 import org.opensearch.common.util.concurrent.CountDown;
 import org.opensearch.core.common.Strings;
 import org.opensearch.transport.Transport;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.util.ArrayList;
 import java.util.Collection;
diff --git a/server/src/main/java/org/opensearch/action/search/DeletePitInfo.java b/server/src/main/java/org/opensearch/action/search/DeletePitInfo.java
index 1e616ab5ca16e..b33f8a46c8f7a 100644
--- a/server/src/main/java/org/opensearch/action/search/DeletePitInfo.java
+++ b/server/src/main/java/org/opensearch/action/search/DeletePitInfo.java
@@ -15,7 +15,7 @@
 import org.opensearch.core.xcontent.ConstructingObjectParser;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 
diff --git a/server/src/main/java/org/opensearch/action/search/SearchTransportService.java b/server/src/main/java/org/opensearch/action/search/SearchTransportService.java
index 5a280818640ed..37ffca6cac5f2 100644
--- a/server/src/main/java/org/opensearch/action/search/SearchTransportService.java
+++ b/server/src/main/java/org/opensearch/action/search/SearchTransportService.java
@@ -65,7 +65,7 @@
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestOptions;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/action/search/UpdatePitContextResponse.java b/server/src/main/java/org/opensearch/action/search/UpdatePitContextResponse.java
index da39aed20ef8e..1db8fc48c28bc 100644
--- a/server/src/main/java/org/opensearch/action/search/UpdatePitContextResponse.java
+++ b/server/src/main/java/org/opensearch/action/search/UpdatePitContextResponse.java
@@ -10,7 +10,7 @@
 
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 
diff --git a/server/src/main/java/org/opensearch/action/support/ChannelActionListener.java b/server/src/main/java/org/opensearch/action/support/ChannelActionListener.java
index 5b0475093d3c2..07851345241bd 100644
--- a/server/src/main/java/org/opensearch/action/support/ChannelActionListener.java
+++ b/server/src/main/java/org/opensearch/action/support/ChannelActionListener.java
@@ -35,7 +35,7 @@
 import org.opensearch.action.ActionListener;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportRequest;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 /**
  * Listener for transport channel actions
diff --git a/server/src/main/java/org/opensearch/action/support/broadcast/BroadcastShardResponse.java b/server/src/main/java/org/opensearch/action/support/broadcast/BroadcastShardResponse.java
index 39c524448bc5d..9603f886366f2 100644
--- a/server/src/main/java/org/opensearch/action/support/broadcast/BroadcastShardResponse.java
+++ b/server/src/main/java/org/opensearch/action/support/broadcast/BroadcastShardResponse.java
@@ -35,7 +35,7 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.index.shard.ShardId;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 
diff --git a/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java b/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
index 308da88f99d27..4d86bfed5925b 100644
--- a/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeAction.java
@@ -63,7 +63,7 @@
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestHandler;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 import org.opensearch.transport.TransportRequestOptions;
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/BaseNodeResponse.java b/server/src/main/java/org/opensearch/action/support/nodes/BaseNodeResponse.java
index 4a94f790c3443..8a4e12567b515 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/BaseNodeResponse.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/BaseNodeResponse.java
@@ -35,7 +35,7 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 
diff --git a/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java b/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java
index ec1a9c64eadec..398b1a3f2c7b3 100644
--- a/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java
+++ b/server/src/main/java/org/opensearch/action/support/tasks/TransportTasksAction.java
@@ -57,7 +57,7 @@
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestHandler;
 import org.opensearch.transport.TransportRequestOptions;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
diff --git a/server/src/main/java/org/opensearch/bootstrap/Bootstrap.java b/server/src/main/java/org/opensearch/bootstrap/Bootstrap.java
index 2a23b501a8a0e..9383260d1bd73 100644
--- a/server/src/main/java/org/opensearch/bootstrap/Bootstrap.java
+++ b/server/src/main/java/org/opensearch/bootstrap/Bootstrap.java
@@ -55,7 +55,7 @@
 import org.opensearch.common.settings.SecureSettings;
 import org.opensearch.core.common.settings.SecureString;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.env.Environment;
 import org.opensearch.monitor.jvm.JvmInfo;
diff --git a/server/src/main/java/org/opensearch/bootstrap/BootstrapChecks.java b/server/src/main/java/org/opensearch/bootstrap/BootstrapChecks.java
index c27c149947444..f9661e71d60e6 100644
--- a/server/src/main/java/org/opensearch/bootstrap/BootstrapChecks.java
+++ b/server/src/main/java/org/opensearch/bootstrap/BootstrapChecks.java
@@ -42,8 +42,8 @@
 import org.opensearch.common.SuppressForbidden;
 import org.opensearch.common.io.PathUtils;
 import org.opensearch.common.settings.Setting;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.discovery.DiscoveryModule;
 import org.opensearch.env.Environment;
 import org.opensearch.index.IndexModule;
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterSettingsResponse.java b/server/src/main/java/org/opensearch/cluster/ClusterSettingsResponse.java
index ee5c8c00dfaf4..408344f476fe2 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterSettingsResponse.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterSettingsResponse.java
@@ -12,7 +12,7 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.Objects;
diff --git a/server/src/main/java/org/opensearch/cluster/action/index/NodeMappingRefreshAction.java b/server/src/main/java/org/opensearch/cluster/action/index/NodeMappingRefreshAction.java
index e6781fc22e1a7..47e4e59dadd3f 100644
--- a/server/src/main/java/org/opensearch/cluster/action/index/NodeMappingRefreshAction.java
+++ b/server/src/main/java/org/opensearch/cluster/action/index/NodeMappingRefreshAction.java
@@ -48,7 +48,7 @@
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestHandler;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/cluster/action/shard/ShardStateAction.java b/server/src/main/java/org/opensearch/cluster/action/shard/ShardStateAction.java
index 9d9b6c52f6b25..30dcb5fd08954 100644
--- a/server/src/main/java/org/opensearch/cluster/action/shard/ShardStateAction.java
+++ b/server/src/main/java/org/opensearch/cluster/action/shard/ShardStateAction.java
@@ -74,7 +74,7 @@
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestDeduplicator;
 import org.opensearch.transport.TransportRequestHandler;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/ClusterFormationFailureHelper.java b/server/src/main/java/org/opensearch/cluster/coordination/ClusterFormationFailureHelper.java
index 9b51e56dce966..05a5ac862a5b1 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/ClusterFormationFailureHelper.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/ClusterFormationFailureHelper.java
@@ -40,7 +40,7 @@
 import org.opensearch.common.Nullable;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
 import org.opensearch.gateway.GatewayMetaState;
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
index 1c38e68c43466..b57da128ce852 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
@@ -67,7 +67,7 @@
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.OpenSearchExecutors;
 import org.opensearch.common.util.concurrent.ListenableFuture;
@@ -86,7 +86,7 @@
 import org.opensearch.monitor.StatusInfo;
 import org.opensearch.threadpool.Scheduler;
 import org.opensearch.threadpool.ThreadPool.Names;
-import org.opensearch.transport.TransportResponse.Empty;
+import org.opensearch.core.transport.TransportResponse.Empty;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java b/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java
index 1500cf8803cd8..bcdc6448d56d5 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java
@@ -55,7 +55,7 @@
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestOptions;
 import org.opensearch.transport.TransportRequestOptions.Type;
-import org.opensearch.transport.TransportResponse.Empty;
+import org.opensearch.core.transport.TransportResponse.Empty;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java b/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java
index 8955c2d9f806a..10f996f3a7eb8 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java
@@ -67,8 +67,8 @@
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestOptions;
-import org.opensearch.transport.TransportResponse;
-import org.opensearch.transport.TransportResponse.Empty;
+import org.opensearch.core.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse.Empty;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java b/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java
index b684269af8265..3359d6ccee7d5 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java
@@ -56,8 +56,8 @@
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestOptions;
 import org.opensearch.transport.TransportRequestOptions.Type;
-import org.opensearch.transport.TransportResponse;
-import org.opensearch.transport.TransportResponse.Empty;
+import org.opensearch.core.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse.Empty;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/PeersResponse.java b/server/src/main/java/org/opensearch/cluster/coordination/PeersResponse.java
index b68f689ef63fd..8a70c71d53fdd 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/PeersResponse.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/PeersResponse.java
@@ -35,7 +35,7 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.List;
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/PreVoteResponse.java b/server/src/main/java/org/opensearch/cluster/coordination/PreVoteResponse.java
index c8186441db449..9c683f7de0878 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/PreVoteResponse.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/PreVoteResponse.java
@@ -34,7 +34,7 @@
 
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.Objects;
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/Publication.java b/server/src/main/java/org/opensearch/cluster/coordination/Publication.java
index 429890e7420de..6ffca828ecb06 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/Publication.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/Publication.java
@@ -43,7 +43,7 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.transport.TransportException;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java b/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
index 41a54fda7cfc2..f9892205a8e12 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
@@ -51,7 +51,7 @@
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequestOptions;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/PublishWithJoinResponse.java b/server/src/main/java/org/opensearch/cluster/coordination/PublishWithJoinResponse.java
index f99ba82be5514..f6350c5558a82 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/PublishWithJoinResponse.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/PublishWithJoinResponse.java
@@ -33,7 +33,7 @@
 
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.Optional;
diff --git a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
index d6ba0199d193c..f44085a232127 100644
--- a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
+++ b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
@@ -39,7 +39,7 @@
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.node.Node;
diff --git a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodeFilters.java b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodeFilters.java
index 4fd2905495961..2f0fb120311d9 100644
--- a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodeFilters.java
+++ b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodeFilters.java
@@ -37,7 +37,7 @@
 import org.opensearch.common.network.NetworkAddress;
 import org.opensearch.common.regex.Regex;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.common.Strings;
 
 import java.util.HashMap;
diff --git a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java
index 060c7c5eb8d1a..e84bbc7a203f2 100644
--- a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java
+++ b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java
@@ -40,7 +40,7 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.common.regex.Regex;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.set.Sets;
 import org.opensearch.core.common.Strings;
 
diff --git a/server/src/main/java/org/opensearch/discovery/DiscoveryModule.java b/server/src/main/java/org/opensearch/discovery/DiscoveryModule.java
index cf2f7b47288fd..13d9c6d97e079 100644
--- a/server/src/main/java/org/opensearch/discovery/DiscoveryModule.java
+++ b/server/src/main/java/org/opensearch/discovery/DiscoveryModule.java
@@ -49,7 +49,7 @@
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Setting.Property;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.gateway.GatewayMetaState;
 import org.opensearch.monitor.NodeHealthService;
 import org.opensearch.plugins.DiscoveryPlugin;
diff --git a/server/src/main/java/org/opensearch/discovery/FileBasedSeedHostsProvider.java b/server/src/main/java/org/opensearch/discovery/FileBasedSeedHostsProvider.java
index 94f36ba0a546e..3159733336057 100644
--- a/server/src/main/java/org/opensearch/discovery/FileBasedSeedHostsProvider.java
+++ b/server/src/main/java/org/opensearch/discovery/FileBasedSeedHostsProvider.java
@@ -35,7 +35,7 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 
 import java.io.IOException;
 import java.nio.file.Files;
diff --git a/server/src/main/java/org/opensearch/discovery/HandshakingTransportAddressConnector.java b/server/src/main/java/org/opensearch/discovery/HandshakingTransportAddressConnector.java
index 90ca19e9369f4..80ce094785755 100644
--- a/server/src/main/java/org/opensearch/discovery/HandshakingTransportAddressConnector.java
+++ b/server/src/main/java/org/opensearch/discovery/HandshakingTransportAddressConnector.java
@@ -43,7 +43,7 @@
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
 import org.opensearch.common.util.io.IOUtils;
diff --git a/server/src/main/java/org/opensearch/discovery/InitializeExtensionResponse.java b/server/src/main/java/org/opensearch/discovery/InitializeExtensionResponse.java
index f56ffc84a7909..33ca1edcf3330 100644
--- a/server/src/main/java/org/opensearch/discovery/InitializeExtensionResponse.java
+++ b/server/src/main/java/org/opensearch/discovery/InitializeExtensionResponse.java
@@ -34,7 +34,7 @@
 
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.Arrays;
diff --git a/server/src/main/java/org/opensearch/discovery/PeerFinder.java b/server/src/main/java/org/opensearch/discovery/PeerFinder.java
index bea31a03bba1a..0ff095c2b7ba2 100644
--- a/server/src/main/java/org/opensearch/discovery/PeerFinder.java
+++ b/server/src/main/java/org/opensearch/discovery/PeerFinder.java
@@ -44,7 +44,7 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
 import org.opensearch.threadpool.ThreadPool.Names;
diff --git a/server/src/main/java/org/opensearch/discovery/SeedHostsProvider.java b/server/src/main/java/org/opensearch/discovery/SeedHostsProvider.java
index 1a4b5a3182dbe..89dfd9310e895 100644
--- a/server/src/main/java/org/opensearch/discovery/SeedHostsProvider.java
+++ b/server/src/main/java/org/opensearch/discovery/SeedHostsProvider.java
@@ -32,7 +32,7 @@
 
 package org.opensearch.discovery;
 
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 
 import java.util.List;
 
diff --git a/server/src/main/java/org/opensearch/discovery/SeedHostsResolver.java b/server/src/main/java/org/opensearch/discovery/SeedHostsResolver.java
index cef7853011b82..43b685052c9a8 100644
--- a/server/src/main/java/org/opensearch/discovery/SeedHostsResolver.java
+++ b/server/src/main/java/org/opensearch/discovery/SeedHostsResolver.java
@@ -38,7 +38,7 @@
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.CancellableThreads;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
diff --git a/server/src/main/java/org/opensearch/discovery/SettingsBasedSeedHostsProvider.java b/server/src/main/java/org/opensearch/discovery/SettingsBasedSeedHostsProvider.java
index 2dcd819e727f2..9785d5b21078e 100644
--- a/server/src/main/java/org/opensearch/discovery/SettingsBasedSeedHostsProvider.java
+++ b/server/src/main/java/org/opensearch/discovery/SettingsBasedSeedHostsProvider.java
@@ -37,7 +37,7 @@
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Setting.Property;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.transport.TransportService;
 
 import java.util.List;
diff --git a/server/src/main/java/org/opensearch/env/EnvironmentSettingsResponse.java b/server/src/main/java/org/opensearch/env/EnvironmentSettingsResponse.java
index ce3aa0556744b..1b87011ff8c75 100644
--- a/server/src/main/java/org/opensearch/env/EnvironmentSettingsResponse.java
+++ b/server/src/main/java/org/opensearch/env/EnvironmentSettingsResponse.java
@@ -11,7 +11,7 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.Objects;
diff --git a/server/src/main/java/org/opensearch/extensions/AcknowledgedResponse.java b/server/src/main/java/org/opensearch/extensions/AcknowledgedResponse.java
index 7c7e3e78798e8..32ad108b728b7 100644
--- a/server/src/main/java/org/opensearch/extensions/AcknowledgedResponse.java
+++ b/server/src/main/java/org/opensearch/extensions/AcknowledgedResponse.java
@@ -10,7 +10,7 @@
 
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import java.io.IOException;
 import java.util.Objects;
 
diff --git a/server/src/main/java/org/opensearch/extensions/AddSettingsUpdateConsumerRequestHandler.java b/server/src/main/java/org/opensearch/extensions/AddSettingsUpdateConsumerRequestHandler.java
index 67c56b7f458ff..4cac2f3b1562c 100644
--- a/server/src/main/java/org/opensearch/extensions/AddSettingsUpdateConsumerRequestHandler.java
+++ b/server/src/main/java/org/opensearch/extensions/AddSettingsUpdateConsumerRequestHandler.java
@@ -17,7 +17,7 @@
 import org.opensearch.common.settings.SettingsException;
 import org.opensearch.common.settings.SettingsModule;
 import org.opensearch.common.settings.WriteableSetting;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 
 /**
diff --git a/server/src/main/java/org/opensearch/extensions/DiscoveryExtensionNode.java b/server/src/main/java/org/opensearch/extensions/DiscoveryExtensionNode.java
index ac1dfe5309ffa..a888f99ff11ed 100644
--- a/server/src/main/java/org/opensearch/extensions/DiscoveryExtensionNode.java
+++ b/server/src/main/java/org/opensearch/extensions/DiscoveryExtensionNode.java
@@ -15,7 +15,7 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 
diff --git a/server/src/main/java/org/opensearch/extensions/ExtensionDependencyResponse.java b/server/src/main/java/org/opensearch/extensions/ExtensionDependencyResponse.java
index d9531c0cc2894..5fb084caf89f3 100644
--- a/server/src/main/java/org/opensearch/extensions/ExtensionDependencyResponse.java
+++ b/server/src/main/java/org/opensearch/extensions/ExtensionDependencyResponse.java
@@ -15,7 +15,7 @@
 import java.util.Objects;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 /**
  * The response for getting the Extension Dependency.
diff --git a/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java b/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
index ea13cfc324734..7fdfa7201aedb 100644
--- a/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
+++ b/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
@@ -32,7 +32,7 @@
 import org.opensearch.common.util.concurrent.AbstractRunnable;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.settings.SettingsModule;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.common.Strings;
 import org.opensearch.core.common.io.stream.StreamInput;
 
@@ -52,7 +52,7 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ConnectTransportException;
 import org.opensearch.transport.TransportException;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 import org.opensearch.env.EnvironmentSettingsResponse;
diff --git a/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java b/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java
index bd8b80be9fd3b..ce7505cae36c0 100644
--- a/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java
+++ b/server/src/main/java/org/opensearch/extensions/action/ExtensionTransportActionsHandler.java
@@ -22,7 +22,7 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ActionNotFoundTransportException;
 import org.opensearch.transport.TransportException;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
diff --git a/server/src/main/java/org/opensearch/extensions/rest/RestActionsRequestHandler.java b/server/src/main/java/org/opensearch/extensions/rest/RestActionsRequestHandler.java
index d890c1b85bb81..563bfc5a5c9da 100644
--- a/server/src/main/java/org/opensearch/extensions/rest/RestActionsRequestHandler.java
+++ b/server/src/main/java/org/opensearch/extensions/rest/RestActionsRequestHandler.java
@@ -13,7 +13,7 @@
 import org.opensearch.extensions.DiscoveryExtensionNode;
 import org.opensearch.rest.RestController;
 import org.opensearch.rest.RestHandler;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 
 import java.util.Map;
diff --git a/server/src/main/java/org/opensearch/extensions/rest/RestExecuteOnExtensionResponse.java b/server/src/main/java/org/opensearch/extensions/rest/RestExecuteOnExtensionResponse.java
index 63ae6ce93af22..c0c53f4e97b31 100644
--- a/server/src/main/java/org/opensearch/extensions/rest/RestExecuteOnExtensionResponse.java
+++ b/server/src/main/java/org/opensearch/extensions/rest/RestExecuteOnExtensionResponse.java
@@ -12,7 +12,7 @@
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.rest.RestResponse;
 import org.opensearch.core.rest.RestStatus;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.List;
diff --git a/server/src/main/java/org/opensearch/extensions/settings/CustomSettingsRequestHandler.java b/server/src/main/java/org/opensearch/extensions/settings/CustomSettingsRequestHandler.java
index 980dcf67c3128..a9070e77c2942 100644
--- a/server/src/main/java/org/opensearch/extensions/settings/CustomSettingsRequestHandler.java
+++ b/server/src/main/java/org/opensearch/extensions/settings/CustomSettingsRequestHandler.java
@@ -11,7 +11,7 @@
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.SettingsModule;
 import org.opensearch.extensions.AcknowledgedResponse;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/server/src/main/java/org/opensearch/gateway/LocalAllocateDangledIndices.java b/server/src/main/java/org/opensearch/gateway/LocalAllocateDangledIndices.java
index 5ee369d6b9402..5d6843a9684e1 100644
--- a/server/src/main/java/org/opensearch/gateway/LocalAllocateDangledIndices.java
+++ b/server/src/main/java/org/opensearch/gateway/LocalAllocateDangledIndices.java
@@ -59,7 +59,7 @@
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestHandler;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java b/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java
index 0ba49be01d193..bedeedb9c5c6f 100644
--- a/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java
+++ b/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java
@@ -43,10 +43,10 @@
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
 import org.opensearch.common.transport.NetworkExceptionHelper;
 import org.opensearch.common.transport.PortsRange;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.common.util.BigArrays;
 import org.opensearch.common.util.concurrent.ThreadContext;
diff --git a/server/src/main/java/org/opensearch/http/HttpInfo.java b/server/src/main/java/org/opensearch/http/HttpInfo.java
index 24c29b8dc7444..35eadc5a5de9e 100644
--- a/server/src/main/java/org/opensearch/http/HttpInfo.java
+++ b/server/src/main/java/org/opensearch/http/HttpInfo.java
@@ -36,8 +36,8 @@
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.network.InetAddresses;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.node.ReportingService;
diff --git a/server/src/main/java/org/opensearch/http/HttpServerTransport.java b/server/src/main/java/org/opensearch/http/HttpServerTransport.java
index 6549f0786fcda..7bd16a286e33b 100644
--- a/server/src/main/java/org/opensearch/http/HttpServerTransport.java
+++ b/server/src/main/java/org/opensearch/http/HttpServerTransport.java
@@ -33,7 +33,7 @@
 package org.opensearch.http;
 
 import org.opensearch.common.lifecycle.LifecycleComponent;
-import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.node.ReportingService;
 import org.opensearch.rest.RestChannel;
diff --git a/server/src/main/java/org/opensearch/index/IndicesModuleResponse.java b/server/src/main/java/org/opensearch/index/IndicesModuleResponse.java
index 67f2c686dbf8b..3d2340ed35a8c 100644
--- a/server/src/main/java/org/opensearch/index/IndicesModuleResponse.java
+++ b/server/src/main/java/org/opensearch/index/IndicesModuleResponse.java
@@ -10,7 +10,7 @@
 
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.Objects;
diff --git a/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java b/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
index a1376d7318832..5eb5b739d63e1 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
@@ -74,7 +74,7 @@
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestHandler;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
diff --git a/server/src/main/java/org/opensearch/indices/recovery/RecoveryResponse.java b/server/src/main/java/org/opensearch/indices/recovery/RecoveryResponse.java
index 8af69b1786e38..c1203a9f4939f 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/RecoveryResponse.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/RecoveryResponse.java
@@ -34,7 +34,7 @@
 
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.List;
diff --git a/server/src/main/java/org/opensearch/indices/recovery/RecoveryTranslogOperationsResponse.java b/server/src/main/java/org/opensearch/indices/recovery/RecoveryTranslogOperationsResponse.java
index b623d382b415f..9ea9f1d48a494 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/RecoveryTranslogOperationsResponse.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/RecoveryTranslogOperationsResponse.java
@@ -34,7 +34,7 @@
 
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 
diff --git a/server/src/main/java/org/opensearch/indices/recovery/RemoteRecoveryTargetHandler.java b/server/src/main/java/org/opensearch/indices/recovery/RemoteRecoveryTargetHandler.java
index cdc62350b4aa5..35585def29365 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/RemoteRecoveryTargetHandler.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/RemoteRecoveryTargetHandler.java
@@ -48,7 +48,7 @@
 import org.opensearch.indices.replication.SegmentReplicationTargetService;
 import org.opensearch.transport.EmptyTransportResponseHandler;
 import org.opensearch.transport.TransportRequestOptions;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 
 import java.util.List;
diff --git a/server/src/main/java/org/opensearch/indices/recovery/RetryableTransportClient.java b/server/src/main/java/org/opensearch/indices/recovery/RetryableTransportClient.java
index 4f1fb42a421f6..7de2d0e2fb3d4 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/RetryableTransportClient.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/RetryableTransportClient.java
@@ -26,7 +26,7 @@
 import org.opensearch.transport.SendRequestTransportException;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestOptions;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 
 import java.util.Map;
diff --git a/server/src/main/java/org/opensearch/indices/replication/CheckpointInfoResponse.java b/server/src/main/java/org/opensearch/indices/replication/CheckpointInfoResponse.java
index 0155883f34552..72ee7203e5e98 100644
--- a/server/src/main/java/org/opensearch/indices/replication/CheckpointInfoResponse.java
+++ b/server/src/main/java/org/opensearch/indices/replication/CheckpointInfoResponse.java
@@ -12,7 +12,7 @@
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.index.store.StoreFileMetadata;
 import org.opensearch.indices.replication.checkpoint.ReplicationCheckpoint;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.Map;
diff --git a/server/src/main/java/org/opensearch/indices/replication/GetSegmentFilesResponse.java b/server/src/main/java/org/opensearch/indices/replication/GetSegmentFilesResponse.java
index 33a84833f2418..7409e09310737 100644
--- a/server/src/main/java/org/opensearch/indices/replication/GetSegmentFilesResponse.java
+++ b/server/src/main/java/org/opensearch/indices/replication/GetSegmentFilesResponse.java
@@ -11,7 +11,7 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.index.store.StoreFileMetadata;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.List;
diff --git a/server/src/main/java/org/opensearch/indices/replication/RemoteSegmentFileChunkWriter.java b/server/src/main/java/org/opensearch/indices/replication/RemoteSegmentFileChunkWriter.java
index ed171927c4600..d96f9544e5734 100644
--- a/server/src/main/java/org/opensearch/indices/replication/RemoteSegmentFileChunkWriter.java
+++ b/server/src/main/java/org/opensearch/indices/replication/RemoteSegmentFileChunkWriter.java
@@ -20,7 +20,7 @@
 import org.opensearch.indices.recovery.RetryableTransportClient;
 import org.opensearch.indices.recovery.FileChunkWriter;
 import org.opensearch.transport.TransportRequestOptions;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.concurrent.atomic.AtomicLong;
diff --git a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationSourceService.java b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationSourceService.java
index 8bb2a61e32e2d..090e3f96a8f65 100644
--- a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationSourceService.java
+++ b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationSourceService.java
@@ -34,7 +34,7 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportRequestHandler;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTargetService.java b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTargetService.java
index 7c35c4f07598e..b41c9e09add45 100644
--- a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTargetService.java
+++ b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTargetService.java
@@ -41,7 +41,7 @@
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportRequestHandler;
 import org.opensearch.transport.TransportRequestOptions;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 
 import java.util.Map;
diff --git a/server/src/main/java/org/opensearch/indices/replication/common/ReplicationTarget.java b/server/src/main/java/org/opensearch/indices/replication/common/ReplicationTarget.java
index 0c96a87715014..0e06791768745 100644
--- a/server/src/main/java/org/opensearch/indices/replication/common/ReplicationTarget.java
+++ b/server/src/main/java/org/opensearch/indices/replication/common/ReplicationTarget.java
@@ -28,7 +28,7 @@
 import org.opensearch.indices.recovery.FileChunkRequest;
 import org.opensearch.indices.recovery.RecoveryTransportRequest;
 import org.opensearch.transport.TransportChannel;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.concurrent.atomic.AtomicBoolean;
diff --git a/server/src/main/java/org/opensearch/indices/store/IndicesStore.java b/server/src/main/java/org/opensearch/indices/store/IndicesStore.java
index eb5ae01c5261c..c53e865d97b56 100644
--- a/server/src/main/java/org/opensearch/indices/store/IndicesStore.java
+++ b/server/src/main/java/org/opensearch/indices/store/IndicesStore.java
@@ -69,7 +69,7 @@
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestHandler;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
diff --git a/server/src/main/java/org/opensearch/node/Node.java b/server/src/main/java/org/opensearch/node/Node.java
index acdbcc1b5bb7a..1bf0dbb8e423a 100644
--- a/server/src/main/java/org/opensearch/node/Node.java
+++ b/server/src/main/java/org/opensearch/node/Node.java
@@ -138,8 +138,8 @@
 import org.opensearch.common.settings.SettingUpgrader;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.settings.SettingsModule;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.BigArrays;
 import org.opensearch.common.util.PageCacheRecycler;
diff --git a/server/src/main/java/org/opensearch/node/NodeValidationException.java b/server/src/main/java/org/opensearch/node/NodeValidationException.java
index ef1500f1e4ede..b316288b7cf06 100644
--- a/server/src/main/java/org/opensearch/node/NodeValidationException.java
+++ b/server/src/main/java/org/opensearch/node/NodeValidationException.java
@@ -32,7 +32,7 @@
 
 package org.opensearch.node;
 
-import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
 
 import java.util.List;
 
diff --git a/server/src/main/java/org/opensearch/plugins/DiscoveryPlugin.java b/server/src/main/java/org/opensearch/plugins/DiscoveryPlugin.java
index 89433b2a3b67d..bca72942bd70e 100644
--- a/server/src/main/java/org/opensearch/plugins/DiscoveryPlugin.java
+++ b/server/src/main/java/org/opensearch/plugins/DiscoveryPlugin.java
@@ -37,6 +37,7 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.discovery.SeedHostsProvider;
 import org.opensearch.transport.TransportService;
 
@@ -86,7 +87,7 @@ default NetworkService.CustomNameResolver getCustomNameResolver(Settings setting
      * (see {@link org.opensearch.discovery.DiscoveryModule#DISCOVERY_SEED_PROVIDERS_SETTING}), and
      * the value is a supplier to construct the host provider when it is selected for use.
      *
-     * @param transportService Use to form the {@link org.opensearch.common.transport.TransportAddress} portion
+     * @param transportService Use to form the {@link TransportAddress} portion
      *                         of a {@link org.opensearch.cluster.node.DiscoveryNode}
      * @param networkService Use to find the publish host address of the current node
      */
diff --git a/server/src/main/java/org/opensearch/repositories/VerifyNodeRepositoryAction.java b/server/src/main/java/org/opensearch/repositories/VerifyNodeRepositoryAction.java
index ff5ffdbfe1e3e..1f0a5060962c6 100644
--- a/server/src/main/java/org/opensearch/repositories/VerifyNodeRepositoryAction.java
+++ b/server/src/main/java/org/opensearch/repositories/VerifyNodeRepositoryAction.java
@@ -48,7 +48,7 @@
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestHandler;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
index b54c8955283a2..e29898624386c 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
@@ -48,7 +48,7 @@
 import org.opensearch.common.Table;
 import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.network.NetworkAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.http.HttpInfo;
 import org.opensearch.index.cache.query.QueryCacheStats;
diff --git a/server/src/main/java/org/opensearch/search/SearchPhaseResult.java b/server/src/main/java/org/opensearch/search/SearchPhaseResult.java
index 1b4cebbe91a3e..9aace832cf72f 100644
--- a/server/src/main/java/org/opensearch/search/SearchPhaseResult.java
+++ b/server/src/main/java/org/opensearch/search/SearchPhaseResult.java
@@ -39,7 +39,7 @@
 import org.opensearch.search.internal.ShardSearchContextId;
 import org.opensearch.search.internal.ShardSearchRequest;
 import org.opensearch.search.query.QuerySearchResult;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 
diff --git a/server/src/main/java/org/opensearch/tasks/TaskCancellationService.java b/server/src/main/java/org/opensearch/tasks/TaskCancellationService.java
index 7ff27fa1096dc..a24cdd02bbd30 100644
--- a/server/src/main/java/org/opensearch/tasks/TaskCancellationService.java
+++ b/server/src/main/java/org/opensearch/tasks/TaskCancellationService.java
@@ -49,7 +49,7 @@
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestHandler;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/transport/ActionTransportException.java b/server/src/main/java/org/opensearch/transport/ActionTransportException.java
index 97e9a986db7f4..fb5dd2c75dc75 100644
--- a/server/src/main/java/org/opensearch/transport/ActionTransportException.java
+++ b/server/src/main/java/org/opensearch/transport/ActionTransportException.java
@@ -34,7 +34,7 @@
 
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 
 import java.io.IOException;
 
diff --git a/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java
index d799b9b078137..d63e0ce442129 100644
--- a/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java
+++ b/server/src/main/java/org/opensearch/transport/EmptyTransportResponseHandler.java
@@ -35,6 +35,7 @@
 import java.io.IOException;
 
 import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.threadpool.ThreadPool;
 
 /**
diff --git a/server/src/main/java/org/opensearch/transport/InboundHandler.java b/server/src/main/java/org/opensearch/transport/InboundHandler.java
index 3e4ea2bab2109..d0d765226cdea 100644
--- a/server/src/main/java/org/opensearch/transport/InboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/InboundHandler.java
@@ -51,7 +51,7 @@
 import org.opensearch.core.common.io.stream.NamedWriteableAwareStreamInput;
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.core.common.io.stream.StreamInput;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
 import org.opensearch.common.util.concurrent.ThreadContext;
@@ -62,6 +62,7 @@
 import org.opensearch.server.proto.NodesStatsProto.NodesStats;
 import org.opensearch.server.proto.NodesStatsRequestProto.NodesStatsRequest;
 import org.opensearch.server.proto.MessageProto.OutboundInboundMessage;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.threadpool.ThreadPool;
 
 import java.io.EOFException;
diff --git a/server/src/main/java/org/opensearch/transport/OutboundHandler.java b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
index 9728776010769..7a7c370c9777c 100644
--- a/server/src/main/java/org/opensearch/transport/OutboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/OutboundHandler.java
@@ -51,12 +51,13 @@
 import org.opensearch.common.io.stream.ReleasableBytesStreamOutput;
 import org.opensearch.common.network.CloseableChannel;
 import org.opensearch.common.transport.NetworkExceptionHelper;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.BigArrays;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.lease.Releasables;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.threadpool.ThreadPool;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/transport/PlainTransportFuture.java b/server/src/main/java/org/opensearch/transport/PlainTransportFuture.java
index 71ab562cdc1de..e257c0135fb40 100644
--- a/server/src/main/java/org/opensearch/transport/PlainTransportFuture.java
+++ b/server/src/main/java/org/opensearch/transport/PlainTransportFuture.java
@@ -36,6 +36,7 @@
 import org.opensearch.OpenSearchTimeoutException;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.util.concurrent.BaseFuture;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.concurrent.ExecutionException;
diff --git a/server/src/main/java/org/opensearch/transport/ProxyConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/ProxyConnectionStrategy.java
index b1eefb9fac245..fcaad01e78a50 100644
--- a/server/src/main/java/org/opensearch/transport/ProxyConnectionStrategy.java
+++ b/server/src/main/java/org/opensearch/transport/ProxyConnectionStrategy.java
@@ -43,7 +43,7 @@
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.concurrent.CountDown;
 import org.opensearch.core.common.Strings;
 import org.opensearch.core.xcontent.XContentBuilder;
diff --git a/server/src/main/java/org/opensearch/transport/RemoteTransportException.java b/server/src/main/java/org/opensearch/transport/RemoteTransportException.java
index 041a70795b8de..de3d6bb9d775e 100644
--- a/server/src/main/java/org/opensearch/transport/RemoteTransportException.java
+++ b/server/src/main/java/org/opensearch/transport/RemoteTransportException.java
@@ -34,7 +34,7 @@
 
 import org.opensearch.OpenSearchWrapperException;
 import org.opensearch.core.common.io.stream.StreamInput;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 
 import java.io.IOException;
 
diff --git a/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java
index 8d879ce45b2a7..6a2e211072dab 100644
--- a/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java
+++ b/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java
@@ -50,7 +50,7 @@
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.core.common.Strings;
 import org.opensearch.core.xcontent.XContentBuilder;
diff --git a/server/src/main/java/org/opensearch/transport/TaskTransportChannel.java b/server/src/main/java/org/opensearch/transport/TaskTransportChannel.java
index 4dceee4c48d4d..052611317f174 100644
--- a/server/src/main/java/org/opensearch/transport/TaskTransportChannel.java
+++ b/server/src/main/java/org/opensearch/transport/TaskTransportChannel.java
@@ -34,6 +34,7 @@
 
 import org.opensearch.Version;
 import org.opensearch.common.lease.Releasable;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 
diff --git a/server/src/main/java/org/opensearch/transport/TcpTransport.java b/server/src/main/java/org/opensearch/transport/TcpTransport.java
index 216f80d99632f..2708a33f9f582 100644
--- a/server/src/main/java/org/opensearch/transport/TcpTransport.java
+++ b/server/src/main/java/org/opensearch/transport/TcpTransport.java
@@ -54,9 +54,9 @@
 import org.opensearch.common.network.NetworkUtils;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
 import org.opensearch.common.transport.PortsRange;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.BigArrays;
diff --git a/server/src/main/java/org/opensearch/transport/TcpTransportChannel.java b/server/src/main/java/org/opensearch/transport/TcpTransportChannel.java
index e25003648794d..00702d08902a9 100644
--- a/server/src/main/java/org/opensearch/transport/TcpTransportChannel.java
+++ b/server/src/main/java/org/opensearch/transport/TcpTransportChannel.java
@@ -34,6 +34,7 @@
 
 import org.opensearch.Version;
 import org.opensearch.common.lease.Releasable;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.search.query.QuerySearchResult;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/transport/Transport.java b/server/src/main/java/org/opensearch/transport/Transport.java
index 89a7de4ff553d..764f4e18859f5 100644
--- a/server/src/main/java/org/opensearch/transport/Transport.java
+++ b/server/src/main/java/org/opensearch/transport/Transport.java
@@ -37,11 +37,12 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.collect.MapBuilder;
 import org.opensearch.common.lifecycle.LifecycleComponent;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.ConcurrentCollections;
 import org.opensearch.common.util.concurrent.ConcurrentMapLong;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.Closeable;
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/transport/TransportActionProxy.java b/server/src/main/java/org/opensearch/transport/TransportActionProxy.java
index 2609648cbff23..463e729739e93 100644
--- a/server/src/main/java/org/opensearch/transport/TransportActionProxy.java
+++ b/server/src/main/java/org/opensearch/transport/TransportActionProxy.java
@@ -35,6 +35,7 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
 
diff --git a/server/src/main/java/org/opensearch/transport/TransportChannel.java b/server/src/main/java/org/opensearch/transport/TransportChannel.java
index b660db029c0b2..3c582127f28e8 100644
--- a/server/src/main/java/org/opensearch/transport/TransportChannel.java
+++ b/server/src/main/java/org/opensearch/transport/TransportChannel.java
@@ -36,6 +36,7 @@
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.Version;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 
diff --git a/server/src/main/java/org/opensearch/transport/TransportHandshaker.java b/server/src/main/java/org/opensearch/transport/TransportHandshaker.java
index 1bdee8e1fca29..e34b3917ab97b 100644
--- a/server/src/main/java/org/opensearch/transport/TransportHandshaker.java
+++ b/server/src/main/java/org/opensearch/transport/TransportHandshaker.java
@@ -40,6 +40,7 @@
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.common.metrics.CounterMetric;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.threadpool.ThreadPool;
 
 import java.io.EOFException;
diff --git a/server/src/main/java/org/opensearch/transport/TransportInfo.java b/server/src/main/java/org/opensearch/transport/TransportInfo.java
index 0ee8672e8df8c..308abb2bc28f4 100644
--- a/server/src/main/java/org/opensearch/transport/TransportInfo.java
+++ b/server/src/main/java/org/opensearch/transport/TransportInfo.java
@@ -37,8 +37,8 @@
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.network.InetAddresses;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.node.ReportingService;
 
diff --git a/server/src/main/java/org/opensearch/transport/TransportInterceptor.java b/server/src/main/java/org/opensearch/transport/TransportInterceptor.java
index d09b9a55aaa6e..c44acdfe4c585 100644
--- a/server/src/main/java/org/opensearch/transport/TransportInterceptor.java
+++ b/server/src/main/java/org/opensearch/transport/TransportInterceptor.java
@@ -34,6 +34,7 @@
 
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.core.common.io.stream.Writeable.Reader;
+import org.opensearch.core.transport.TransportResponse;
 
 /**
  * This interface allows plugins to intercept requests on both the sender and the receiver side.
diff --git a/server/src/main/java/org/opensearch/transport/TransportMessageListener.java b/server/src/main/java/org/opensearch/transport/TransportMessageListener.java
index 8a7612d3bd99a..dfcd7acce3706 100644
--- a/server/src/main/java/org/opensearch/transport/TransportMessageListener.java
+++ b/server/src/main/java/org/opensearch/transport/TransportMessageListener.java
@@ -32,6 +32,7 @@
 package org.opensearch.transport;
 
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.core.transport.TransportResponse;
 
 /**
  * Listens for transport messages
diff --git a/server/src/main/java/org/opensearch/transport/TransportRequest.java b/server/src/main/java/org/opensearch/transport/TransportRequest.java
index a868476733208..9e507a730fead 100644
--- a/server/src/main/java/org/opensearch/transport/TransportRequest.java
+++ b/server/src/main/java/org/opensearch/transport/TransportRequest.java
@@ -36,6 +36,7 @@
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.tasks.ProtobufTaskAwareRequest;
 import org.opensearch.tasks.ProtobufTaskId;
+import org.opensearch.core.transport.TransportMessage;
 import org.opensearch.tasks.TaskAwareRequest;
 import org.opensearch.tasks.TaskId;
 
diff --git a/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java
index d4fad0e299d35..5e6cf0200c473 100644
--- a/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java
+++ b/server/src/main/java/org/opensearch/transport/TransportResponseHandler.java
@@ -35,6 +35,7 @@
 import org.opensearch.core.common.io.stream.ProtobufWriteable;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.function.Function;
diff --git a/server/src/main/java/org/opensearch/transport/TransportService.java b/server/src/main/java/org/opensearch/transport/TransportService.java
index cbd550396f5dd..57ef5df700859 100644
--- a/server/src/main/java/org/opensearch/transport/TransportService.java
+++ b/server/src/main/java/org/opensearch/transport/TransportService.java
@@ -53,8 +53,8 @@
 import org.opensearch.common.regex.Regex;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
 import org.opensearch.common.util.concurrent.ThreadContext;
@@ -62,6 +62,7 @@
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.core.common.Strings;
 import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.node.NodeClosedException;
 import org.opensearch.node.ReportingService;
 import org.opensearch.tasks.Task;
diff --git a/server/src/test/java/org/opensearch/ExceptionSerializationTests.java b/server/src/test/java/org/opensearch/ExceptionSerializationTests.java
index 629fe9ebd4b99..920f3026871a0 100644
--- a/server/src/test/java/org/opensearch/ExceptionSerializationTests.java
+++ b/server/src/test/java/org/opensearch/ExceptionSerializationTests.java
@@ -72,7 +72,7 @@
 import org.opensearch.core.common.io.stream.NotSerializableExceptionWrapper;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.common.util.CancellableThreadsTests;
 import org.opensearch.common.util.set.Sets;
diff --git a/server/src/test/java/org/opensearch/action/admin/cluster/node/tasks/TaskManagerTestCase.java b/server/src/test/java/org/opensearch/action/admin/cluster/node/tasks/TaskManagerTestCase.java
index e0676cc9ddbdd..1b8d3a2c276fb 100644
--- a/server/src/test/java/org/opensearch/action/admin/cluster/node/tasks/TaskManagerTestCase.java
+++ b/server/src/test/java/org/opensearch/action/admin/cluster/node/tasks/TaskManagerTestCase.java
@@ -53,7 +53,7 @@
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.core.indices.breaker.NoneCircuitBreakerService;
diff --git a/server/src/test/java/org/opensearch/action/admin/cluster/node/tasks/TestTaskPlugin.java b/server/src/test/java/org/opensearch/action/admin/cluster/node/tasks/TestTaskPlugin.java
index b46d4fcfea2c9..6b4317d6ec934 100644
--- a/server/src/test/java/org/opensearch/action/admin/cluster/node/tasks/TestTaskPlugin.java
+++ b/server/src/test/java/org/opensearch/action/admin/cluster/node/tasks/TestTaskPlugin.java
@@ -73,7 +73,7 @@
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportService;
 import org.opensearch.transport.TransportRequestOptions;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 
 import java.io.IOException;
diff --git a/server/src/test/java/org/opensearch/action/admin/cluster/reroute/ClusterRerouteResponseTests.java b/server/src/test/java/org/opensearch/action/admin/cluster/reroute/ClusterRerouteResponseTests.java
index 5571eb020b9e0..a2998b4bf6be7 100644
--- a/server/src/test/java/org/opensearch/action/admin/cluster/reroute/ClusterRerouteResponseTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/cluster/reroute/ClusterRerouteResponseTests.java
@@ -45,7 +45,7 @@
 import org.opensearch.cluster.routing.allocation.decider.Decision;
 import org.opensearch.common.Strings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.common.xcontent.json.JsonXContent;
diff --git a/server/src/test/java/org/opensearch/action/admin/cluster/shards/ClusterSearchShardsResponseTests.java b/server/src/test/java/org/opensearch/action/admin/cluster/shards/ClusterSearchShardsResponseTests.java
index a09a580de1475..ee4f22c6af93b 100644
--- a/server/src/test/java/org/opensearch/action/admin/cluster/shards/ClusterSearchShardsResponseTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/cluster/shards/ClusterSearchShardsResponseTests.java
@@ -42,7 +42,7 @@
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.common.Strings;
 import org.opensearch.index.query.RandomQueryBuilder;
 import org.opensearch.core.index.shard.ShardId;
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/close/TransportVerifyShardBeforeCloseActionTests.java b/server/src/test/java/org/opensearch/action/admin/indices/close/TransportVerifyShardBeforeCloseActionTests.java
index 55e4efd8b10df..86e87de364a51 100644
--- a/server/src/test/java/org/opensearch/action/admin/indices/close/TransportVerifyShardBeforeCloseActionTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/indices/close/TransportVerifyShardBeforeCloseActionTests.java
@@ -70,7 +70,7 @@
 import org.opensearch.test.transport.CapturingTransport;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 
 import java.util.Collections;
diff --git a/server/src/test/java/org/opensearch/action/bulk/TransportShardBulkActionTests.java b/server/src/test/java/org/opensearch/action/bulk/TransportShardBulkActionTests.java
index c0c35e8c22f4d..ebdc7dcbfd6ac 100644
--- a/server/src/test/java/org/opensearch/action/bulk/TransportShardBulkActionTests.java
+++ b/server/src/test/java/org/opensearch/action/bulk/TransportShardBulkActionTests.java
@@ -92,7 +92,7 @@
 import org.opensearch.threadpool.ThreadPool.Names;
 import org.opensearch.transport.TestTransportChannel;
 import org.opensearch.transport.TransportChannel;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
diff --git a/server/src/test/java/org/opensearch/action/search/ClearScrollControllerTests.java b/server/src/test/java/org/opensearch/action/search/ClearScrollControllerTests.java
index e3c7d4741d3ae..55e597dab04dc 100644
--- a/server/src/test/java/org/opensearch/action/search/ClearScrollControllerTests.java
+++ b/server/src/test/java/org/opensearch/action/search/ClearScrollControllerTests.java
@@ -46,7 +46,7 @@
 import org.opensearch.test.VersionUtils;
 import org.opensearch.transport.NodeNotConnectedException;
 import org.opensearch.transport.Transport;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.Arrays;
diff --git a/server/src/test/java/org/opensearch/action/search/TransportSearchActionTests.java b/server/src/test/java/org/opensearch/action/search/TransportSearchActionTests.java
index 413fff98de44c..05df501faae82 100644
--- a/server/src/test/java/org/opensearch/action/search/TransportSearchActionTests.java
+++ b/server/src/test/java/org/opensearch/action/search/TransportSearchActionTests.java
@@ -54,7 +54,7 @@
 import org.opensearch.common.SetOnce;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.common.Strings;
 import org.opensearch.core.index.Index;
 import org.opensearch.index.query.InnerHitBuilder;
diff --git a/server/src/test/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeActionTests.java b/server/src/test/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeActionTests.java
index 23654c02f0901..5c328c279fabb 100644
--- a/server/src/test/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeActionTests.java
+++ b/server/src/test/java/org/opensearch/action/support/broadcast/node/TransportBroadcastByNodeActionTests.java
@@ -73,7 +73,7 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.ReceiveTimeoutTransportException;
 import org.opensearch.transport.TestTransportChannel;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 import org.junit.After;
 import org.junit.AfterClass;
diff --git a/server/src/test/java/org/opensearch/action/support/replication/ReplicationOperationTests.java b/server/src/test/java/org/opensearch/action/support/replication/ReplicationOperationTests.java
index 21d14fb31059d..10d5a87e8200a 100644
--- a/server/src/test/java/org/opensearch/action/support/replication/ReplicationOperationTests.java
+++ b/server/src/test/java/org/opensearch/action/support/replication/ReplicationOperationTests.java
@@ -51,7 +51,7 @@
 import org.opensearch.cluster.routing.ShardRoutingState;
 import org.opensearch.core.common.breaker.CircuitBreaker;
 import org.opensearch.core.common.breaker.CircuitBreakingException;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.ConcurrentCollections;
 import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
diff --git a/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationActionTests.java b/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationActionTests.java
index 5af358cae18a8..7d47238b8e5ab 100644
--- a/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationActionTests.java
+++ b/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationActionTests.java
@@ -102,7 +102,7 @@
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 import org.opensearch.transport.nio.MockNioTransport;
 
diff --git a/server/src/test/java/org/opensearch/action/support/replication/TransportWriteActionForIndexingPressureTests.java b/server/src/test/java/org/opensearch/action/support/replication/TransportWriteActionForIndexingPressureTests.java
index c978031103ff2..4a7500f16197d 100644
--- a/server/src/test/java/org/opensearch/action/support/replication/TransportWriteActionForIndexingPressureTests.java
+++ b/server/src/test/java/org/opensearch/action/support/replication/TransportWriteActionForIndexingPressureTests.java
@@ -41,7 +41,7 @@
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportChannel;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 import org.hamcrest.Matcher;
 import org.junit.After;
diff --git a/server/src/test/java/org/opensearch/action/support/replication/TransportWriteActionTests.java b/server/src/test/java/org/opensearch/action/support/replication/TransportWriteActionTests.java
index 7a0d0f3814100..a2d5e92fa11fe 100644
--- a/server/src/test/java/org/opensearch/action/support/replication/TransportWriteActionTests.java
+++ b/server/src/test/java/org/opensearch/action/support/replication/TransportWriteActionTests.java
@@ -72,7 +72,7 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportException;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 import org.junit.After;
 import org.junit.AfterClass;
diff --git a/server/src/test/java/org/opensearch/bootstrap/BootstrapChecksTests.java b/server/src/test/java/org/opensearch/bootstrap/BootstrapChecksTests.java
index 15aacd25b30b1..69102d2e76bef 100644
--- a/server/src/test/java/org/opensearch/bootstrap/BootstrapChecksTests.java
+++ b/server/src/test/java/org/opensearch/bootstrap/BootstrapChecksTests.java
@@ -40,8 +40,8 @@
 import org.opensearch.common.CheckedConsumer;
 import org.opensearch.common.io.PathUtils;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.discovery.DiscoveryModule;
 import org.opensearch.discovery.SettingsBasedSeedHostsProvider;
 import org.opensearch.env.Environment;
diff --git a/server/src/test/java/org/opensearch/cluster/ClusterStateTests.java b/server/src/test/java/org/opensearch/cluster/ClusterStateTests.java
index 23c2506bf6143..20b68f32a69e4 100644
--- a/server/src/test/java/org/opensearch/cluster/ClusterStateTests.java
+++ b/server/src/test/java/org/opensearch/cluster/ClusterStateTests.java
@@ -51,7 +51,7 @@
 import org.opensearch.cluster.routing.TestShardRouting;
 import org.opensearch.common.Strings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.common.xcontent.json.JsonXContent;
diff --git a/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java b/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java
index 124ecd52ac538..c33dd9c732045 100644
--- a/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/NodeConnectionsServiceTests.java
@@ -48,8 +48,8 @@
 import org.opensearch.common.lifecycle.Lifecycle;
 import org.opensearch.common.lifecycle.LifecycleListener;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.MockLogAppender;
 import org.opensearch.test.junit.annotations.TestLogging;
diff --git a/server/src/test/java/org/opensearch/cluster/action/shard/ShardStateActionTests.java b/server/src/test/java/org/opensearch/cluster/action/shard/ShardStateActionTests.java
index 2688aaa145dc0..957da6ea65b89 100644
--- a/server/src/test/java/org/opensearch/cluster/action/shard/ShardStateActionTests.java
+++ b/server/src/test/java/org/opensearch/cluster/action/shard/ShardStateActionTests.java
@@ -64,7 +64,7 @@
 import org.opensearch.transport.NodeNotConnectedException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 import org.junit.After;
 import org.junit.AfterClass;
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/ClusterFormationFailureHelperTests.java b/server/src/test/java/org/opensearch/cluster/coordination/ClusterFormationFailureHelperTests.java
index b091130db0b98..efdf4fb4b92f5 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/ClusterFormationFailureHelperTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/ClusterFormationFailureHelperTests.java
@@ -41,7 +41,7 @@
 import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.gateway.GatewayMetaState;
 import org.opensearch.monitor.StatusInfo;
 import org.opensearch.test.OpenSearchTestCase;
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/CoordinationStateTests.java b/server/src/test/java/org/opensearch/cluster/coordination/CoordinationStateTests.java
index 23087e6dd2ba4..bae7581f8d9e0 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/CoordinationStateTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/CoordinationStateTests.java
@@ -43,7 +43,7 @@
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.EqualsHashCodeTestUtils;
 import org.junit.Before;
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/FollowersCheckerTests.java b/server/src/test/java/org/opensearch/cluster/coordination/FollowersCheckerTests.java
index 0b84eaf1ae6db..89948c1bd8c9d 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/FollowersCheckerTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/FollowersCheckerTests.java
@@ -53,8 +53,8 @@
 import org.opensearch.transport.ConnectTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
-import org.opensearch.transport.TransportResponse;
-import org.opensearch.transport.TransportResponse.Empty;
+import org.opensearch.core.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse.Empty;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/JoinHelperTests.java b/server/src/test/java/org/opensearch/cluster/coordination/JoinHelperTests.java
index 27146829ad8da..f63f33f345411 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/JoinHelperTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/JoinHelperTests.java
@@ -53,7 +53,7 @@
 import org.opensearch.transport.RemoteTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/LeaderCheckerTests.java b/server/src/test/java/org/opensearch/cluster/coordination/LeaderCheckerTests.java
index cf3cab116716a..bc118791ec6c8 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/LeaderCheckerTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/LeaderCheckerTests.java
@@ -50,8 +50,8 @@
 import org.opensearch.transport.ConnectTransportException;
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
-import org.opensearch.transport.TransportResponse;
-import org.opensearch.transport.TransportResponse.Empty;
+import org.opensearch.core.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse.Empty;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/NodeJoinTests.java b/server/src/test/java/org/opensearch/cluster/coordination/NodeJoinTests.java
index fb2e7cd73d3bf..09a7b34958f2c 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/NodeJoinTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/NodeJoinTests.java
@@ -68,7 +68,7 @@
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestOptions;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 import org.junit.After;
 import org.junit.AfterClass;
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/PublicationTests.java b/server/src/test/java/org/opensearch/cluster/coordination/PublicationTests.java
index 517456f54b785..366f19f74aac8 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/PublicationTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/PublicationTests.java
@@ -47,7 +47,7 @@
 import org.opensearch.discovery.Discovery;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.transport.TransportException;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.util.ArrayList;
 import java.util.Arrays;
diff --git a/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodeFiltersTests.java b/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodeFiltersTests.java
index 54f9c46e999d7..691a3cb418f94 100644
--- a/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodeFiltersTests.java
+++ b/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodeFiltersTests.java
@@ -35,7 +35,7 @@
 import org.opensearch.Version;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.test.OpenSearchTestCase;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
diff --git a/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodeTests.java b/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodeTests.java
index 14f6880419286..b4f03b1d7a850 100644
--- a/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodeTests.java
+++ b/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodeTests.java
@@ -37,7 +37,7 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.test.NodeRoles;
 import org.opensearch.test.OpenSearchTestCase;
 
diff --git a/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodesTests.java b/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodesTests.java
index 47676ecc13f5e..f5b7d98bb95ce 100644
--- a/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodesTests.java
+++ b/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodesTests.java
@@ -36,7 +36,7 @@
 import org.opensearch.LegacyESVersion;
 import org.opensearch.Version;
 import org.opensearch.common.settings.Setting;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.util.ArrayList;
diff --git a/server/src/test/java/org/opensearch/cluster/routing/RoutingNodeTests.java b/server/src/test/java/org/opensearch/cluster/routing/RoutingNodeTests.java
index 578d537653684..cc4f2e510cb31 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/RoutingNodeTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/RoutingNodeTests.java
@@ -35,7 +35,7 @@
 import org.opensearch.Version;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.test.OpenSearchTestCase;
diff --git a/server/src/test/java/org/opensearch/common/network/NetworkModuleTests.java b/server/src/test/java/org/opensearch/common/network/NetworkModuleTests.java
index f795df2f48b22..5b47d9babd264 100644
--- a/server/src/test/java/org/opensearch/common/network/NetworkModuleTests.java
+++ b/server/src/test/java/org/opensearch/common/network/NetworkModuleTests.java
@@ -36,7 +36,7 @@
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
 import org.opensearch.common.util.BigArrays;
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.common.util.concurrent.ThreadContext;
diff --git a/server/src/test/java/org/opensearch/common/transport/BoundTransportAddressTests.java b/server/src/test/java/org/opensearch/common/transport/BoundTransportAddressTests.java
index a177840059f8f..dae16d805efbf 100644
--- a/server/src/test/java/org/opensearch/common/transport/BoundTransportAddressTests.java
+++ b/server/src/test/java/org/opensearch/common/transport/BoundTransportAddressTests.java
@@ -34,6 +34,8 @@
 
 import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.net.InetAddress;
diff --git a/server/src/test/java/org/opensearch/discovery/FileBasedSeedHostsProviderTests.java b/server/src/test/java/org/opensearch/discovery/FileBasedSeedHostsProviderTests.java
index acf94483c8116..0f8c40a0bd759 100644
--- a/server/src/test/java/org/opensearch/discovery/FileBasedSeedHostsProviderTests.java
+++ b/server/src/test/java/org/opensearch/discovery/FileBasedSeedHostsProviderTests.java
@@ -36,8 +36,8 @@
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.CancellableThreads;
 import org.opensearch.common.util.PageCacheRecycler;
diff --git a/server/src/test/java/org/opensearch/discovery/HandshakingTransportAddressConnectorTests.java b/server/src/test/java/org/opensearch/discovery/HandshakingTransportAddressConnectorTests.java
index 5d252168c7b28..e4703626d08fc 100644
--- a/server/src/test/java/org/opensearch/discovery/HandshakingTransportAddressConnectorTests.java
+++ b/server/src/test/java/org/opensearch/discovery/HandshakingTransportAddressConnectorTests.java
@@ -43,7 +43,7 @@
 import org.opensearch.common.Nullable;
 import org.opensearch.common.SetOnce;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.MockLogAppender;
 import org.opensearch.test.junit.annotations.TestLogging;
diff --git a/server/src/test/java/org/opensearch/discovery/InitializeExtensionRequestTests.java b/server/src/test/java/org/opensearch/discovery/InitializeExtensionRequestTests.java
index 63b79c9b53081..0be812ce847f8 100644
--- a/server/src/test/java/org/opensearch/discovery/InitializeExtensionRequestTests.java
+++ b/server/src/test/java/org/opensearch/discovery/InitializeExtensionRequestTests.java
@@ -13,7 +13,7 @@
 import org.opensearch.core.common.bytes.BytesReference;
 import org.opensearch.core.common.io.stream.BytesStreamInput;
 import org.opensearch.common.io.stream.BytesStreamOutput;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.extensions.DiscoveryExtensionNode;
 import org.opensearch.extensions.ExtensionDependency;
 import org.opensearch.test.OpenSearchTestCase;
diff --git a/server/src/test/java/org/opensearch/discovery/PeerFinderTests.java b/server/src/test/java/org/opensearch/discovery/PeerFinderTests.java
index d0273bca3b31f..014ca0d96e618 100644
--- a/server/src/test/java/org/opensearch/discovery/PeerFinderTests.java
+++ b/server/src/test/java/org/opensearch/discovery/PeerFinderTests.java
@@ -42,7 +42,7 @@
 import org.opensearch.cluster.node.DiscoveryNodes.Builder;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.discovery.PeerFinder.TransportAddressConnector;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.transport.CapturingTransport;
diff --git a/server/src/test/java/org/opensearch/discovery/SeedHostsResolverTests.java b/server/src/test/java/org/opensearch/discovery/SeedHostsResolverTests.java
index 07491cc0d6435..724d3fbee3939 100644
--- a/server/src/test/java/org/opensearch/discovery/SeedHostsResolverTests.java
+++ b/server/src/test/java/org/opensearch/discovery/SeedHostsResolverTests.java
@@ -39,8 +39,8 @@
 import org.opensearch.common.network.NetworkAddress;
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.CancellableThreads;
 import org.opensearch.common.util.PageCacheRecycler;
diff --git a/server/src/test/java/org/opensearch/discovery/SettingsBasedSeedHostsProviderTests.java b/server/src/test/java/org/opensearch/discovery/SettingsBasedSeedHostsProviderTests.java
index 4648c98bec5df..5801ad0d08818 100644
--- a/server/src/test/java/org/opensearch/discovery/SettingsBasedSeedHostsProviderTests.java
+++ b/server/src/test/java/org/opensearch/discovery/SettingsBasedSeedHostsProviderTests.java
@@ -32,7 +32,7 @@
 package org.opensearch.discovery;
 
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.set.Sets;
 import org.opensearch.discovery.SeedHostsProvider.HostsResolver;
 import org.opensearch.test.OpenSearchTestCase;
diff --git a/server/src/test/java/org/opensearch/extensions/DiscoveryExtensionNodeTests.java b/server/src/test/java/org/opensearch/extensions/DiscoveryExtensionNodeTests.java
index 578e7503b76a9..8146062c15b73 100644
--- a/server/src/test/java/org/opensearch/extensions/DiscoveryExtensionNodeTests.java
+++ b/server/src/test/java/org/opensearch/extensions/DiscoveryExtensionNodeTests.java
@@ -10,7 +10,7 @@
 
 import org.opensearch.OpenSearchException;
 import org.opensearch.Version;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.net.InetAddress;
diff --git a/server/src/test/java/org/opensearch/extensions/ExtensionsManagerTests.java b/server/src/test/java/org/opensearch/extensions/ExtensionsManagerTests.java
index 9f1050351c7b5..840605b61c500 100644
--- a/server/src/test/java/org/opensearch/extensions/ExtensionsManagerTests.java
+++ b/server/src/test/java/org/opensearch/extensions/ExtensionsManagerTests.java
@@ -55,7 +55,7 @@
 import org.opensearch.common.settings.Setting.Property;
 import org.opensearch.common.settings.WriteableSetting.SettingType;
 import org.opensearch.common.settings.SettingsModule;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.core.common.bytes.BytesReference;
 import org.opensearch.core.common.io.stream.BytesStreamInput;
@@ -77,7 +77,7 @@
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.Transport;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 import org.opensearch.transport.nio.MockNioTransport;
 import org.opensearch.usage.UsageService;
diff --git a/server/src/test/java/org/opensearch/extensions/action/ExtensionTransportActionsHandlerTests.java b/server/src/test/java/org/opensearch/extensions/action/ExtensionTransportActionsHandlerTests.java
index bc216bd3bbbb8..fb5a6e374b9a3 100644
--- a/server/src/test/java/org/opensearch/extensions/action/ExtensionTransportActionsHandlerTests.java
+++ b/server/src/test/java/org/opensearch/extensions/action/ExtensionTransportActionsHandlerTests.java
@@ -20,7 +20,7 @@
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.extensions.DiscoveryExtensionNode;
 import org.opensearch.extensions.AcknowledgedResponse;
diff --git a/server/src/test/java/org/opensearch/extensions/rest/RestSendToExtensionActionTests.java b/server/src/test/java/org/opensearch/extensions/rest/RestSendToExtensionActionTests.java
index b59513fc0045d..f0cdbd6c96d41 100644
--- a/server/src/test/java/org/opensearch/extensions/rest/RestSendToExtensionActionTests.java
+++ b/server/src/test/java/org/opensearch/extensions/rest/RestSendToExtensionActionTests.java
@@ -38,7 +38,7 @@
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.settings.SettingsModule;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.extensions.DiscoveryExtensionNode;
diff --git a/server/src/test/java/org/opensearch/gateway/GatewayServiceTests.java b/server/src/test/java/org/opensearch/gateway/GatewayServiceTests.java
index 2d8a26f8bbe87..b8607c0aa89ab 100644
--- a/server/src/test/java/org/opensearch/gateway/GatewayServiceTests.java
+++ b/server/src/test/java/org/opensearch/gateway/GatewayServiceTests.java
@@ -50,7 +50,7 @@
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.snapshots.EmptySnapshotsInfoService;
 import org.opensearch.test.OpenSearchTestCase;
diff --git a/server/src/test/java/org/opensearch/http/AbstractHttpServerTransportTests.java b/server/src/test/java/org/opensearch/http/AbstractHttpServerTransportTests.java
index fbf0e8cd42c72..5ea003b323fd6 100644
--- a/server/src/test/java/org/opensearch/http/AbstractHttpServerTransportTests.java
+++ b/server/src/test/java/org/opensearch/http/AbstractHttpServerTransportTests.java
@@ -41,7 +41,7 @@
 import org.opensearch.common.network.NetworkUtils;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.MockBigArrays;
 import org.opensearch.common.util.MockPageCacheRecycler;
 import org.opensearch.common.util.concurrent.ThreadContext;
diff --git a/server/src/test/java/org/opensearch/http/HttpInfoTests.java b/server/src/test/java/org/opensearch/http/HttpInfoTests.java
index d03ae9a2a1ccb..030e7cc89ab76 100644
--- a/server/src/test/java/org/opensearch/http/HttpInfoTests.java
+++ b/server/src/test/java/org/opensearch/http/HttpInfoTests.java
@@ -36,8 +36,8 @@
 import java.net.InetAddress;
 import java.util.Map;
 import org.opensearch.common.network.NetworkAddress;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.common.xcontent.XContentFactory;
diff --git a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationSourceServiceTests.java b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationSourceServiceTests.java
index d56a02b7fd71f..1d9acb9f39de1 100644
--- a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationSourceServiceTests.java
+++ b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationSourceServiceTests.java
@@ -34,7 +34,7 @@
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportException;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
diff --git a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetServiceTests.java b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetServiceTests.java
index 94e57f4a0d3e4..efb8dda201e87 100644
--- a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetServiceTests.java
+++ b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetServiceTests.java
@@ -41,7 +41,7 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.EmptyTransportResponseHandler;
 import org.opensearch.transport.TransportRequestOptions;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 import org.opensearch.test.transport.CapturingTransport;
 import java.io.IOException;
diff --git a/server/src/test/java/org/opensearch/node/NodeTests.java b/server/src/test/java/org/opensearch/node/NodeTests.java
index 6dfecd8a692f1..816dc47c96f8a 100644
--- a/server/src/test/java/org/opensearch/node/NodeTests.java
+++ b/server/src/test/java/org/opensearch/node/NodeTests.java
@@ -41,7 +41,7 @@
 import org.opensearch.common.network.NetworkModule;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.settings.SettingsException;
-import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
 import org.opensearch.core.common.unit.ByteSizeUnit;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.env.Environment;
diff --git a/server/src/test/java/org/opensearch/node/ResponseCollectorServiceTests.java b/server/src/test/java/org/opensearch/node/ResponseCollectorServiceTests.java
index 2b13df3027cfa..7ca1f1e864b99 100644
--- a/server/src/test/java/org/opensearch/node/ResponseCollectorServiceTests.java
+++ b/server/src/test/java/org/opensearch/node/ResponseCollectorServiceTests.java
@@ -40,7 +40,7 @@
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
diff --git a/server/src/test/java/org/opensearch/nodesinfo/NodeInfoStreamingTests.java b/server/src/test/java/org/opensearch/nodesinfo/NodeInfoStreamingTests.java
index 347fef773fc8a..31df1b3ab80b3 100644
--- a/server/src/test/java/org/opensearch/nodesinfo/NodeInfoStreamingTests.java
+++ b/server/src/test/java/org/opensearch/nodesinfo/NodeInfoStreamingTests.java
@@ -40,8 +40,8 @@
 import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
diff --git a/server/src/test/java/org/opensearch/rest/BytesRestResponseTests.java b/server/src/test/java/org/opensearch/rest/BytesRestResponseTests.java
index 5bdc2cc0bd280..9e851cef62655 100644
--- a/server/src/test/java/org/opensearch/rest/BytesRestResponseTests.java
+++ b/server/src/test/java/org/opensearch/rest/BytesRestResponseTests.java
@@ -42,7 +42,7 @@
 import org.opensearch.action.search.ShardSearchFailure;
 import org.opensearch.core.common.ParsingException;
 import org.opensearch.core.common.bytes.BytesReference;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.rest.RestStatus;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
diff --git a/server/src/test/java/org/opensearch/rest/RestControllerTests.java b/server/src/test/java/org/opensearch/rest/RestControllerTests.java
index ea0ce54913a8d..b4fa7574f0ff0 100644
--- a/server/src/test/java/org/opensearch/rest/RestControllerTests.java
+++ b/server/src/test/java/org/opensearch/rest/RestControllerTests.java
@@ -39,8 +39,8 @@
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.core.rest.RestStatus;
diff --git a/server/src/test/java/org/opensearch/rest/action/RestBuilderListenerTests.java b/server/src/test/java/org/opensearch/rest/action/RestBuilderListenerTests.java
index d865607aa5451..662ba202c8c5c 100644
--- a/server/src/test/java/org/opensearch/rest/action/RestBuilderListenerTests.java
+++ b/server/src/test/java/org/opensearch/rest/action/RestBuilderListenerTests.java
@@ -40,8 +40,8 @@
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.rest.FakeRestChannel;
 import org.opensearch.test.rest.FakeRestRequest;
-import org.opensearch.transport.TransportResponse;
-import org.opensearch.transport.TransportResponse.Empty;
+import org.opensearch.core.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse.Empty;
 
 import java.util.concurrent.atomic.AtomicReference;
 
diff --git a/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java b/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java
index 32e0edf7c8f11..92781cf160afc 100644
--- a/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java
+++ b/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java
@@ -158,7 +158,7 @@
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.IndexScopedSettings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.BigArrays;
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
diff --git a/server/src/test/java/org/opensearch/transport/ClusterConnectionManagerTests.java b/server/src/test/java/org/opensearch/transport/ClusterConnectionManagerTests.java
index bf47fc2cc9b45..e3d3e17c41fcb 100644
--- a/server/src/test/java/org/opensearch/transport/ClusterConnectionManagerTests.java
+++ b/server/src/test/java/org/opensearch/transport/ClusterConnectionManagerTests.java
@@ -37,7 +37,7 @@
 import org.opensearch.action.support.PlainActionFuture;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.ThreadPool;
diff --git a/server/src/test/java/org/opensearch/transport/InboundDecoderTests.java b/server/src/test/java/org/opensearch/transport/InboundDecoderTests.java
index 4d8955650f8be..009dc829e8168 100644
--- a/server/src/test/java/org/opensearch/transport/InboundDecoderTests.java
+++ b/server/src/test/java/org/opensearch/transport/InboundDecoderTests.java
@@ -39,6 +39,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.core.transport.TransportMessage;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.VersionUtils;
 
diff --git a/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java b/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
index 46b3c43104e99..a46e00e975af4 100644
--- a/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
+++ b/server/src/test/java/org/opensearch/transport/OutboundHandlerTests.java
@@ -43,12 +43,13 @@
 import org.opensearch.common.bytes.ReleasableBytesReference;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.io.stream.BytesStreamOutput;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.BigArrays;
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.common.util.io.Streams;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
diff --git a/server/src/test/java/org/opensearch/transport/ProxyConnectionStrategyTests.java b/server/src/test/java/org/opensearch/transport/ProxyConnectionStrategyTests.java
index 1451e9466778b..510a2b3abd943 100644
--- a/server/src/test/java/org/opensearch/transport/ProxyConnectionStrategyTests.java
+++ b/server/src/test/java/org/opensearch/transport/ProxyConnectionStrategyTests.java
@@ -41,7 +41,7 @@
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.transport.MockTransportService;
 import org.opensearch.threadpool.TestThreadPool;
diff --git a/server/src/test/java/org/opensearch/transport/RemoteClusterConnectionTests.java b/server/src/test/java/org/opensearch/transport/RemoteClusterConnectionTests.java
index 4106ebd9988c9..92f5f455f7caa 100644
--- a/server/src/test/java/org/opensearch/transport/RemoteClusterConnectionTests.java
+++ b/server/src/test/java/org/opensearch/transport/RemoteClusterConnectionTests.java
@@ -56,7 +56,7 @@
 import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.common.xcontent.XContentFactory;
diff --git a/server/src/test/java/org/opensearch/transport/RemoteConnectionManagerTests.java b/server/src/test/java/org/opensearch/transport/RemoteConnectionManagerTests.java
index ccba66ff4c45e..5741024850756 100644
--- a/server/src/test/java/org/opensearch/transport/RemoteConnectionManagerTests.java
+++ b/server/src/test/java/org/opensearch/transport/RemoteConnectionManagerTests.java
@@ -36,7 +36,7 @@
 import org.opensearch.action.support.PlainActionFuture;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.net.InetAddress;
diff --git a/server/src/test/java/org/opensearch/transport/SniffConnectionStrategyTests.java b/server/src/test/java/org/opensearch/transport/SniffConnectionStrategyTests.java
index 975da2de82ae6..a91b114b5ee84 100644
--- a/server/src/test/java/org/opensearch/transport/SniffConnectionStrategyTests.java
+++ b/server/src/test/java/org/opensearch/transport/SniffConnectionStrategyTests.java
@@ -47,7 +47,7 @@
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.common.Strings;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.VersionUtils;
diff --git a/server/src/test/java/org/opensearch/transport/TcpTransportTests.java b/server/src/test/java/org/opensearch/transport/TcpTransportTests.java
index 39bc2d9bd2d48..ba216b31a1f1d 100644
--- a/server/src/test/java/org/opensearch/transport/TcpTransportTests.java
+++ b/server/src/test/java/org/opensearch/transport/TcpTransportTests.java
@@ -43,7 +43,7 @@
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.network.NetworkUtils;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.BigArrays;
 import org.opensearch.common.util.MockPageCacheRecycler;
 import org.opensearch.core.indices.breaker.NoneCircuitBreakerService;
diff --git a/server/src/test/java/org/opensearch/transport/TransportActionProxyTests.java b/server/src/test/java/org/opensearch/transport/TransportActionProxyTests.java
index 40280696af870..234048110cf9a 100644
--- a/server/src/test/java/org/opensearch/transport/TransportActionProxyTests.java
+++ b/server/src/test/java/org/opensearch/transport/TransportActionProxyTests.java
@@ -39,6 +39,7 @@
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.transport.MockTransportService;
 import org.opensearch.threadpool.TestThreadPool;
diff --git a/server/src/test/java/org/opensearch/transport/TransportHandshakerTests.java b/server/src/test/java/org/opensearch/transport/TransportHandshakerTests.java
index 58c8806380436..6bbe926ea0384 100644
--- a/server/src/test/java/org/opensearch/transport/TransportHandshakerTests.java
+++ b/server/src/test/java/org/opensearch/transport/TransportHandshakerTests.java
@@ -37,6 +37,7 @@
 import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.tasks.TaskId;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
diff --git a/server/src/test/java/org/opensearch/transport/TransportInfoTests.java b/server/src/test/java/org/opensearch/transport/TransportInfoTests.java
index 402c4183fa2b8..8360346ce3c42 100644
--- a/server/src/test/java/org/opensearch/transport/TransportInfoTests.java
+++ b/server/src/test/java/org/opensearch/transport/TransportInfoTests.java
@@ -33,8 +33,8 @@
 package org.opensearch.transport;
 
 import org.opensearch.common.network.NetworkAddress;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.common.xcontent.XContentFactory;
diff --git a/server/src/test/java/org/opensearch/transport/TransportServiceDeserializationFailureTests.java b/server/src/test/java/org/opensearch/transport/TransportServiceDeserializationFailureTests.java
index 7a01bc0276114..13c7560b270e8 100644
--- a/server/src/test/java/org/opensearch/transport/TransportServiceDeserializationFailureTests.java
+++ b/server/src/test/java/org/opensearch/transport/TransportServiceDeserializationFailureTests.java
@@ -39,6 +39,7 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.tasks.Task;
 import org.opensearch.tasks.TaskAwareRequest;
 import org.opensearch.tasks.TaskId;
diff --git a/test/framework/src/main/java/org/opensearch/cluster/coordination/AbstractCoordinatorTestCase.java b/test/framework/src/main/java/org/opensearch/cluster/coordination/AbstractCoordinatorTestCase.java
index 72fabc001760f..0d1d30014a9ac 100644
--- a/test/framework/src/main/java/org/opensearch/cluster/coordination/AbstractCoordinatorTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/cluster/coordination/AbstractCoordinatorTestCase.java
@@ -66,7 +66,7 @@
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.BigArrays;
 import org.opensearch.common.util.MockBigArrays;
diff --git a/test/framework/src/main/java/org/opensearch/node/MockNode.java b/test/framework/src/main/java/org/opensearch/node/MockNode.java
index 7d3a88fb1aba2..59c78d32c4c3c 100644
--- a/test/framework/src/main/java/org/opensearch/node/MockNode.java
+++ b/test/framework/src/main/java/org/opensearch/node/MockNode.java
@@ -41,7 +41,7 @@
 import org.opensearch.common.network.NetworkModule;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
 import org.opensearch.common.util.BigArrays;
 import org.opensearch.common.util.MockBigArrays;
 import org.opensearch.common.util.MockPageCacheRecycler;
diff --git a/test/framework/src/main/java/org/opensearch/test/ExternalTestCluster.java b/test/framework/src/main/java/org/opensearch/test/ExternalTestCluster.java
index 1869fc8c9b447..943a99c02a00b 100644
--- a/test/framework/src/main/java/org/opensearch/test/ExternalTestCluster.java
+++ b/test/framework/src/main/java/org/opensearch/test/ExternalTestCluster.java
@@ -45,7 +45,7 @@
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.common.network.NetworkModule;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.env.Environment;
 import org.opensearch.http.HttpInfo;
 import org.opensearch.node.MockNode;
diff --git a/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java b/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java
index e156449adc184..841cf62620f0d 100644
--- a/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/MockHttpTransport.java
@@ -33,8 +33,8 @@
 package org.opensearch.test;
 
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.http.HttpInfo;
 import org.opensearch.http.HttpServerTransport;
 import org.opensearch.http.HttpStats;
diff --git a/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java b/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java
index 5e79bec91bd90..45d69703456fc 100644
--- a/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java
@@ -106,7 +106,7 @@
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Setting.Property;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.common.unit.ByteSizeUnit;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.common.unit.TimeValue;
diff --git a/test/framework/src/main/java/org/opensearch/test/OpenSearchTestCase.java b/test/framework/src/main/java/org/opensearch/test/OpenSearchTestCase.java
index 14275d838e6a9..7b787e12be64a 100644
--- a/test/framework/src/main/java/org/opensearch/test/OpenSearchTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/test/OpenSearchTestCase.java
@@ -89,7 +89,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.time.DateUtils;
 import org.opensearch.common.time.FormatNames;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.MockBigArrays;
 import org.opensearch.common.util.MockPageCacheRecycler;
 import org.opensearch.common.util.concurrent.ThreadContext;
diff --git a/test/framework/src/main/java/org/opensearch/test/disruption/DisruptableMockTransport.java b/test/framework/src/main/java/org/opensearch/test/disruption/DisruptableMockTransport.java
index dd025555d1ae8..1cd60690ca9d5 100644
--- a/test/framework/src/main/java/org/opensearch/test/disruption/DisruptableMockTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/disruption/DisruptableMockTransport.java
@@ -39,8 +39,8 @@
 import org.opensearch.common.Nullable;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.test.transport.MockTransport;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.CloseableConnection;
@@ -52,7 +52,7 @@
 import org.opensearch.transport.TransportInterceptor;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestOptions;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
diff --git a/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java b/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
index 9c15a6e0ab572..c5c002cb8b85e 100644
--- a/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/transport/FakeTransport.java
@@ -35,8 +35,8 @@
 import org.opensearch.action.ActionListener;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.transport.CloseableConnection;
 import org.opensearch.transport.ConnectionProfile;
 import org.opensearch.transport.TransportRequest;
diff --git a/test/framework/src/main/java/org/opensearch/test/transport/MockTransport.java b/test/framework/src/main/java/org/opensearch/test/transport/MockTransport.java
index 36f3e6cb4b692..0974a5f1f5671 100644
--- a/test/framework/src/main/java/org/opensearch/test/transport/MockTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/transport/MockTransport.java
@@ -43,7 +43,7 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.CloseableConnection;
 import org.opensearch.transport.ClusterConnectionManager;
@@ -54,7 +54,7 @@
 import org.opensearch.transport.TransportMessageListener;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestOptions;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
diff --git a/test/framework/src/main/java/org/opensearch/test/transport/MockTransportService.java b/test/framework/src/main/java/org/opensearch/test/transport/MockTransportService.java
index 7a1d730ac1b27..5cf451980ec98 100644
--- a/test/framework/src/main/java/org/opensearch/test/transport/MockTransportService.java
+++ b/test/framework/src/main/java/org/opensearch/test/transport/MockTransportService.java
@@ -46,8 +46,8 @@
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.MockPageCacheRecycler;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
diff --git a/test/framework/src/main/java/org/opensearch/test/transport/StubbableConnectionManager.java b/test/framework/src/main/java/org/opensearch/test/transport/StubbableConnectionManager.java
index 53cae12871d92..47de32acde351 100644
--- a/test/framework/src/main/java/org/opensearch/test/transport/StubbableConnectionManager.java
+++ b/test/framework/src/main/java/org/opensearch/test/transport/StubbableConnectionManager.java
@@ -33,7 +33,7 @@
 
 import org.opensearch.action.ActionListener;
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.transport.ConnectTransportException;
 import org.opensearch.transport.ConnectionProfile;
 import org.opensearch.transport.ConnectionManager;
diff --git a/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java b/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
index b4675c9fcebf2..c270452c35b57 100644
--- a/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
+++ b/test/framework/src/main/java/org/opensearch/test/transport/StubbableTransport.java
@@ -37,8 +37,8 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.lifecycle.Lifecycle;
 import org.opensearch.common.lifecycle.LifecycleListener;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.tasks.Task;
 import org.opensearch.transport.ConnectionProfile;
 import org.opensearch.transport.TransportRequest;
diff --git a/test/framework/src/main/java/org/opensearch/transport/AbstractSimpleTransportTestCase.java b/test/framework/src/main/java/org/opensearch/transport/AbstractSimpleTransportTestCase.java
index 5fc4633448caa..7a42a0e91caf2 100644
--- a/test/framework/src/main/java/org/opensearch/transport/AbstractSimpleTransportTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/transport/AbstractSimpleTransportTestCase.java
@@ -58,12 +58,13 @@
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.BoundTransportAddress;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.BoundTransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
 import org.opensearch.common.util.concurrent.ConcurrentCollections;
 import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.node.Node;
 import org.opensearch.tasks.Task;
 import org.opensearch.test.OpenSearchTestCase;
diff --git a/test/framework/src/main/java/org/opensearch/transport/TestResponse.java b/test/framework/src/main/java/org/opensearch/transport/TestResponse.java
index 09dd50d656004..14db8b3372bf2 100644
--- a/test/framework/src/main/java/org/opensearch/transport/TestResponse.java
+++ b/test/framework/src/main/java/org/opensearch/transport/TestResponse.java
@@ -33,6 +33,7 @@
 
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 
diff --git a/test/framework/src/main/java/org/opensearch/transport/TestTransportChannel.java b/test/framework/src/main/java/org/opensearch/transport/TestTransportChannel.java
index 819094c9fb089..64bb01afe3430 100644
--- a/test/framework/src/main/java/org/opensearch/transport/TestTransportChannel.java
+++ b/test/framework/src/main/java/org/opensearch/transport/TestTransportChannel.java
@@ -33,6 +33,7 @@
 package org.opensearch.transport;
 
 import org.opensearch.action.ActionListener;
+import org.opensearch.core.transport.TransportResponse;
 
 public class TestTransportChannel implements TransportChannel {
 
diff --git a/test/framework/src/test/java/org/opensearch/test/disruption/DisruptableMockTransportTests.java b/test/framework/src/test/java/org/opensearch/test/disruption/DisruptableMockTransportTests.java
index 0ea90005cf7cf..8eaaedd43efa2 100644
--- a/test/framework/src/test/java/org/opensearch/test/disruption/DisruptableMockTransportTests.java
+++ b/test/framework/src/test/java/org/opensearch/test/disruption/DisruptableMockTransportTests.java
@@ -39,7 +39,7 @@
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.node.Node;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.disruption.DisruptableMockTransport.ConnectionStatus;
@@ -49,8 +49,8 @@
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.TransportRequestHandler;
-import org.opensearch.transport.TransportResponse;
-import org.opensearch.transport.TransportResponse.Empty;
+import org.opensearch.core.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse.Empty;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
diff --git a/test/framework/src/test/java/org/opensearch/test/disruption/NetworkDisruptionIT.java b/test/framework/src/test/java/org/opensearch/test/disruption/NetworkDisruptionIT.java
index 91b235706fc9c..0959c716e79f7 100644
--- a/test/framework/src/test/java/org/opensearch/test/disruption/NetworkDisruptionIT.java
+++ b/test/framework/src/test/java/org/opensearch/test/disruption/NetworkDisruptionIT.java
@@ -46,7 +46,7 @@
 import org.opensearch.test.transport.MockTransportService;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportException;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportService;
 
diff --git a/test/framework/src/test/java/org/opensearch/transport/nio/SimpleMockNioTransportTests.java b/test/framework/src/test/java/org/opensearch/transport/nio/SimpleMockNioTransportTests.java
index 868affc81be37..158a770987207 100644
--- a/test/framework/src/test/java/org/opensearch/transport/nio/SimpleMockNioTransportTests.java
+++ b/test/framework/src/test/java/org/opensearch/transport/nio/SimpleMockNioTransportTests.java
@@ -39,7 +39,7 @@
 import org.opensearch.common.network.NetworkService;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.transport.TransportAddress;
+import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.common.util.MockPageCacheRecycler;
 import org.opensearch.core.indices.breaker.NoneCircuitBreakerService;
 import org.opensearch.transport.AbstractSimpleTransportTestCase;

From d73fd6a1123f8b51c94db647a42cd4c39423e22c Mon Sep 17 00:00:00 2001
From: Harish Bhakuni <harishbhakuni21@gmail.com>
Date: Thu, 3 Aug 2023 00:36:45 -0700
Subject: [PATCH 33/37] [Snapshot Interop] Add Logic in Lock Manager to cleanup
 stale data post index deletion. (#8472)

Signed-off-by: Harish Bhakuni <hbhakuni@amazon.com>
---
 .../RemoteStoreBaseIntegTestCase.java         |  2 +-
 .../snapshots/DeleteSnapshotIT.java           | 76 ++++++++++++++++++-
 .../store/RemoteSegmentStoreDirectory.java    | 16 ++--
 .../RemoteSegmentStoreDirectoryFactory.java   |  4 +-
 .../RemoteStoreLockManagerFactory.java        |  8 +-
 .../blobstore/BlobStoreRepository.java        | 43 +++++++++--
 .../blobstore/BlobStoreRepositoryTests.java   |  2 -
 .../AbstractSnapshotIntegTestCase.java        |  5 ++
 8 files changed, 138 insertions(+), 18 deletions(-)

diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreBaseIntegTestCase.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreBaseIntegTestCase.java
index 4a85ff46d9025..ec58c29175e16 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreBaseIntegTestCase.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreBaseIntegTestCase.java
@@ -159,7 +159,7 @@ public void teardown() {
         assertAcked(clusterAdmin().prepareDeleteRepository(REPOSITORY_2_NAME));
     }
 
-    public int getFileCount(Path path) throws Exception {
+    public static int getFileCount(Path path) throws Exception {
         final AtomicInteger filesExisting = new AtomicInteger(0);
         Files.walkFileTree(path, new SimpleFileVisitor<>() {
             @Override
diff --git a/server/src/internalClusterTest/java/org/opensearch/snapshots/DeleteSnapshotIT.java b/server/src/internalClusterTest/java/org/opensearch/snapshots/DeleteSnapshotIT.java
index b12fbdd2a9bd7..d38620723a8f4 100644
--- a/server/src/internalClusterTest/java/org/opensearch/snapshots/DeleteSnapshotIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/snapshots/DeleteSnapshotIT.java
@@ -10,22 +10,28 @@
 
 import org.opensearch.action.ActionFuture;
 import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotResponse;
+import org.opensearch.action.support.master.AcknowledgedResponse;
 import org.opensearch.client.Client;
+import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.remotestore.RemoteStoreBaseIntegTestCase;
 import org.opensearch.test.FeatureFlagSetter;
 import org.opensearch.test.OpenSearchIntegTestCase;
 
 import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Locale;
+import java.util.concurrent.TimeUnit;
 import java.util.stream.Stream;
 
 import static org.hamcrest.Matchers.is;
 import static org.opensearch.remotestore.RemoteStoreBaseIntegTestCase.remoteStoreClusterSettings;
+import static org.hamcrest.Matchers.comparesEqualTo;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 
 @OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
@@ -240,12 +246,13 @@ public void testDeleteMultipleShallowCopySnapshotsCase3() throws Exception {
         final String snapshotRepoName = "snapshot-repo-name";
         final Path snapshotRepoPath = randomRepoPath();
         createRepository(snapshotRepoName, "mock", snapshotRepoSettingsForShallowCopy(snapshotRepoPath));
-        final String testIndex = "index-test";
-        createIndexWithContent(testIndex);
 
         final Path remoteStoreRepoPath = randomRepoPath();
         createRepository(REMOTE_REPO_NAME, "fs", remoteStoreRepoPath);
 
+        final String testIndex = "index-test";
+        createIndexWithContent(testIndex);
+
         final String remoteStoreEnabledIndexName = "remote-index-1";
         final Settings remoteStoreEnabledIndexSettings = getRemoteStoreBackedIndexSettings();
         createIndex(remoteStoreEnabledIndexName, remoteStoreEnabledIndexSettings);
@@ -289,6 +296,71 @@ public void testDeleteMultipleShallowCopySnapshotsCase3() throws Exception {
         assert (getLockFilesInRemoteStore(remoteStoreEnabledIndexName, REMOTE_REPO_NAME).length == 0);
     }
 
+    public void testRemoteStoreCleanupForDeletedIndex() throws Exception {
+        disableRepoConsistencyCheck("Remote store repository is being used in the test");
+        FeatureFlagSetter.set(FeatureFlags.REMOTE_STORE);
+
+        internalCluster().startClusterManagerOnlyNode(remoteStoreClusterSettings(REMOTE_REPO_NAME));
+        internalCluster().startDataOnlyNode();
+        final Client clusterManagerClient = internalCluster().clusterManagerClient();
+        ensureStableCluster(2);
+
+        final String snapshotRepoName = "snapshot-repo-name";
+        final Path snapshotRepoPath = randomRepoPath();
+        createRepository(snapshotRepoName, "mock", snapshotRepoSettingsForShallowCopy(snapshotRepoPath));
+
+        final Path remoteStoreRepoPath = randomRepoPath();
+        createRepository(REMOTE_REPO_NAME, "fs", remoteStoreRepoPath);
+
+        final String testIndex = "index-test";
+        createIndexWithContent(testIndex);
+
+        final String remoteStoreEnabledIndexName = "remote-index-1";
+        final Settings remoteStoreEnabledIndexSettings = getRemoteStoreBackedIndexSettings();
+        createIndex(remoteStoreEnabledIndexName, remoteStoreEnabledIndexSettings);
+        indexRandomDocs(remoteStoreEnabledIndexName, randomIntBetween(5, 10));
+
+        String indexUUID = client().admin()
+            .indices()
+            .prepareGetSettings(remoteStoreEnabledIndexName)
+            .get()
+            .getSetting(remoteStoreEnabledIndexName, IndexMetadata.SETTING_INDEX_UUID);
+
+        logger.info("--> create two remote index shallow snapshots");
+        List<String> shallowCopySnapshots = createNSnapshots(snapshotRepoName, 2);
+
+        String[] lockFiles = getLockFilesInRemoteStore(remoteStoreEnabledIndexName, REMOTE_REPO_NAME);
+        assert (lockFiles.length == 2) : "lock files are " + Arrays.toString(lockFiles);
+
+        // delete remote store index
+        assertAcked(client().admin().indices().prepareDelete(remoteStoreEnabledIndexName));
+
+        logger.info("--> delete snapshot 1");
+        AcknowledgedResponse deleteSnapshotResponse = clusterManagerClient.admin()
+            .cluster()
+            .prepareDeleteSnapshot(snapshotRepoName, shallowCopySnapshots.get(0))
+            .get();
+        assertAcked(deleteSnapshotResponse);
+
+        lockFiles = getLockFilesInRemoteStore(remoteStoreEnabledIndexName, REMOTE_REPO_NAME, indexUUID);
+        assert (lockFiles.length == 1) : "lock files are " + Arrays.toString(lockFiles);
+
+        logger.info("--> delete snapshot 2");
+        deleteSnapshotResponse = clusterManagerClient.admin()
+            .cluster()
+            .prepareDeleteSnapshot(snapshotRepoName, shallowCopySnapshots.get(1))
+            .get();
+        assertAcked(deleteSnapshotResponse);
+
+        Path indexPath = Path.of(String.valueOf(remoteStoreRepoPath), indexUUID);
+        // Delete is async. Give time for it
+        assertBusy(() -> {
+            try {
+                assertThat(RemoteStoreBaseIntegTestCase.getFileCount(indexPath), comparesEqualTo(0));
+            } catch (Exception e) {}
+        }, 30, TimeUnit.SECONDS);
+    }
+
     private List<String> createNSnapshots(String repoName, int count) {
         final List<String> snapshotNames = new ArrayList<>(count);
         final String prefix = "snap-" + UUIDs.randomBase64UUID(random()).toLowerCase(Locale.ROOT) + "-";
diff --git a/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectory.java b/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectory.java
index 8dfdb3e2c8e06..9ac5ebb94a5ca 100644
--- a/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectory.java
+++ b/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectory.java
@@ -837,29 +837,36 @@ public void deleteStaleSegments(int lastNMetadataFilesToKeep) throws IOException
         }
     }
 
+    public void deleteStaleSegmentsAsync(int lastNMetadataFilesToKeep) {
+        deleteStaleSegmentsAsync(lastNMetadataFilesToKeep, ActionListener.wrap(r -> {}, e -> {}));
+    }
+
     /**
      * Delete stale segment and metadata files asynchronously.
      * This method calls {@link RemoteSegmentStoreDirectory#deleteStaleSegments(int)} in an async manner.
      * @param lastNMetadataFilesToKeep number of metadata files to keep
      */
-    public void deleteStaleSegmentsAsync(int lastNMetadataFilesToKeep) {
+    public void deleteStaleSegmentsAsync(int lastNMetadataFilesToKeep, ActionListener<Void> listener) {
         if (canDeleteStaleCommits.compareAndSet(true, false)) {
             try {
                 threadPool.executor(ThreadPool.Names.REMOTE_PURGE).execute(() -> {
                     try {
                         deleteStaleSegments(lastNMetadataFilesToKeep);
+                        listener.onResponse(null);
                     } catch (Exception e) {
-                        logger.info(
+                        logger.error(
                             "Exception while deleting stale commits from remote segment store, will retry delete post next commit",
                             e
                         );
+                        listener.onFailure(e);
                     } finally {
                         canDeleteStaleCommits.set(true);
                     }
                 });
             } catch (Exception e) {
-                logger.info("Exception occurred while scheduling deleteStaleCommits", e);
+                logger.error("Exception occurred while scheduling deleteStaleCommits", e);
                 canDeleteStaleCommits.set(true);
+                listener.onFailure(e);
             }
         }
     }
@@ -891,7 +898,6 @@ private boolean deleteIfEmpty() throws IOException {
     }
 
     public void close() throws IOException {
-        deleteStaleSegmentsAsync(0);
-        deleteIfEmpty();
+        deleteStaleSegmentsAsync(0, ActionListener.wrap(r -> deleteIfEmpty(), e -> logger.error("Failed to cleanup remote directory")));
     }
 }
diff --git a/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryFactory.java b/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryFactory.java
index 3bec84f287ce4..3de7a706c0688 100644
--- a/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryFactory.java
+++ b/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryFactory.java
@@ -13,8 +13,8 @@
 import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.shard.ShardPath;
+import org.opensearch.index.store.lockmanager.RemoteStoreLockManager;
 import org.opensearch.index.store.lockmanager.RemoteStoreLockManagerFactory;
-import org.opensearch.index.store.lockmanager.RemoteStoreMetadataLockManager;
 import org.opensearch.plugins.IndexStorePlugin;
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.Repository;
@@ -59,7 +59,7 @@ public Directory newDirectory(String repositoryName, String indexUUID, String sh
 
             RemoteDirectory dataDirectory = createRemoteDirectory(repository, commonBlobPath, "data");
             RemoteDirectory metadataDirectory = createRemoteDirectory(repository, commonBlobPath, "metadata");
-            RemoteStoreMetadataLockManager mdLockManager = RemoteStoreLockManagerFactory.newLockManager(
+            RemoteStoreLockManager mdLockManager = RemoteStoreLockManagerFactory.newLockManager(
                 repositoriesService.get(),
                 repositoryName,
                 indexUUID,
diff --git a/server/src/main/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactory.java b/server/src/main/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactory.java
index e866551eae143..1a306f3261094 100644
--- a/server/src/main/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactory.java
+++ b/server/src/main/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactory.java
@@ -33,7 +33,7 @@ public RemoteStoreLockManagerFactory(Supplier<RepositoriesService> repositoriesS
         this.repositoriesService = repositoriesService;
     }
 
-    public RemoteStoreMetadataLockManager newLockManager(String repositoryName, String indexUUID, String shardId) throws IOException {
+    public RemoteStoreLockManager newLockManager(String repositoryName, String indexUUID, String shardId) throws IOException {
         return newLockManager(repositoriesService.get(), repositoryName, indexUUID, shardId);
     }
 
@@ -58,6 +58,12 @@ public static RemoteStoreMetadataLockManager newLockManager(
         }
     }
 
+    // TODO: remove this once we add poller in place to trigger remote store cleanup
+    // see: https://github.com/opensearch-project/OpenSearch/issues/8469
+    public Supplier<RepositoriesService> getRepositoriesService() {
+        return repositoriesService;
+    }
+
     private static RemoteBufferedOutputDirectory createRemoteBufferedOutputDirectory(
         Repository repository,
         BlobPath commonBlobPath,
diff --git a/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java b/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java
index 70db2e0c0a9bd..f24c255f0d0da 100644
--- a/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java
+++ b/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java
@@ -113,11 +113,12 @@
 import org.opensearch.index.snapshots.blobstore.RateLimitingInputStream;
 import org.opensearch.index.snapshots.blobstore.SlicedInputStream;
 import org.opensearch.index.snapshots.blobstore.SnapshotFiles;
+import org.opensearch.index.store.RemoteSegmentStoreDirectoryFactory;
 import org.opensearch.index.store.Store;
 import org.opensearch.index.store.StoreFileMetadata;
 import org.opensearch.index.store.lockmanager.FileLockInfo;
+import org.opensearch.index.store.lockmanager.RemoteStoreLockManager;
 import org.opensearch.index.store.lockmanager.RemoteStoreLockManagerFactory;
-import org.opensearch.index.store.lockmanager.RemoteStoreMetadataLockManager;
 import org.opensearch.indices.recovery.RecoverySettings;
 import org.opensearch.indices.recovery.RecoveryState;
 import org.opensearch.repositories.IndexId;
@@ -616,7 +617,7 @@ public void cloneRemoteStoreIndexShardSnapshot(
             RemoteStoreShardShallowCopySnapshot remStoreBasedShardMetadata = (RemoteStoreShardShallowCopySnapshot) indexShardSnapshot;
             String indexUUID = remStoreBasedShardMetadata.getIndexUUID();
             String remoteStoreRepository = remStoreBasedShardMetadata.getRemoteStoreRepository();
-            RemoteStoreMetadataLockManager remoteStoreMetadataLockManger = remoteStoreLockManagerFactory.newLockManager(
+            RemoteStoreLockManager remoteStoreMetadataLockManger = remoteStoreLockManagerFactory.newLockManager(
                 remoteStoreRepository,
                 indexUUID,
                 String.valueOf(shardId.shardId())
@@ -1072,11 +1073,24 @@ private void executeStaleShardDelete(
                                 // Releasing lock file before deleting the shallow-snap-UUID file because in case of any failure while
                                 // releasing the lock file, we would still have the shallow-snap-UUID file and that would be used during
                                 // next delete operation for releasing this lock file
-                                RemoteStoreMetadataLockManager remoteStoreMetadataLockManager = remoteStoreLockManagerFactory
-                                    .newLockManager(remoteStoreRepoForIndex, indexUUID, shardId);
+                                RemoteStoreLockManager remoteStoreMetadataLockManager = remoteStoreLockManagerFactory.newLockManager(
+                                    remoteStoreRepoForIndex,
+                                    indexUUID,
+                                    shardId
+                                );
                                 remoteStoreMetadataLockManager.release(
                                     FileLockInfo.getLockInfoBuilder().withAcquirerId(snapshotUUID).build()
                                 );
+                                if (!isIndexPresent(clusterService, indexUUID)) {
+                                    // this is a temporary solution where snapshot deletion triggers remote store side
+                                    // cleanup if index is already deleted. We will add a poller in future to take
+                                    // care of remote store side cleanup.
+                                    // see https://github.com/opensearch-project/OpenSearch/issues/8469
+                                    new RemoteSegmentStoreDirectoryFactory(
+                                        remoteStoreLockManagerFactory.getRepositoriesService(),
+                                        threadPool
+                                    ).newDirectory(remoteStoreRepoForIndex, indexUUID, shardId).close();
+                                }
                             }
                         }
                     }
@@ -1487,6 +1501,15 @@ private void cleanupStaleIndices(
         }
     }
 
+    private static boolean isIndexPresent(ClusterService clusterService, String indexUUID) {
+        for (final IndexMetadata indexMetadata : clusterService.state().metadata().getIndices().values()) {
+            if (indexUUID.equals(indexMetadata.getIndexUUID())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     private void executeOneStaleIndexDelete(
         BlockingQueue<Map.Entry<String, BlobContainer>> staleIndicesToDelete,
         RemoteStoreLockManagerFactory remoteStoreLockManagerFactory,
@@ -1519,11 +1542,21 @@ private void executeOneStaleIndexDelete(
                                         // Releasing lock files before deleting the shallow-snap-UUID file because in case of any failure
                                         // while releasing the lock file, we would still have the corresponding shallow-snap-UUID file
                                         // and that would be used during next delete operation for releasing this stale lock file
-                                        RemoteStoreMetadataLockManager remoteStoreMetadataLockManager = remoteStoreLockManagerFactory
+                                        RemoteStoreLockManager remoteStoreMetadataLockManager = remoteStoreLockManagerFactory
                                             .newLockManager(remoteStoreRepoForIndex, indexUUID, shardBlob.getKey());
                                         remoteStoreMetadataLockManager.release(
                                             FileLockInfo.getLockInfoBuilder().withAcquirerId(snapshotUUID).build()
                                         );
+                                        if (!isIndexPresent(clusterService, indexUUID)) {
+                                            // this is a temporary solution where snapshot deletion triggers remote store side
+                                            // cleanup if index is already deleted. We will add a poller in future to take
+                                            // care of remote store side cleanup.
+                                            // see https://github.com/opensearch-project/OpenSearch/issues/8469
+                                            new RemoteSegmentStoreDirectoryFactory(
+                                                remoteStoreLockManagerFactory.getRepositoriesService(),
+                                                threadPool
+                                            ).newDirectory(remoteStoreRepoForIndex, indexUUID, shardBlob.getKey()).close();
+                                        }
                                     }
                                 }
                             }
diff --git a/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryTests.java b/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryTests.java
index 26082f2456867..ee9181dba4563 100644
--- a/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryTests.java
+++ b/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryTests.java
@@ -166,8 +166,6 @@ public void testRetrieveSnapshots() throws Exception {
         assertThat(snapshotIds, equalTo(originalSnapshots));
     }
 
-    // Validate Scenario remoteStoreShallowCopy Snapshot -> remoteStoreShallowCopy Snapshot
-    // -> remoteStoreShallowCopy Snapshot -> normal snapshot
     public void testReadAndWriteSnapshotsThroughIndexFile() throws Exception {
         final BlobStoreRepository repository = setupRepo();
         final long pendingGeneration = repository.metadata.pendingGeneration();
diff --git a/test/framework/src/main/java/org/opensearch/snapshots/AbstractSnapshotIntegTestCase.java b/test/framework/src/main/java/org/opensearch/snapshots/AbstractSnapshotIntegTestCase.java
index 2c6f4f7b15e5d..9c3f342e58111 100644
--- a/test/framework/src/main/java/org/opensearch/snapshots/AbstractSnapshotIntegTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/snapshots/AbstractSnapshotIntegTestCase.java
@@ -557,6 +557,11 @@ protected String[] getLockFilesInRemoteStore(String remoteStoreIndex, String rem
             .prepareGetSettings(remoteStoreIndex)
             .get()
             .getSetting(remoteStoreIndex, IndexMetadata.SETTING_INDEX_UUID);
+        return getLockFilesInRemoteStore(remoteStoreIndex, remoteStoreRepositoryName, indexUUID);
+    }
+
+    protected String[] getLockFilesInRemoteStore(String remoteStoreIndex, String remoteStoreRepositoryName, String indexUUID)
+        throws IOException {
         final RepositoriesService repositoriesService = internalCluster().getCurrentClusterManagerNodeInstance(RepositoriesService.class);
         final BlobStoreRepository remoteStoreRepository = (BlobStoreRepository) repositoriesService.repository(remoteStoreRepositoryName);
         BlobPath shardLevelBlobPath = remoteStoreRepository.basePath().add(indexUUID).add("0").add("segments").add("lock_files");

From f3a17fc79f3daee83e2222345e8f15a9630578c6 Mon Sep 17 00:00:00 2001
From: Gaurav Bafna <85113518+gbbafna@users.noreply.github.com>
Date: Thu, 3 Aug 2023 16:47:20 +0530
Subject: [PATCH 34/37] Avoid duplicate indexing in case of SegRep enabled
 indices' translog replay (#8578)

Signed-off-by: Gaurav Bafna <gbbafna@amazon.com>
---
 .../recovery/IndexPrimaryRelocationIT.java    | 14 +--
 .../RemoteIndexPrimaryRelocationIT.java       | 66 ++++++++++++++
 .../opensearch/remotestore/RemoteStoreIT.java |  3 +
 .../ReplicaToPrimaryPromotionIT.java          | 64 ++++++++++++++
 .../index/engine/InternalEngine.java          | 28 ++++--
 .../index/shard/IndexShardTests.java          | 27 +++---
 ...dTests.java => RemoteIndexShardTests.java} | 39 ++++++++-
 ...overyWithRemoteTranslogOnPrimaryTests.java | 12 +--
 .../SegmentReplicationIndexShardTests.java    | 40 ++++++++-
 .../TranslogTransferManagerTests.java         |  5 +-
 ...enSearchIndexLevelReplicationTestCase.java | 17 +---
 .../index/shard/IndexShardTestCase.java       | 86 ++++++++++++++-----
 12 files changed, 325 insertions(+), 76 deletions(-)
 create mode 100644 server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteIndexPrimaryRelocationIT.java
 rename server/src/test/java/org/opensearch/index/shard/{SegmentReplicationWithRemoteIndexShardTests.java => RemoteIndexShardTests.java} (78%)

diff --git a/server/src/internalClusterTest/java/org/opensearch/indices/recovery/IndexPrimaryRelocationIT.java b/server/src/internalClusterTest/java/org/opensearch/indices/recovery/IndexPrimaryRelocationIT.java
index 32a10451a0dd3..e9962706bcd39 100644
--- a/server/src/internalClusterTest/java/org/opensearch/indices/recovery/IndexPrimaryRelocationIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/indices/recovery/IndexPrimaryRelocationIT.java
@@ -56,14 +56,16 @@ public class IndexPrimaryRelocationIT extends OpenSearchIntegTestCase {
 
     private static final int RELOCATION_COUNT = 15;
 
+    public void setup() {}
+
+    public Settings indexSettings() {
+        return Settings.builder().put("index.number_of_shards", 1).put("index.number_of_replicas", 0).build();
+    }
+
     public void testPrimaryRelocationWhileIndexing() throws Exception {
         internalCluster().ensureAtLeastNumDataNodes(randomIntBetween(2, 3));
-        client().admin()
-            .indices()
-            .prepareCreate("test")
-            .setSettings(Settings.builder().put("index.number_of_shards", 1).put("index.number_of_replicas", 0))
-            .setMapping("field", "type=text")
-            .get();
+        setup();
+        client().admin().indices().prepareCreate("test").setSettings(indexSettings()).setMapping("field", "type=text").get();
         ensureGreen("test");
         AtomicInteger numAutoGenDocs = new AtomicInteger();
         final AtomicBoolean finished = new AtomicBoolean(false);
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteIndexPrimaryRelocationIT.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteIndexPrimaryRelocationIT.java
new file mode 100644
index 0000000000000..a9482c8c19187
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteIndexPrimaryRelocationIT.java
@@ -0,0 +1,66 @@
+/*
+ * 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.
+ */
+
+package org.opensearch.remotestore;
+
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.indices.recovery.IndexPrimaryRelocationIT;
+import org.opensearch.indices.replication.common.ReplicationType;
+import org.opensearch.test.OpenSearchIntegTestCase;
+
+import java.nio.file.Path;
+
+import static org.opensearch.remotestore.RemoteStoreBaseIntegTestCase.remoteStoreClusterSettings;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
+
+@OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST)
+public class RemoteIndexPrimaryRelocationIT extends IndexPrimaryRelocationIT {
+
+    protected static final String REPOSITORY_NAME = "test-remote-store-repo";
+
+    protected Path absolutePath;
+
+    public void setup() {
+        absolutePath = randomRepoPath().toAbsolutePath();
+        assertAcked(
+            clusterAdmin().preparePutRepository(REPOSITORY_NAME).setType("fs").setSettings(Settings.builder().put("location", absolutePath))
+        );
+    }
+
+    protected Settings nodeSettings(int nodeOrdinal) {
+        return Settings.builder()
+            .put(super.nodeSettings(nodeOrdinal))
+            .put(remoteStoreClusterSettings(REPOSITORY_NAME, REPOSITORY_NAME, false))
+            .build();
+    }
+
+    @Override
+    protected boolean addMockInternalEngine() {
+        return false;
+    }
+
+    public Settings indexSettings() {
+        return Settings.builder()
+            .put(super.indexSettings())
+            .put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT)
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+            .build();
+    }
+
+    @Override
+    protected Settings featureFlagSettings() {
+        return Settings.builder()
+            .put(super.featureFlagSettings())
+            .put(FeatureFlags.REMOTE_STORE, "true")
+            .put(FeatureFlags.SEGMENT_REPLICATION_EXPERIMENTAL, "true")
+            .build();
+    }
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreIT.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreIT.java
index 693c4113f8f3b..51ae37c3b4faa 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreIT.java
@@ -40,6 +40,9 @@
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.oneOf;
 import static org.hamcrest.Matchers.comparesEqualTo;
+import static org.hamcrest.Matchers.comparesEqualTo;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.oneOf;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertHitCount;
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/ReplicaToPrimaryPromotionIT.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/ReplicaToPrimaryPromotionIT.java
index 549b4985894a7..c73e7f603b09b 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/ReplicaToPrimaryPromotionIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/ReplicaToPrimaryPromotionIT.java
@@ -11,17 +11,22 @@
 import com.carrotsearch.randomizedtesting.RandomizedTest;
 import org.junit.Before;
 import org.opensearch.action.admin.indices.close.CloseIndexResponse;
+import org.opensearch.action.index.IndexResponse;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.routing.IndexShardRoutingTable;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.core.rest.RestStatus;
 import org.opensearch.test.BackgroundIndexer;
 import org.opensearch.test.InternalTestCluster;
 import org.opensearch.test.OpenSearchIntegTestCase;
 
 import java.util.Locale;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.is;
@@ -116,4 +121,63 @@ public void testPromoteReplicaToPrimary() throws Exception {
         refresh(indexName);
         assertHitCount(client().prepareSearch(indexName).setSize(0).get(), numOfDocs);
     }
+
+    public void testFailoverWhileIndexing() throws Exception {
+        internalCluster().startNode();
+        internalCluster().startNode();
+        final String indexName = randomAlphaOfLength(5).toLowerCase(Locale.ROOT);
+        shard_count = scaledRandomIntBetween(1, 5);
+        createIndex(indexName);
+        ensureGreen(indexName);
+        int docCount = scaledRandomIntBetween(20, 50);
+        final int indexDocAfterFailover = scaledRandomIntBetween(20, 50);
+        AtomicInteger numAutoGenDocs = new AtomicInteger();
+        CountDownLatch latch = new CountDownLatch(1);
+        final AtomicBoolean finished = new AtomicBoolean(false);
+        Thread indexingThread = new Thread(() -> {
+            int docsAfterFailover = 0;
+            while (finished.get() == false && numAutoGenDocs.get() < docCount) {
+                IndexResponse indexResponse = internalCluster().clusterManagerClient()
+                    .prepareIndex(indexName)
+                    .setSource("field", numAutoGenDocs.get())
+                    .get();
+
+                if (indexResponse.status() == RestStatus.CREATED || indexResponse.status() == RestStatus.ACCEPTED) {
+                    numAutoGenDocs.incrementAndGet();
+                    if (numAutoGenDocs.get() == docCount / 2) {
+                        if (random().nextInt(3) == 0) {
+                            refresh(indexName);
+                        } else if (random().nextInt(2) == 0) {
+                            flush(indexName);
+                        }
+                        // Node is killed on this
+                        latch.countDown();
+                    } else if (numAutoGenDocs.get() > docCount / 2) {
+                        docsAfterFailover++;
+                        if (docsAfterFailover == indexDocAfterFailover) {
+                            finished.set(true);
+                        }
+                    }
+                }
+            }
+            logger.debug("Done indexing");
+        });
+        indexingThread.start();
+        latch.await();
+
+        ClusterState state = client(internalCluster().getClusterManagerName()).admin().cluster().prepareState().get().getState();
+        final int numShards = state.metadata().index(indexName).getNumberOfShards();
+        final ShardRouting primaryShard = state.routingTable().index(indexName).shard(randomIntBetween(0, numShards - 1)).primaryShard();
+        final DiscoveryNode randomNode = state.nodes().resolveNode(primaryShard.currentNodeId());
+
+        // stop the random data node, all remaining shards are promoted to primaries
+        internalCluster().stopRandomNode(InternalTestCluster.nameFilter(randomNode.getName()));
+        ensureYellowAndNoInitializingShards(indexName);
+        indexingThread.join();
+        refresh(indexName);
+        assertHitCount(
+            client(internalCluster().getClusterManagerName()).prepareSearch(indexName).setSize(0).setTrackTotalHits(true).get(),
+            numAutoGenDocs.get()
+        );
+    }
 }
diff --git a/server/src/main/java/org/opensearch/index/engine/InternalEngine.java b/server/src/main/java/org/opensearch/index/engine/InternalEngine.java
index 77d63dfaade54..028298f662e7b 100644
--- a/server/src/main/java/org/opensearch/index/engine/InternalEngine.java
+++ b/server/src/main/java/org/opensearch/index/engine/InternalEngine.java
@@ -710,6 +710,7 @@ private OpVsLuceneDocStatus compareOpToLuceneDocBasedOnSeqNo(final Operation op)
         final OpVsLuceneDocStatus status;
         VersionValue versionValue = getVersionFromMap(op.uid().bytes());
         assert incrementVersionLookup();
+        boolean segRepEnabled = engineConfig.getIndexSettings().isSegRepEnabled();
         if (versionValue != null) {
             status = compareOpToVersionMapOnSeqNo(op.id(), op.seqNo(), op.primaryTerm(), versionValue);
         } else {
@@ -722,10 +723,8 @@ private OpVsLuceneDocStatus compareOpToLuceneDocBasedOnSeqNo(final Operation op)
                 } else if (op.seqNo() > docAndSeqNo.seqNo) {
                     status = OpVsLuceneDocStatus.OP_NEWER;
                 } else if (op.seqNo() == docAndSeqNo.seqNo) {
-                    assert localCheckpointTracker.hasProcessed(op.seqNo()) : "local checkpoint tracker is not updated seq_no="
-                        + op.seqNo()
-                        + " id="
-                        + op.id();
+                    assert localCheckpointTracker.hasProcessed(op.seqNo()) || segRepEnabled
+                        : "local checkpoint tracker is not updated seq_no=" + op.seqNo() + " id=" + op.id();
                     status = OpVsLuceneDocStatus.OP_STALE_OR_EQUAL;
                 } else {
                     status = OpVsLuceneDocStatus.OP_STALE_OR_EQUAL;
@@ -927,6 +926,7 @@ public IndexResult index(Index index) throws IOException {
                             plan.currentNotFoundOrDeleted
                         );
                     }
+
                 }
                 if (index.origin().isFromTranslog() == false) {
                     final Translog.Location location;
@@ -1005,10 +1005,18 @@ protected final IndexingStrategy planIndexingAsNonPrimary(Index index) throws IO
             assert maxSeqNoOfUpdatesOrDeletes < index.seqNo() : index.seqNo() + ">=" + maxSeqNoOfUpdatesOrDeletes;
             plan = IndexingStrategy.optimizedAppendOnly(index.version(), 0);
         } else {
+            boolean segRepEnabled = engineConfig.getIndexSettings().isSegRepEnabled();
             versionMap.enforceSafeAccess();
             final OpVsLuceneDocStatus opVsLucene = compareOpToLuceneDocBasedOnSeqNo(index);
             if (opVsLucene == OpVsLuceneDocStatus.OP_STALE_OR_EQUAL) {
-                plan = IndexingStrategy.processAsStaleOp(index.version());
+                if (segRepEnabled) {
+                    // For segrep based indices, we can't completely rely on localCheckpointTracker
+                    // as the preserved checkpoint may not have all the operations present in lucene
+                    // we don't need to index it again as stale op as it would create multiple documents for same seq no
+                    plan = IndexingStrategy.processButSkipLucene(false, index.version());
+                } else {
+                    plan = IndexingStrategy.processAsStaleOp(index.version());
+                }
             } else {
                 plan = IndexingStrategy.processNormally(opVsLucene == OpVsLuceneDocStatus.LUCENE_DOC_NOT_FOUND, index.version(), 0);
             }
@@ -1442,9 +1450,17 @@ protected final DeletionStrategy planDeletionAsNonPrimary(Delete delete) throws
             // See testRecoveryWithOutOfOrderDelete for an example of peer recovery
             plan = DeletionStrategy.processButSkipLucene(false, delete.version());
         } else {
+            boolean segRepEnabled = engineConfig.getIndexSettings().isSegRepEnabled();
             final OpVsLuceneDocStatus opVsLucene = compareOpToLuceneDocBasedOnSeqNo(delete);
             if (opVsLucene == OpVsLuceneDocStatus.OP_STALE_OR_EQUAL) {
-                plan = DeletionStrategy.processAsStaleOp(delete.version());
+                if (segRepEnabled) {
+                    // For segrep based indices, we can't completely rely on localCheckpointTracker
+                    // as the preserved checkpoint may not have all the operations present in lucene
+                    // we don't need to index it again as stale op as it would create multiple documents for same seq no
+                    plan = DeletionStrategy.processButSkipLucene(false, delete.version());
+                } else {
+                    plan = DeletionStrategy.processAsStaleOp(delete.version());
+                }
             } else {
                 plan = DeletionStrategy.processNormally(opVsLucene == OpVsLuceneDocStatus.LUCENE_DOC_NOT_FOUND, delete.version(), 0);
             }
diff --git a/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java b/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java
index 96fa53fbf0fc2..f1ae4b16d9bad 100644
--- a/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java
+++ b/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java
@@ -36,8 +36,8 @@
 import org.apache.lucene.index.DirectoryReader;
 import org.apache.lucene.index.IndexCommit;
 import org.apache.lucene.index.IndexableField;
-import org.apache.lucene.index.Term;
 import org.apache.lucene.index.SegmentInfos;
+import org.apache.lucene.index.Term;
 import org.apache.lucene.search.ReferenceManager;
 import org.apache.lucene.search.TermQuery;
 import org.apache.lucene.search.TopDocs;
@@ -50,8 +50,6 @@
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.Constants;
 import org.junit.Assert;
-import org.opensearch.common.io.PathUtils;
-import org.opensearch.core.Assertions;
 import org.opensearch.OpenSearchException;
 import org.opensearch.Version;
 import org.opensearch.action.ActionListener;
@@ -77,11 +75,12 @@
 import org.opensearch.common.Randomness;
 import org.opensearch.common.Strings;
 import org.opensearch.common.UUIDs;
-import org.opensearch.core.common.bytes.BytesArray;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.concurrent.GatedCloseable;
+import org.opensearch.common.io.PathUtils;
 import org.opensearch.common.io.stream.BytesStreamOutput;
-import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.lease.Releasables;
 import org.opensearch.common.settings.IndexScopedSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
@@ -90,8 +89,9 @@
 import org.opensearch.common.util.concurrent.ConcurrentCollections;
 import org.opensearch.common.xcontent.XContentFactory;
 import org.opensearch.common.xcontent.XContentType;
-import org.opensearch.common.lease.Releasable;
-import org.opensearch.common.lease.Releasables;
+import org.opensearch.core.Assertions;
+import org.opensearch.core.common.bytes.BytesArray;
+import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.core.xcontent.NamedXContentRegistry;
 import org.opensearch.core.xcontent.XContentBuilder;
@@ -106,8 +106,8 @@
 import org.opensearch.index.engine.EngineTestCase;
 import org.opensearch.index.engine.InternalEngine;
 import org.opensearch.index.engine.InternalEngineFactory;
-import org.opensearch.index.engine.NRTReplicationEngineFactory;
 import org.opensearch.index.engine.NRTReplicationEngine;
+import org.opensearch.index.engine.NRTReplicationEngineFactory;
 import org.opensearch.index.engine.ReadOnlyEngine;
 import org.opensearch.index.fielddata.FieldDataStats;
 import org.opensearch.index.fielddata.IndexFieldData;
@@ -168,6 +168,7 @@
 import java.nio.file.attribute.BasicFileAttributes;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
@@ -192,7 +193,7 @@
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
-import java.util.Collection;
+
 import static java.util.Collections.emptyMap;
 import static java.util.Collections.emptySet;
 import static org.hamcrest.Matchers.containsInAnyOrder;
@@ -217,8 +218,8 @@
 import static org.mockito.Mockito.mock;
 import static org.opensearch.cluster.routing.TestShardRouting.newShardRouting;
 import static org.opensearch.common.lucene.Lucene.cleanLuceneIndex;
-import static org.opensearch.core.xcontent.ToXContent.EMPTY_PARAMS;
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
+import static org.opensearch.core.xcontent.ToXContent.EMPTY_PARAMS;
 import static org.opensearch.index.seqno.SequenceNumbers.UNASSIGNED_SEQ_NO;
 import static org.opensearch.test.hamcrest.RegexMatcher.matches;
 
@@ -2886,13 +2887,14 @@ public void testCommitLevelRestoreShardFromRemoteStore() throws IOException {
     }
 
     public void testRestoreShardFromRemoteStore(boolean performFlush) throws IOException {
+        String remoteStorePath = createTempDir().toString();
         IndexShard target = newStartedShard(
             true,
             Settings.builder()
                 .put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT)
                 .put(IndexMetadata.SETTING_REMOTE_STORE_ENABLED, true)
-                .put(IndexMetadata.SETTING_REMOTE_SEGMENT_STORE_REPOSITORY, "temp-fs")
-                .put(IndexMetadata.SETTING_REMOTE_TRANSLOG_STORE_REPOSITORY, "temp-fs")
+                .put(IndexMetadata.SETTING_REMOTE_SEGMENT_STORE_REPOSITORY, remoteStorePath + "__test")
+                .put(IndexMetadata.SETTING_REMOTE_TRANSLOG_STORE_REPOSITORY, remoteStorePath + "__test")
                 .build(),
             new InternalEngineFactory()
         );
@@ -2957,7 +2959,6 @@ public void testRestoreShardFromRemoteStore(boolean performFlush) throws IOExcep
         final PlainActionFuture<Boolean> future = PlainActionFuture.newFuture();
         target.restoreFromRemoteStore(future);
         target.remoteStore().decRef();
-
         assertTrue(future.actionGet());
         assertDocs(target, "1", "2");
 
diff --git a/server/src/test/java/org/opensearch/index/shard/SegmentReplicationWithRemoteIndexShardTests.java b/server/src/test/java/org/opensearch/index/shard/RemoteIndexShardTests.java
similarity index 78%
rename from server/src/test/java/org/opensearch/index/shard/SegmentReplicationWithRemoteIndexShardTests.java
rename to server/src/test/java/org/opensearch/index/shard/RemoteIndexShardTests.java
index b15d8b66fca55..a01169480de0b 100644
--- a/server/src/test/java/org/opensearch/index/shard/SegmentReplicationWithRemoteIndexShardTests.java
+++ b/server/src/test/java/org/opensearch/index/shard/RemoteIndexShardTests.java
@@ -19,10 +19,12 @@
 
 import java.io.IOException;
 import java.util.List;
+import java.util.concurrent.CountDownLatch;
 
 import static org.hamcrest.Matchers.equalTo;
+import static org.opensearch.index.engine.EngineTestCase.assertAtMostOneLuceneDocumentPerSequenceNumber;
 
-public class SegmentReplicationWithRemoteIndexShardTests extends SegmentReplicationIndexShardTests {
+public class RemoteIndexShardTests extends SegmentReplicationIndexShardTests {
 
     private static final String REPOSITORY_NAME = "temp-fs";
     private static final Settings settings = Settings.builder()
@@ -135,4 +137,39 @@ public void testNRTReplicaWithRemoteStorePromotedAsPrimary(boolean performFlushF
             }
         }
     }
+
+    public void testNoDuplicateSeqNo() throws Exception {
+        Settings settings = Settings.builder().put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT).build();
+        ReplicationGroup shards = createGroup(1, settings, indexMapping, new NRTReplicationEngineFactory(), createTempDir());
+        final IndexShard primaryShard = shards.getPrimary();
+        final IndexShard replicaShard = shards.getReplicas().get(0);
+        shards.startPrimary();
+        shards.startAll();
+        shards.indexDocs(10);
+        replicateSegments(primaryShard, shards.getReplicas());
+
+        flushShard(primaryShard);
+        shards.indexDocs(10);
+        replicateSegments(primaryShard, shards.getReplicas());
+
+        shards.indexDocs(10);
+        primaryShard.refresh("test");
+        replicateSegments(primaryShard, shards.getReplicas());
+
+        CountDownLatch latch = new CountDownLatch(1);
+        shards.promoteReplicaToPrimary(replicaShard, (shard, listener) -> {
+            try {
+                assertAtMostOneLuceneDocumentPerSequenceNumber(replicaShard.getEngine());
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+            latch.countDown();
+        });
+        latch.await();
+        for (IndexShard shard : shards) {
+            if (shard != null) {
+                closeShard(shard, false);
+            }
+        }
+    }
 }
diff --git a/server/src/test/java/org/opensearch/index/shard/ReplicaRecoveryWithRemoteTranslogOnPrimaryTests.java b/server/src/test/java/org/opensearch/index/shard/ReplicaRecoveryWithRemoteTranslogOnPrimaryTests.java
index 20b3dfc0f93a6..d71a290c9619a 100644
--- a/server/src/test/java/org/opensearch/index/shard/ReplicaRecoveryWithRemoteTranslogOnPrimaryTests.java
+++ b/server/src/test/java/org/opensearch/index/shard/ReplicaRecoveryWithRemoteTranslogOnPrimaryTests.java
@@ -23,7 +23,6 @@
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.replication.OpenSearchIndexLevelReplicationTestCase;
 import org.opensearch.index.seqno.SequenceNumbers;
-import org.opensearch.index.store.Store;
 import org.opensearch.index.translog.WriteOnlyTranslogManager;
 import org.opensearch.indices.recovery.RecoveryTarget;
 import org.opensearch.indices.replication.common.ReplicationType;
@@ -76,15 +75,6 @@ public void testStartSequenceForReplicaRecovery() throws Exception {
 
             int moreDocs = shards.indexDocs(randomIntBetween(20, 100));
             shards.flush();
-
-            final ShardRouting replicaRouting2 = newShardRouting(
-                replicaRouting.shardId(),
-                replicaRouting.currentNodeId(),
-                false,
-                ShardRoutingState.INITIALIZING,
-                RecoverySource.PeerRecoverySource.INSTANCE
-            );
-            Store remoteStore = createRemoteStore(remoteDir, replicaRouting2, newIndexMetadata);
             IndexShard newReplicaShard = newShard(
                 newShardRouting(
                     replicaRouting.shardId(),
@@ -102,7 +92,7 @@ public void testStartSequenceForReplicaRecovery() throws Exception {
                 replica.getGlobalCheckpointSyncer(),
                 replica.getRetentionLeaseSyncer(),
                 EMPTY_EVENT_LISTENER,
-                remoteStore
+                remoteDir
             );
             shards.addReplica(newReplicaShard);
             AtomicBoolean assertDone = new AtomicBoolean(false);
diff --git a/server/src/test/java/org/opensearch/index/shard/SegmentReplicationIndexShardTests.java b/server/src/test/java/org/opensearch/index/shard/SegmentReplicationIndexShardTests.java
index 4bdad5aa78c25..771e7313eee32 100644
--- a/server/src/test/java/org/opensearch/index/shard/SegmentReplicationIndexShardTests.java
+++ b/server/src/test/java/org/opensearch/index/shard/SegmentReplicationIndexShardTests.java
@@ -23,12 +23,12 @@
 import org.opensearch.cluster.routing.ShardRoutingHelper;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.concurrent.GatedCloseable;
+import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.CancellableThreads;
 import org.opensearch.common.xcontent.XContentType;
-import org.opensearch.common.lease.Releasable;
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.engine.Engine;
 import org.opensearch.index.engine.InternalEngineFactory;
@@ -50,8 +50,8 @@
 import org.opensearch.indices.replication.SegmentReplicationState;
 import org.opensearch.indices.replication.SegmentReplicationTarget;
 import org.opensearch.indices.replication.SegmentReplicationTargetService;
-import org.opensearch.indices.replication.checkpoint.SegmentReplicationCheckpointPublisher;
 import org.opensearch.indices.replication.checkpoint.ReplicationCheckpoint;
+import org.opensearch.indices.replication.checkpoint.SegmentReplicationCheckpointPublisher;
 import org.opensearch.indices.replication.common.CopyState;
 import org.opensearch.indices.replication.common.ReplicationFailedException;
 import org.opensearch.indices.replication.common.ReplicationListener;
@@ -82,6 +82,7 @@
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
+import static org.opensearch.index.engine.EngineTestCase.assertAtMostOneLuceneDocumentPerSequenceNumber;
 
 public class SegmentReplicationIndexShardTests extends OpenSearchIndexLevelReplicationTestCase {
 
@@ -673,6 +674,41 @@ protected SegmentReplicationTargetService newTargetService(SegmentReplicationSou
         );
     }
 
+    public void testNoDuplicateSeqNo() throws Exception {
+        Settings settings = Settings.builder().put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT).build();
+        ReplicationGroup shards = createGroup(1, settings, indexMapping, new NRTReplicationEngineFactory(), createTempDir());
+        final IndexShard primaryShard = shards.getPrimary();
+        final IndexShard replicaShard = shards.getReplicas().get(0);
+        shards.startPrimary();
+        shards.startAll();
+        shards.indexDocs(10);
+        replicateSegments(primaryShard, shards.getReplicas());
+
+        flushShard(primaryShard);
+        shards.indexDocs(10);
+        replicateSegments(primaryShard, shards.getReplicas());
+
+        shards.indexDocs(10);
+        primaryShard.refresh("test");
+        replicateSegments(primaryShard, shards.getReplicas());
+
+        CountDownLatch latch = new CountDownLatch(1);
+        shards.promoteReplicaToPrimary(replicaShard, (shard, listener) -> {
+            try {
+                assertAtMostOneLuceneDocumentPerSequenceNumber(replicaShard.getEngine());
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+            latch.countDown();
+        });
+        latch.await();
+        for (IndexShard shard : shards) {
+            if (shard != null) {
+                closeShard(shard, false);
+            }
+        }
+    }
+
     /**
      * Assert persisted and searchable doc counts.  This method should not be used while docs are concurrently indexed because
      * it asserts point in time seqNos are relative to the doc counts.
diff --git a/server/src/test/java/org/opensearch/index/translog/transfer/TranslogTransferManagerTests.java b/server/src/test/java/org/opensearch/index/translog/transfer/TranslogTransferManagerTests.java
index 3d622d6bdf8b8..99937faa18584 100644
--- a/server/src/test/java/org/opensearch/index/translog/transfer/TranslogTransferManagerTests.java
+++ b/server/src/test/java/org/opensearch/index/translog/transfer/TranslogTransferManagerTests.java
@@ -16,8 +16,8 @@
 import org.opensearch.common.blobstore.BlobMetadata;
 import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.common.blobstore.BlobStore;
-import org.opensearch.common.blobstore.support.PlainBlobMetadata;
 import org.opensearch.common.blobstore.stream.write.WritePriority;
+import org.opensearch.common.blobstore.support.PlainBlobMetadata;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.translog.Translog;
@@ -44,7 +44,6 @@
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.anyMap;
 import static org.mockito.ArgumentMatchers.anySet;
-import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doNothing;
@@ -432,7 +431,7 @@ public void testDeleteStaleTranslogMetadata() {
             .listAllInSortedOrderAsync(
                 eq(ThreadPool.Names.REMOTE_PURGE),
                 any(BlobPath.class),
-                anyString(),
+                eq(TranslogTransferMetadata.METADATA_PREFIX),
                 anyInt(),
                 any(ActionListener.class)
             );
diff --git a/test/framework/src/main/java/org/opensearch/index/replication/OpenSearchIndexLevelReplicationTestCase.java b/test/framework/src/main/java/org/opensearch/index/replication/OpenSearchIndexLevelReplicationTestCase.java
index 278847e56e65f..e8c5203129374 100644
--- a/test/framework/src/main/java/org/opensearch/index/replication/OpenSearchIndexLevelReplicationTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/index/replication/OpenSearchIndexLevelReplicationTestCase.java
@@ -75,12 +75,12 @@
 import org.opensearch.common.collect.Iterators;
 import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.lease.Releasables;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.xcontent.XContentType;
-import org.opensearch.common.lease.Releasable;
-import org.opensearch.common.lease.Releasables;
 import org.opensearch.core.index.Index;
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.engine.DocIdSeqNoAndSource;
@@ -98,7 +98,6 @@
 import org.opensearch.index.shard.PrimaryReplicaSyncer;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.shard.ShardPath;
-import org.opensearch.index.store.Store;
 import org.opensearch.index.translog.Translog;
 import org.opensearch.indices.recovery.RecoveryState;
 import org.opensearch.indices.recovery.RecoveryTarget;
@@ -253,10 +252,6 @@ protected ReplicationGroup(final IndexMetadata indexMetadata) throws IOException
 
         protected ReplicationGroup(final IndexMetadata indexMetadata, Path remotePath) throws IOException {
             final ShardRouting primaryRouting = this.createShardRouting("s0", true);
-            Store remoteStore = null;
-            if (remotePath != null) {
-                remoteStore = createRemoteStore(remotePath, primaryRouting, indexMetadata);
-            }
             primary = newShard(
                 primaryRouting,
                 indexMetadata,
@@ -264,7 +259,7 @@ protected ReplicationGroup(final IndexMetadata indexMetadata, Path remotePath) t
                 getEngineFactory(primaryRouting),
                 () -> {},
                 retentionLeaseSyncer,
-                remoteStore
+                remotePath
             );
             replicas = new CopyOnWriteArrayList<>();
             this.indexMetadata = indexMetadata;
@@ -390,10 +385,6 @@ public IndexShard addReplica() throws IOException {
 
         public IndexShard addReplica(Path remotePath) throws IOException {
             final ShardRouting replicaRouting = createShardRouting("s" + replicaId.incrementAndGet(), false);
-            Store remoteStore = null;
-            if (remotePath != null) {
-                remoteStore = createRemoteStore(remotePath, replicaRouting, indexMetadata);
-            }
             final IndexShard replica = newShard(
                 replicaRouting,
                 indexMetadata,
@@ -401,7 +392,7 @@ public IndexShard addReplica(Path remotePath) throws IOException {
                 getEngineFactory(replicaRouting),
                 () -> {},
                 retentionLeaseSyncer,
-                remoteStore
+                remotePath
             );
             addReplica(replica);
             return replica;
diff --git a/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java b/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java
index 66e5459cfea3b..29ecc6b376ad0 100644
--- a/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java
@@ -48,6 +48,7 @@
 import org.opensearch.action.support.replication.TransportReplicationAction;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.MappingMetadata;
+import org.opensearch.cluster.metadata.RepositoryMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.cluster.routing.IndexShardRoutingTable;
@@ -66,7 +67,6 @@
 import org.opensearch.common.blobstore.BlobStore;
 import org.opensearch.common.blobstore.fs.FsBlobContainer;
 import org.opensearch.common.blobstore.fs.FsBlobStore;
-import org.opensearch.core.common.bytes.BytesArray;
 import org.opensearch.common.concurrent.GatedCloseable;
 import org.opensearch.common.io.PathUtils;
 import org.opensearch.common.lease.Releasable;
@@ -77,9 +77,12 @@
 import org.opensearch.common.util.BigArrays;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.common.xcontent.XContentType;
-import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.core.common.bytes.BytesArray;
 import org.opensearch.core.index.Index;
+import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.env.Environment;
 import org.opensearch.env.NodeEnvironment;
+import org.opensearch.env.TestEnvironment;
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.MapperTestUtils;
 import org.opensearch.index.VersionType;
@@ -142,7 +145,9 @@
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.Repository;
 import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.repositories.blobstore.BlobStoreTestUtil;
 import org.opensearch.repositories.blobstore.OpenSearchBlobStoreRepositoryIntegTestCase;
+import org.opensearch.repositories.fs.FsRepository;
 import org.opensearch.snapshots.Snapshot;
 import org.opensearch.test.DummyShardLock;
 import org.opensearch.test.OpenSearchTestCase;
@@ -460,7 +465,7 @@ protected IndexShard newShard(
         @Nullable EngineFactory engineFactory,
         Runnable globalCheckpointSyncer,
         RetentionLeaseSyncer retentionLeaseSyncer,
-        Store remoteStore,
+        Path path,
         IndexingOperationListener... listeners
     ) throws IOException {
         // add node id as name to settings for proper logging
@@ -478,7 +483,7 @@ protected IndexShard newShard(
             globalCheckpointSyncer,
             retentionLeaseSyncer,
             EMPTY_EVENT_LISTENER,
-            remoteStore,
+            path,
             listeners
         );
     }
@@ -506,7 +511,7 @@ protected IndexShard newShard(
         Runnable globalCheckpointSyncer,
         RetentionLeaseSyncer retentionLeaseSyncer,
         IndexEventListener indexEventListener,
-        Store remoteStore,
+        Path remotePath,
         IndexingOperationListener... listeners
     ) throws IOException {
         return newShard(
@@ -521,7 +526,7 @@ protected IndexShard newShard(
             retentionLeaseSyncer,
             indexEventListener,
             SegmentReplicationCheckpointPublisher.EMPTY,
-            remoteStore,
+            remotePath,
             listeners
         );
     }
@@ -550,7 +555,7 @@ protected IndexShard newShard(
         RetentionLeaseSyncer retentionLeaseSyncer,
         IndexEventListener indexEventListener,
         SegmentReplicationCheckpointPublisher checkpointPublisher,
-        @Nullable Store remoteStore,
+        @Nullable Path remotePath,
         IndexingOperationListener... listeners
     ) throws IOException {
         final Settings nodeSettings = Settings.builder().put("node.name", routing.currentNodeId()).build();
@@ -578,26 +583,32 @@ protected IndexShard newShard(
                 Collections.emptyList(),
                 clusterSettings
             );
-
+            Store remoteStore = null;
             RemoteRefreshSegmentPressureService remoteRefreshSegmentPressureService = null;
+            RepositoriesService mockRepoSvc = mock(RepositoriesService.class);
+
             if (indexSettings.isRemoteStoreEnabled()) {
-                if (remoteStore == null) {
-                    Path remoteStorePath;
-                    String remoteStoreRepository = indexSettings.getRemoteStoreRepository();
-                    if (remoteStoreRepository != null && remoteStoreRepository.endsWith("__test")) {
-                        remoteStorePath = PathUtils.get(remoteStoreRepository.replace("__test", ""));
-                    } else {
-                        remoteStorePath = createTempDir();
-                    }
-                    remoteStore = createRemoteStore(remoteStorePath, routing, indexMetadata);
+                String remoteStoreRepository = indexSettings.getRemoteStoreRepository();
+                // remote path via setting a repository . This is a hack used for shards are created using reset .
+                // since we can't get remote path from IndexShard directly, we are using repository to store it .
+                if (remoteStoreRepository != null && remoteStoreRepository.endsWith("__test")) {
+                    remotePath = PathUtils.get(remoteStoreRepository.replace("__test", ""));
+                } else if (remotePath == null) {
+                    remotePath = createTempDir();
                 }
+
+                remoteStore = createRemoteStore(remotePath, routing, indexMetadata);
+
                 remoteRefreshSegmentPressureService = new RemoteRefreshSegmentPressureService(clusterService, indexSettings.getSettings());
+                BlobStoreRepository repo = createRepository(remotePath);
+                when(mockRepoSvc.repository(any())).thenAnswer(invocationOnMock -> repo);
             }
 
             final BiFunction<IndexSettings, ShardRouting, TranslogFactory> translogFactorySupplier = (settings, shardRouting) -> {
                 if (settings.isRemoteTranslogStoreEnabled() && shardRouting.primary()) {
+
                     return new RemoteBlobStoreInternalTranslogFactory(
-                        this::createRepositoriesService,
+                        () -> mockRepoSvc,
                         threadPool,
                         settings.getRemoteStoreTranslogRepository()
                     );
@@ -643,6 +654,39 @@ protected IndexShard newShard(
         return indexShard;
     }
 
+    private BlobStoreRepository createRepository(Path path) {
+        Settings settings = Settings.builder().put("location", path).build();
+        RepositoryMetadata repositoryMetadata = new RepositoryMetadata(randomAlphaOfLength(10), FsRepository.TYPE, settings);
+        final ClusterService clusterService = BlobStoreTestUtil.mockClusterService(repositoryMetadata);
+        final FsRepository repository = new FsRepository(
+            repositoryMetadata,
+            createEnvironment(path),
+            xContentRegistry(),
+            clusterService,
+            new RecoverySettings(Settings.EMPTY, new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS))
+        ) {
+            @Override
+            protected void assertSnapshotOrGenericThread() {
+                // eliminate thread name check as we create repo manually
+            }
+        };
+        clusterService.addStateApplier(event -> repository.updateState(event.state()));
+        // Apply state once to initialize repo properly like RepositoriesService would
+        repository.updateState(clusterService.state());
+        repository.start();
+        return repository;
+    }
+
+    private Environment createEnvironment(Path path) {
+        Path home = createTempDir();
+        return TestEnvironment.newEnvironment(
+            Settings.builder()
+                .put(Environment.PATH_HOME_SETTING.getKey(), home.toAbsolutePath())
+                .put(Environment.PATH_REPO_SETTING.getKey(), path.toAbsolutePath())
+                .build()
+        );
+    }
+
     protected RepositoriesService createRepositoriesService() {
         RepositoriesService repositoriesService = Mockito.mock(RepositoriesService.class);
         BlobStoreRepository repository = Mockito.mock(BlobStoreRepository.class);
@@ -724,7 +768,7 @@ protected IndexShard reinitShard(IndexShard current, ShardRouting routing, Index
             current.indexSettings.getIndexMetadata(),
             current.engineFactory,
             current.engineConfigFactory,
-            current.remoteStore(),
+            null,
             listeners
         );
     }
@@ -743,7 +787,7 @@ protected IndexShard reinitShard(
         IndexMetadata indexMetadata,
         EngineFactory engineFactory,
         EngineConfigFactory engineConfigFactory,
-        Store remoteStore,
+        Path remotePath,
         IndexingOperationListener... listeners
     ) throws IOException {
         closeShards(current);
@@ -758,7 +802,7 @@ protected IndexShard reinitShard(
             current.getGlobalCheckpointSyncer(),
             current.getRetentionLeaseSyncer(),
             EMPTY_EVENT_LISTENER,
-            remoteStore,
+            remotePath,
             listeners
         );
     }

From 64a74570741e76cda87762d7d5bbc74087e9feb8 Mon Sep 17 00:00:00 2001
From: Ashish <ssashish@amazon.com>
Date: Thu, 3 Aug 2023 20:02:43 +0530
Subject: [PATCH 35/37] Fix flaky test testStatsOnShardUnassigned in
 RemoteStoreStatsIT (#9057)

---------

Signed-off-by: Ashish Singh <ssashish@amazon.com>
---
 .../opensearch/remotestore/RemoteStoreStatsIT.java  | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreStatsIT.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreStatsIT.java
index 1c7f14701b3e7..bd546a01b0b88 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreStatsIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreStatsIT.java
@@ -9,6 +9,7 @@
 package org.opensearch.remotestore;
 
 import org.junit.Before;
+import org.opensearch.action.admin.cluster.health.ClusterHealthResponse;
 import org.opensearch.action.admin.cluster.remotestore.restore.RestoreRemoteStoreRequest;
 import org.opensearch.action.admin.cluster.remotestore.stats.RemoteStoreStats;
 import org.opensearch.action.admin.cluster.remotestore.stats.RemoteStoreStatsRequestBuilder;
@@ -22,6 +23,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.remote.RemoteSegmentTransferTracker;
+import org.opensearch.test.InternalTestCluster;
 import org.opensearch.test.OpenSearchIntegTestCase;
 
 import java.io.IOException;
@@ -443,12 +445,19 @@ public void testStatsOnShardUnassigned() throws IOException {
         createIndex(INDEX_NAME, remoteStoreIndexSettings(2, 1));
         ensureGreen(INDEX_NAME);
         indexDocs();
-        int dataNodeCountBeforeStop = client().admin().cluster().prepareHealth().get().getNumberOfDataNodes();
-        internalCluster().stopRandomDataNode();
+        ClusterHealthResponse clusterHealthResponse = client().admin().cluster().prepareHealth().get();
+        int dataNodeCountBeforeStop = clusterHealthResponse.getNumberOfDataNodes();
+        int nodeCount = clusterHealthResponse.getNumberOfNodes();
+        String nodeToBeStopped = randomBoolean() ? primaryNodeName(INDEX_NAME) : replicaNodeName(INDEX_NAME);
+        internalCluster().stopRandomNode(InternalTestCluster.nameFilter(nodeToBeStopped));
+        ensureYellowAndNoInitializingShards(INDEX_NAME);
+        ensureStableCluster(nodeCount - 1);
         RemoteStoreStatsResponse response = client().admin().cluster().prepareRemoteStoreStats(INDEX_NAME, "0").get();
         int dataNodeCountAfterStop = client().admin().cluster().prepareHealth().get().getNumberOfDataNodes();
         assertEquals(dataNodeCountBeforeStop, response.getTotalShards());
         assertEquals(dataNodeCountAfterStop, response.getSuccessfulShards());
+        // Indexing docs to ensure that the primary has started
+        indexSingleDoc(INDEX_NAME);
     }
 
     public void testStatsOnRemoteStoreRestore() throws IOException {

From 60300399f536e850ffc6fe58f42494b4549feae8 Mon Sep 17 00:00:00 2001
From: Marc Handalian <handalm@amazon.com>
Date: Thu, 3 Aug 2023 09:47:30 -0700
Subject: [PATCH 36/37] Fix test testDropPrimaryDuringReplication and clean up
 ReplicationCheckpoint validation (#8889)

* Fix test testDropPrimaryDuringReplication and clean up ReplicationCheckpoint validation.

This test is now occasionally failing with replicas having 0 documents. This occurs in a couple of ways:
1. After dropping the old primary the new primary is not publishing a checkpoint to replicas unless it indexes docs from translog after flipping to primary mode.
If there is nothing to index, it will not publish a checkpoint, but the other replica could have never sync'd with the original primary and be left out of date.
- This PR fixes this by force publishing a checkpoint after the new primary flips to primary mode.
2. The replica receives a checkpoint post failover and cancels its sync with the former primary that is still active, recognizing a primary term bump.
However this cancellation is async and immediately starting a new replication event could fail as its still replicating.
- This PR fixes this by attempting to process the latest received checkpoint on failure, if the shard is not failed and still behind.

This PR also introduces a few changes to ensure the accuracy of the ReplicationCheckpoint tracked on primary & replicas.
- Ensure the checkpoint stored in SegmentReplicationTarget is the checkpoint passed from the primary and not locally computed.  This ensures checks for primary term are accurate and not using a locally compued operationPrimaryTerm.
- Introduces a refresh listener for both primary & replica to update the ReplicationCheckpoint and store it in replicationTracker post refresh rather than redundantly computing when accessed.
- Removes unnecessary onCheckpointPublished method used to start replication timers manually.  This will happen automatically on primaries once its local cp is updated.

Signed-off-by: Marc Handalian <handalm@amazon.com>

* Handle NoSuchFileException when attempting to delete decref'd files.

To avoid divergent logic with remote store, we always incref/decref the segmentinfos.files(true) which includes the segments_n file.
Decref to 0 will attempt to delete the file from the store and its possible this _n file does not yet exist. This change will ignore if we get a noSuchFile while attempting to delete.

Signed-off-by: Marc Handalian <handalm@amazon.com>

* Add more unit tests.

Signed-off-by: Marc Handalian <handalm@amazon.com>

* Clean up IndexShardTests.testCheckpointReffreshListenerWithNull

Signed-off-by: Marc Handalian <handalm@amazon.com>

* Remove unnecessary catch for NoSuchFileException.

Signed-off-by: Marc Handalian <handalm@amazon.com>

* Add another test for non segrep.

Signed-off-by: Marc Handalian <handalm@amazon.com>

* PR Feedback.

Signed-off-by: Marc Handalian <handalm@amazon.com>

* re-compute replication checkpoint on primary promotion.

Signed-off-by: Marc Handalian <handalm@amazon.com>

---------

Signed-off-by: Marc Handalian <handalm@amazon.com>
---
 .../replication/SegmentReplicationIT.java     |  10 +-
 .../index/engine/NRTReplicationEngine.java    |  15 +++
 .../opensearch/index/shard/IndexShard.java    |  69 +++++++----
 .../shard/RemoteStoreRefreshListener.java     |   5 +-
 .../replication/SegmentReplicationTarget.java |  20 +++-
 .../SegmentReplicationTargetService.java      | 107 +++++++++++-------
 ...SegmentReplicationCheckpointPublisher.java |   1 -
 .../engine/NRTReplicationEngineTests.java     |  72 ++++++++++++
 .../index/shard/IndexShardTests.java          |  51 +--------
 .../SegmentReplicationIndexShardTests.java    |  79 ++++++++++++-
 ...licationWithNodeToNodeIndexShardTests.java |  16 ++-
 .../SegmentReplicationTargetServiceTests.java |  90 +++++++++------
 .../SegmentReplicationTargetTests.java        |  14 +--
 .../recovery/ReplicationCollectionTests.java  |   2 +
 .../index/shard/IndexShardTestCase.java       |  60 +++++++++-
 15 files changed, 435 insertions(+), 176 deletions(-)

diff --git a/server/src/internalClusterTest/java/org/opensearch/indices/replication/SegmentReplicationIT.java b/server/src/internalClusterTest/java/org/opensearch/indices/replication/SegmentReplicationIT.java
index 08186bf3f9362..72b6a0296e3bb 100644
--- a/server/src/internalClusterTest/java/org/opensearch/indices/replication/SegmentReplicationIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/indices/replication/SegmentReplicationIT.java
@@ -44,6 +44,8 @@
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.routing.ShardRoutingState;
 import org.opensearch.cluster.routing.allocation.command.CancelAllocationCommand;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.concurrent.GatedCloseable;
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.common.lucene.index.OpenSearchDirectoryReader;
 import org.opensearch.common.settings.Settings;
@@ -60,6 +62,7 @@
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.indices.recovery.FileChunkRequest;
+import org.opensearch.indices.replication.checkpoint.ReplicationCheckpoint;
 import org.opensearch.indices.replication.common.ReplicationType;
 import org.opensearch.search.SearchService;
 import org.opensearch.search.builder.PointInTimeBuilder;
@@ -983,8 +986,11 @@ public void testScrollCreatedOnReplica() throws Exception {
             )
         );
         final IndexShard replicaShard = getIndexShard(replica, INDEX_NAME);
-        final SegmentInfos segmentInfos = replicaShard.getLatestSegmentInfosAndCheckpoint().v1().get();
-        final Collection<String> snapshottedSegments = segmentInfos.files(false);
+        final Tuple<GatedCloseable<SegmentInfos>, ReplicationCheckpoint> tuple = replicaShard.getLatestSegmentInfosAndCheckpoint();
+        final Collection<String> snapshottedSegments;
+        try (final GatedCloseable<SegmentInfos> closeable = tuple.v1()) {
+            snapshottedSegments = closeable.get().files(false);
+        }
         // opens a scrolled query before a flush is called.
         // this is for testing scroll segment consistency between refresh and flush
         SearchResponse searchResponse = client(replica).prepareSearch()
diff --git a/server/src/main/java/org/opensearch/index/engine/NRTReplicationEngine.java b/server/src/main/java/org/opensearch/index/engine/NRTReplicationEngine.java
index e852658d7b3ba..6b09b8d86dc6c 100644
--- a/server/src/main/java/org/opensearch/index/engine/NRTReplicationEngine.java
+++ b/server/src/main/java/org/opensearch/index/engine/NRTReplicationEngine.java
@@ -34,6 +34,7 @@
 import java.io.Closeable;
 import java.io.IOException;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -445,6 +446,20 @@ protected SegmentInfos getLatestSegmentInfos() {
         return readerManager.getSegmentInfos();
     }
 
+    @Override
+    public synchronized GatedCloseable<SegmentInfos> getSegmentInfosSnapshot() {
+        // get reference to latest infos
+        final SegmentInfos latestSegmentInfos = getLatestSegmentInfos();
+        // incref all files
+        try {
+            final Collection<String> files = latestSegmentInfos.files(false);
+            store.incRefFileDeleter(files);
+            return new GatedCloseable<>(latestSegmentInfos, () -> store.decRefFileDeleter(files));
+        } catch (IOException e) {
+            throw new EngineException(shardId, e.getMessage(), e);
+        }
+    }
+
     protected LocalCheckpointTracker getLocalCheckpointTracker() {
         return localCheckpointTracker;
     }
diff --git a/server/src/main/java/org/opensearch/index/shard/IndexShard.java b/server/src/main/java/org/opensearch/index/shard/IndexShard.java
index 2b85193275a13..ace6ed56c007c 100644
--- a/server/src/main/java/org/opensearch/index/shard/IndexShard.java
+++ b/server/src/main/java/org/opensearch/index/shard/IndexShard.java
@@ -677,8 +677,19 @@ public void updateShardState(
                                 // this Shard's engine was read only, we need to update its engine before restoring local history from xlog.
                                 assert newRouting.primary() && currentRouting.primary() == false;
                                 resetEngineToGlobalCheckpoint();
+                                // It is possible an engine can open with a SegmentInfos on a higher gen but the reader does not refresh to
+                                // trigger our refresh listener.
+                                // Force update the checkpoint post engine reset.
+                                updateReplicationCheckpoint();
                             }
+
                             replicationTracker.activatePrimaryMode(getLocalCheckpoint());
+                            if (indexSettings.isSegRepEnabled()) {
+                                // force publish a checkpoint once in primary mode so that replicas not caught up to previous primary
+                                // are brought up to date.
+                                checkpointPublisher.publish(this, getLatestReplicationCheckpoint());
+                            }
+
                             ensurePeerRecoveryRetentionLeasesExist();
                             /*
                              * If this shard was serving as a replica shard when another shard was promoted to primary then
@@ -1551,15 +1562,7 @@ public GatedCloseable<IndexCommit> acquireSafeIndexCommit() throws EngineExcepti
      * @return EMPTY checkpoint before the engine is opened and null for non-segrep enabled indices
      */
     public ReplicationCheckpoint getLatestReplicationCheckpoint() {
-        final Tuple<GatedCloseable<SegmentInfos>, ReplicationCheckpoint> infosAndCheckpoint = getLatestSegmentInfosAndCheckpoint();
-        if (infosAndCheckpoint == null) {
-            return null;
-        }
-        try (final GatedCloseable<SegmentInfos> ignored = infosAndCheckpoint.v1()) {
-            return infosAndCheckpoint.v2();
-        } catch (IOException e) {
-            throw new OpenSearchException("Error Closing SegmentInfos Snapshot", e);
-        }
+        return replicationTracker.getLatestReplicationCheckpoint();
     }
 
     /**
@@ -1573,13 +1576,11 @@ public ReplicationCheckpoint getLatestReplicationCheckpoint() {
      *
      */
     public Tuple<GatedCloseable<SegmentInfos>, ReplicationCheckpoint> getLatestSegmentInfosAndCheckpoint() {
-        if (indexSettings.isSegRepEnabled() == false) {
-            return null;
-        }
+        assert indexSettings.isSegRepEnabled();
 
         Tuple<GatedCloseable<SegmentInfos>, ReplicationCheckpoint> nullSegmentInfosEmptyCheckpoint = new Tuple<>(
             new GatedCloseable<>(null, () -> {}),
-            ReplicationCheckpoint.empty(shardId, getDefaultCodecName())
+            getLatestReplicationCheckpoint()
         );
 
         if (getEngineOrNull() == null) {
@@ -1598,11 +1599,7 @@ public Tuple<GatedCloseable<SegmentInfos>, ReplicationCheckpoint> getLatestSegme
                         getOperationPrimaryTerm(),
                         segmentInfos.getGeneration(),
                         segmentInfos.getVersion(),
-                        // TODO: Update replicas to compute length from SegmentInfos. Replicas do not yet incref segments with
-                        // getSegmentInfosSnapshot, so computing length from SegmentInfos can cause issues.
-                        shardRouting.primary()
-                            ? store.getSegmentMetadataMap(segmentInfos).values().stream().mapToLong(StoreFileMetadata::length).sum()
-                            : store.stats(StoreStats.UNKNOWN_RESERVED_BYTES).getSizeInBytes(),
+                        store.getSegmentMetadataMap(segmentInfos).values().stream().mapToLong(StoreFileMetadata::length).sum(),
                         getEngine().config().getCodec().getName()
                     )
                 );
@@ -1858,10 +1855,6 @@ public void resetToWriteableEngine() throws IOException, InterruptedException, T
         indexShardOperationPermits.blockOperations(30, TimeUnit.MINUTES, () -> { resetEngineToGlobalCheckpoint(); });
     }
 
-    public void onCheckpointPublished(ReplicationCheckpoint checkpoint) {
-        replicationTracker.setLatestReplicationCheckpoint(checkpoint);
-    }
-
     /**
      * Wrapper for a non-closing reader
      *
@@ -2342,6 +2335,11 @@ private void innerOpenEngineAndTranslog(LongSupplier globalCheckpointSupplier, b
             final Engine newEngine = engineFactory.newReadWriteEngine(config);
             onNewEngine(newEngine);
             currentEngineReference.set(newEngine);
+
+            if (indexSettings.isSegRepEnabled()) {
+                // set initial replication checkpoints into tracker.
+                updateReplicationCheckpoint();
+            }
             // We set active because we are now writing operations to the engine; this way,
             // we can flush if we go idle after some time and become inactive.
             active.set(true);
@@ -3667,6 +3665,9 @@ private EngineConfig newEngineConfig(LongSupplier globalCheckpointSupplier) thro
 
         internalRefreshListener.clear();
         internalRefreshListener.add(new RefreshMetricUpdater(refreshMetric));
+        if (indexSettings.isSegRepEnabled()) {
+            internalRefreshListener.add(new ReplicationCheckpointUpdater());
+        }
         if (this.checkpointPublisher != null && shardRouting.primary() && indexSettings.isSegRepLocalEnabled()) {
             internalRefreshListener.add(new CheckpointRefreshListener(this, this.checkpointPublisher));
         }
@@ -4471,6 +4472,30 @@ public void afterRefresh(boolean didRefresh) throws IOException {
         }
     }
 
+    /**
+     * Refresh listener to update the Shard's ReplicationCheckpoint post refresh.
+     */
+    private class ReplicationCheckpointUpdater implements ReferenceManager.RefreshListener {
+        @Override
+        public void beforeRefresh() throws IOException {}
+
+        @Override
+        public void afterRefresh(boolean didRefresh) throws IOException {
+            if (didRefresh) {
+                updateReplicationCheckpoint();
+            }
+        }
+    }
+
+    private void updateReplicationCheckpoint() {
+        final Tuple<GatedCloseable<SegmentInfos>, ReplicationCheckpoint> tuple = getLatestSegmentInfosAndCheckpoint();
+        try (final GatedCloseable<SegmentInfos> ignored = tuple.v1()) {
+            replicationTracker.setLatestReplicationCheckpoint(tuple.v2());
+        } catch (IOException e) {
+            throw new OpenSearchException("Error Closing SegmentInfos Snapshot", e);
+        }
+    }
+
     private EngineConfig.TombstoneDocSupplier tombstoneDocSupplier() {
         final RootObjectMapper.Builder noopRootMapper = new RootObjectMapper.Builder("__noop");
         final DocumentMapper noopDocumentMapper = mapperService != null
diff --git a/server/src/main/java/org/opensearch/index/shard/RemoteStoreRefreshListener.java b/server/src/main/java/org/opensearch/index/shard/RemoteStoreRefreshListener.java
index 8dd0c8b9d4405..d56054dd1c42b 100644
--- a/server/src/main/java/org/opensearch/index/shard/RemoteStoreRefreshListener.java
+++ b/server/src/main/java/org/opensearch/index/shard/RemoteStoreRefreshListener.java
@@ -185,7 +185,6 @@ private synchronized boolean syncSegments() {
             return true;
         }
         ReplicationCheckpoint checkpoint = indexShard.getLatestReplicationCheckpoint();
-        indexShard.onCheckpointPublished(checkpoint);
         beforeSegmentsSync();
         long refreshTimeMs = segmentTracker.getLocalRefreshTimeMs(), refreshClockTimeMs = segmentTracker.getLocalRefreshClockTimeMs();
         long refreshSeqNo = segmentTracker.getLocalRefreshSeqNo();
@@ -207,6 +206,10 @@ private synchronized boolean syncSegments() {
 
                 try (GatedCloseable<SegmentInfos> segmentInfosGatedCloseable = indexShard.getSegmentInfosSnapshot()) {
                     SegmentInfos segmentInfos = segmentInfosGatedCloseable.get();
+                    assert segmentInfos.getGeneration() == checkpoint.getSegmentsGen() : "SegmentInfos generation: "
+                        + segmentInfos.getGeneration()
+                        + " does not match metadata generation: "
+                        + checkpoint.getSegmentsGen();
                     // Capture replication checkpoint before uploading the segments as upload can take some time and checkpoint can
                     // move.
                     long lastRefreshedCheckpoint = ((InternalEngine) indexShard.getEngine()).lastRefreshedCheckpoint();
diff --git a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTarget.java b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTarget.java
index c22701dfc94ce..3a84163bb979d 100644
--- a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTarget.java
+++ b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTarget.java
@@ -51,9 +51,14 @@ public class SegmentReplicationTarget extends ReplicationTarget {
 
     public final static String REPLICATION_PREFIX = "replication.";
 
-    public SegmentReplicationTarget(IndexShard indexShard, SegmentReplicationSource source, ReplicationListener listener) {
+    public SegmentReplicationTarget(
+        IndexShard indexShard,
+        ReplicationCheckpoint checkpoint,
+        SegmentReplicationSource source,
+        ReplicationListener listener
+    ) {
         super("replication_target", indexShard, new ReplicationLuceneIndex(), listener);
-        this.checkpoint = indexShard.getLatestReplicationCheckpoint();
+        this.checkpoint = checkpoint;
         this.source = source;
         this.state = new SegmentReplicationState(
             indexShard.routingEntry(),
@@ -90,12 +95,19 @@ public SegmentReplicationState state() {
     }
 
     public SegmentReplicationTarget retryCopy() {
-        return new SegmentReplicationTarget(indexShard, source, listener);
+        return new SegmentReplicationTarget(indexShard, checkpoint, source, listener);
     }
 
     @Override
     public String description() {
-        return String.format(Locale.ROOT, "Id:[%d] Shard:[%s] Source:[%s]", getId(), shardId(), source.getDescription());
+        return String.format(
+            Locale.ROOT,
+            "Id:[%d] Checkpoint [%s] Shard:[%s] Source:[%s]",
+            getId(),
+            getCheckpoint(),
+            shardId(),
+            source.getDescription()
+        );
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTargetService.java b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTargetService.java
index b41c9e09add45..84d6a722e572e 100644
--- a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTargetService.java
+++ b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTargetService.java
@@ -234,7 +234,7 @@ public synchronized void onNewCheckpoint(final ReplicationCheckpoint receivedChe
                     logger.trace(
                         () -> new ParameterizedMessage(
                             "Ignoring new replication checkpoint - shard is currently replicating to checkpoint {}",
-                            replicaShard.getLatestReplicationCheckpoint()
+                            ongoingReplicationTarget.getCheckpoint()
                         )
                     );
                     return;
@@ -242,7 +242,7 @@ public synchronized void onNewCheckpoint(final ReplicationCheckpoint receivedChe
             }
             final Thread thread = Thread.currentThread();
             if (replicaShard.shouldProcessCheckpoint(receivedCheckpoint)) {
-                startReplication(replicaShard, new SegmentReplicationListener() {
+                startReplication(replicaShard, receivedCheckpoint, new SegmentReplicationListener() {
                     @Override
                     public void onReplicationDone(SegmentReplicationState state) {
                         logger.trace(
@@ -280,6 +280,8 @@ public void onReplicationFailure(
                         );
                         if (sendShardFailure == true) {
                             failShard(e, replicaShard);
+                        } else {
+                            processLatestReceivedCheckpoint(replicaShard, thread);
                         }
                     }
                 });
@@ -396,8 +398,24 @@ protected void updateLatestReceivedCheckpoint(ReplicationCheckpoint receivedChec
         }
     }
 
-    public SegmentReplicationTarget startReplication(final IndexShard indexShard, final SegmentReplicationListener listener) {
-        final SegmentReplicationTarget target = new SegmentReplicationTarget(indexShard, sourceFactory.get(indexShard), listener);
+    /**
+     * Start a round of replication and sync to at least the given checkpoint.
+     * @param indexShard - {@link IndexShard} replica shard
+     * @param checkpoint - {@link ReplicationCheckpoint} checkpoint to sync to
+     * @param listener - {@link ReplicationListener}
+     * @return {@link SegmentReplicationTarget} target event orchestrating the event.
+     */
+    public SegmentReplicationTarget startReplication(
+        final IndexShard indexShard,
+        final ReplicationCheckpoint checkpoint,
+        final SegmentReplicationListener listener
+    ) {
+        final SegmentReplicationTarget target = new SegmentReplicationTarget(
+            indexShard,
+            checkpoint,
+            sourceFactory.get(indexShard),
+            listener
+        );
         startReplication(target);
         return target;
     }
@@ -529,50 +547,59 @@ private void forceReplication(ForceSyncRequest request, ActionListener<Transport
         if (indexShard == null || indexShard.getReplicationEngine().isEmpty()) {
             listener.onResponse(TransportResponse.Empty.INSTANCE);
         } else {
-            startReplication(indexShard, new SegmentReplicationTargetService.SegmentReplicationListener() {
-                @Override
-                public void onReplicationDone(SegmentReplicationState state) {
-                    try {
-                        logger.trace(
+            // We are skipping any validation for an incoming checkpoint, use the shard's latest checkpoint in the target.
+            startReplication(
+                indexShard,
+                indexShard.getLatestReplicationCheckpoint(),
+                new SegmentReplicationTargetService.SegmentReplicationListener() {
+                    @Override
+                    public void onReplicationDone(SegmentReplicationState state) {
+                        try {
+                            logger.trace(
+                                () -> new ParameterizedMessage(
+                                    "[shardId {}] [replication id {}] Force replication Sync complete to {}, timing data: {}",
+                                    shardId,
+                                    state.getReplicationId(),
+                                    indexShard.getLatestReplicationCheckpoint(),
+                                    state.getTimingData()
+                                )
+                            );
+                            // Promote engine type for primary target
+                            if (indexShard.recoveryState().getPrimary() == true) {
+                                indexShard.resetToWriteableEngine();
+                            } else {
+                                // Update the replica's checkpoint on primary's replication tracker.
+                                updateVisibleCheckpoint(state.getReplicationId(), indexShard);
+                            }
+                            listener.onResponse(TransportResponse.Empty.INSTANCE);
+                        } catch (Exception e) {
+                            logger.error("Error while marking replication completed", e);
+                            listener.onFailure(e);
+                        }
+                    }
+
+                    @Override
+                    public void onReplicationFailure(
+                        SegmentReplicationState state,
+                        ReplicationFailedException e,
+                        boolean sendShardFailure
+                    ) {
+                        logger.error(
                             () -> new ParameterizedMessage(
-                                "[shardId {}] [replication id {}] Force replication Sync complete to {}, timing data: {}",
-                                shardId,
+                                "[shardId {}] [replication id {}] Force replication Sync failed, timing data: {}",
+                                indexShard.shardId().getId(),
                                 state.getReplicationId(),
-                                indexShard.getLatestReplicationCheckpoint(),
                                 state.getTimingData()
-                            )
+                            ),
+                            e
                         );
-                        // Promote engine type for primary target
-                        if (indexShard.recoveryState().getPrimary() == true) {
-                            indexShard.resetToWriteableEngine();
-                        } else {
-                            // Update the replica's checkpoint on primary's replication tracker.
-                            updateVisibleCheckpoint(state.getReplicationId(), indexShard);
+                        if (sendShardFailure) {
+                            failShard(e, indexShard);
                         }
-                        listener.onResponse(TransportResponse.Empty.INSTANCE);
-                    } catch (Exception e) {
-                        logger.error("Error while marking replication completed", e);
                         listener.onFailure(e);
                     }
                 }
-
-                @Override
-                public void onReplicationFailure(SegmentReplicationState state, ReplicationFailedException e, boolean sendShardFailure) {
-                    logger.error(
-                        () -> new ParameterizedMessage(
-                            "[shardId {}] [replication id {}] Replication failed, timing data: {}",
-                            indexShard.shardId().getId(),
-                            state.getReplicationId(),
-                            state.getTimingData()
-                        ),
-                        e
-                    );
-                    if (sendShardFailure) {
-                        failShard(e, indexShard);
-                    }
-                    listener.onFailure(e);
-                }
-            });
+            );
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/indices/replication/checkpoint/SegmentReplicationCheckpointPublisher.java b/server/src/main/java/org/opensearch/indices/replication/checkpoint/SegmentReplicationCheckpointPublisher.java
index b4bcdc92e539a..f5cb32b741862 100644
--- a/server/src/main/java/org/opensearch/indices/replication/checkpoint/SegmentReplicationCheckpointPublisher.java
+++ b/server/src/main/java/org/opensearch/indices/replication/checkpoint/SegmentReplicationCheckpointPublisher.java
@@ -34,7 +34,6 @@ public SegmentReplicationCheckpointPublisher(PublishAction publishAction) {
 
     public void publish(IndexShard indexShard, ReplicationCheckpoint checkpoint) {
         publishAction.publish(indexShard, checkpoint);
-        indexShard.onCheckpointPublished(checkpoint);
     }
 
     /**
diff --git a/server/src/test/java/org/opensearch/index/engine/NRTReplicationEngineTests.java b/server/src/test/java/org/opensearch/index/engine/NRTReplicationEngineTests.java
index 64fe42493c686..4c87df48f583f 100644
--- a/server/src/test/java/org/opensearch/index/engine/NRTReplicationEngineTests.java
+++ b/server/src/test/java/org/opensearch/index/engine/NRTReplicationEngineTests.java
@@ -12,7 +12,9 @@
 import org.apache.lucene.index.NoMergePolicy;
 import org.apache.lucene.index.SegmentInfos;
 import org.apache.lucene.search.ReferenceManager;
+import org.apache.lucene.store.IOContext;
 import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.UUIDs;
 import org.opensearch.common.concurrent.GatedCloseable;
 import org.opensearch.common.lucene.Lucene;
 import org.opensearch.common.lucene.index.OpenSearchDirectoryReader;
@@ -28,6 +30,8 @@
 
 import java.io.IOException;
 import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -367,4 +371,72 @@ private NRTReplicationEngine buildNrtReplicaEngine(AtomicLong globalCheckpoint,
     private NRTReplicationEngine buildNrtReplicaEngine(AtomicLong globalCheckpoint, Store store) throws IOException {
         return buildNrtReplicaEngine(globalCheckpoint, store, defaultSettings);
     }
+
+    public void testGetSegmentInfosSnapshotPreservesFilesUntilRelease() throws Exception {
+        final AtomicLong globalCheckpoint = new AtomicLong(SequenceNumbers.NO_OPS_PERFORMED);
+
+        // TODO: Remove this divergent commit logic and copy Segments_N from primary with node-node.
+        // randomly toggle commit / no commit.
+        IndexSettings settings = REMOTE_STORE_INDEX_SETTINGS;
+        final boolean shouldCommit = randomBoolean();
+        if (shouldCommit) {
+            settings = INDEX_SETTINGS;
+        }
+        try (
+            final Store nrtEngineStore = createStore(REMOTE_STORE_INDEX_SETTINGS, newDirectory());
+            final NRTReplicationEngine nrtEngine = buildNrtReplicaEngine(globalCheckpoint, nrtEngineStore, settings)
+        ) {
+            // only index 2 docs here, this will create segments _0 and _1 and after forcemerge into _2.
+            final int docCount = 2;
+            List<Engine.Operation> operations = generateHistoryOnReplica(docCount, randomBoolean(), randomBoolean(), randomBoolean());
+            for (Engine.Operation op : operations) {
+                applyOperation(engine, op);
+                applyOperation(nrtEngine, op);
+                // refresh to create a lot of segments.
+                engine.refresh("test");
+            }
+            assertEquals(2, engine.segmentsStats(false, false).getCount());
+            // wipe the nrt directory initially so we can sync with primary.
+            Lucene.cleanLuceneIndex(nrtEngineStore.directory());
+            assertFalse(
+                Arrays.stream(nrtEngineStore.directory().listAll())
+                    .anyMatch(file -> file.equals("write.lock") == false && file.equals("extra0") == false)
+            );
+            for (String file : engine.getLatestSegmentInfos().files(true)) {
+                nrtEngineStore.directory().copyFrom(store.directory(), file, file, IOContext.DEFAULT);
+            }
+            nrtEngine.updateSegments(engine.getLatestSegmentInfos());
+            assertEquals(engine.getLatestSegmentInfos(), nrtEngine.getLatestSegmentInfos());
+            final GatedCloseable<SegmentInfos> snapshot = nrtEngine.getSegmentInfosSnapshot();
+            final Collection<String> replicaSnapshotFiles = snapshot.get().files(false);
+            List<String> replicaFiles = List.of(nrtEngine.store.directory().listAll());
+
+            // merge primary down to 1 segment
+            engine.forceMerge(true, 1, false, false, false, UUIDs.randomBase64UUID());
+            // we expect a 3rd segment to be created after merge.
+            assertEquals(3, engine.segmentsStats(false, false).getCount());
+            final Collection<String> latestPrimaryFiles = engine.getLatestSegmentInfos().files(false);
+
+            // copy new segments in and load reader.
+            for (String file : latestPrimaryFiles) {
+                if (replicaFiles.contains(file) == false) {
+                    nrtEngineStore.directory().copyFrom(store.directory(), file, file, IOContext.DEFAULT);
+                }
+            }
+            nrtEngine.updateSegments(engine.getLatestSegmentInfos());
+
+            replicaFiles = List.of(nrtEngine.store.directory().listAll());
+            assertTrue(replicaFiles.containsAll(replicaSnapshotFiles));
+
+            // close snapshot, files should be cleaned up
+            snapshot.close();
+
+            replicaFiles = List.of(nrtEngine.store.directory().listAll());
+            assertFalse(replicaFiles.containsAll(replicaSnapshotFiles));
+
+            // Ensure we still have all the active files. Note - we exclude the infos file here if we aren't committing
+            // the nrt reader will still reference segments_n-1 after being loaded until a local commit occurs.
+            assertTrue(replicaFiles.containsAll(nrtEngine.getLatestSegmentInfos().files(shouldCommit)));
+        }
+    }
 }
diff --git a/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java b/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java
index f1ae4b16d9bad..8ffeb5d689f55 100644
--- a/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java
+++ b/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java
@@ -3753,7 +3753,7 @@ public void testReadSnapshotConcurrently() throws IOException, InterruptedExcept
      */
     public void testCheckpointRefreshListener() throws IOException {
         final SegmentReplicationCheckpointPublisher mock = mock(SegmentReplicationCheckpointPublisher.class);
-        IndexShard shard = newStartedShard(p -> newShard(mock), true);
+        IndexShard shard = newStartedShard(p -> newShard(true, mock), true);
         List<ReferenceManager.RefreshListener> refreshListeners = shard.getEngine().config().getInternalRefreshListener();
         assertTrue(refreshListeners.stream().anyMatch(e -> e instanceof CheckpointRefreshListener));
         closeShards(shard);
@@ -3763,58 +3763,13 @@ public void testCheckpointRefreshListener() throws IOException {
      * here we are passing null in place of SegmentReplicationCheckpointPublisher and testing  on index shard if CheckpointRefreshListener is not added to the InternalrefreshListerners List
      */
     public void testCheckpointRefreshListenerWithNull() throws IOException {
-        IndexShard shard = newStartedShard(p -> newShard(null), true);
+        final SegmentReplicationCheckpointPublisher publisher = null;
+        IndexShard shard = newStartedShard(p -> newShard(true, publisher), true);
         List<ReferenceManager.RefreshListener> refreshListeners = shard.getEngine().config().getInternalRefreshListener();
         assertFalse(refreshListeners.stream().anyMatch(e -> e instanceof CheckpointRefreshListener));
         closeShards(shard);
     }
 
-    /**
-     * creates a new initializing shard. The shard will be put in its proper path under the
-     * current node id the shard is assigned to.
-     * @param checkpointPublisher               Segment Replication Checkpoint Publisher to publish checkpoint
-     */
-    private IndexShard newShard(SegmentReplicationCheckpointPublisher checkpointPublisher) throws IOException {
-        final ShardId shardId = new ShardId("index", "_na_", 0);
-        final ShardRouting shardRouting = TestShardRouting.newShardRouting(
-            shardId,
-            randomAlphaOfLength(10),
-            true,
-            ShardRoutingState.INITIALIZING,
-            RecoverySource.EmptyStoreRecoverySource.INSTANCE
-        );
-        final NodeEnvironment.NodePath nodePath = new NodeEnvironment.NodePath(createTempDir());
-        ShardPath shardPath = new ShardPath(false, nodePath.resolve(shardId), nodePath.resolve(shardId), shardId);
-
-        Settings indexSettings = Settings.builder()
-            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
-            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
-            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
-            .put(IndexMetadata.SETTING_REPLICATION_TYPE, "SEGMENT")
-            .put(IndexSettings.INDEX_SOFT_DELETES_RETENTION_OPERATIONS_SETTING.getKey(), between(0, 1000))
-            .put(Settings.EMPTY)
-            .build();
-        IndexMetadata metadata = IndexMetadata.builder(shardRouting.getIndexName())
-            .settings(indexSettings)
-            .primaryTerm(0, primaryTerm)
-            .putMapping("{ \"properties\": {} }")
-            .build();
-        return newShard(
-            shardRouting,
-            shardPath,
-            metadata,
-            null,
-            null,
-            new InternalEngineFactory(),
-            new EngineConfigFactory(new IndexSettings(metadata, metadata.getSettings())),
-            () -> {},
-            RetentionLeaseSyncer.EMPTY,
-            EMPTY_EVENT_LISTENER,
-            checkpointPublisher,
-            null
-        );
-    }
-
     public void testIndexCheckOnStartup() throws Exception {
         final IndexShard indexShard = newStartedShard(true);
 
diff --git a/server/src/test/java/org/opensearch/index/shard/SegmentReplicationIndexShardTests.java b/server/src/test/java/org/opensearch/index/shard/SegmentReplicationIndexShardTests.java
index 771e7313eee32..1117367cbe465 100644
--- a/server/src/test/java/org/opensearch/index/shard/SegmentReplicationIndexShardTests.java
+++ b/server/src/test/java/org/opensearch/index/shard/SegmentReplicationIndexShardTests.java
@@ -19,6 +19,7 @@
 import org.opensearch.action.index.IndexRequest;
 import org.opensearch.action.support.PlainActionFuture;
 import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.routing.IndexShardRoutingTable;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.routing.ShardRoutingHelper;
 import org.opensearch.common.collect.Tuple;
@@ -63,6 +64,7 @@
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CountDownLatch;
@@ -423,7 +425,70 @@ public void testShardIdleWithNoReplicas() throws Exception {
     /**
      * here we are starting a new primary shard in PrimaryMode and testing if the shard publishes checkpoint after refresh.
      */
-    public void testPublishCheckpointOnPrimaryMode() throws IOException {
+    public void testPublishCheckpointOnPrimaryMode() throws IOException, InterruptedException {
+        final SegmentReplicationCheckpointPublisher mock = mock(SegmentReplicationCheckpointPublisher.class);
+        IndexShard shard = newStartedShard(p -> newShard(false, mock, settings), false);
+
+        final ShardRouting shardRouting = shard.routingEntry();
+        promoteReplica(
+            shard,
+            Collections.singleton(shardRouting.allocationId().getId()),
+            new IndexShardRoutingTable.Builder(shardRouting.shardId()).addShard(shardRouting).build()
+        );
+
+        final CountDownLatch latch = new CountDownLatch(1);
+        shard.acquirePrimaryOperationPermit(new ActionListener<Releasable>() {
+            @Override
+            public void onResponse(Releasable releasable) {
+                releasable.close();
+                latch.countDown();
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                throw new RuntimeException(e);
+            }
+        }, ThreadPool.Names.GENERIC, "");
+
+        latch.await();
+        // verify checkpoint is published
+        verify(mock, times(1)).publish(any(), any());
+        closeShards(shard);
+    }
+
+    public void testPublishCheckpointOnPrimaryMode_segrep_off() throws IOException, InterruptedException {
+        final SegmentReplicationCheckpointPublisher mock = mock(SegmentReplicationCheckpointPublisher.class);
+        final Settings settings = Settings.builder().put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.DOCUMENT).build();
+        IndexShard shard = newStartedShard(p -> newShard(false, mock, settings), false);
+
+        final ShardRouting shardRouting = shard.routingEntry();
+        promoteReplica(
+            shard,
+            Collections.singleton(shardRouting.allocationId().getId()),
+            new IndexShardRoutingTable.Builder(shardRouting.shardId()).addShard(shardRouting).build()
+        );
+
+        final CountDownLatch latch = new CountDownLatch(1);
+        shard.acquirePrimaryOperationPermit(new ActionListener<Releasable>() {
+            @Override
+            public void onResponse(Releasable releasable) {
+                releasable.close();
+                latch.countDown();
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                throw new RuntimeException(e);
+            }
+        }, ThreadPool.Names.GENERIC, "");
+
+        latch.await();
+        // verify checkpoint is published
+        verify(mock, times(0)).publish(any(), any());
+        closeShards(shard);
+    }
+
+    public void testPublishCheckpointPostFailover() throws IOException {
         final SegmentReplicationCheckpointPublisher mock = mock(SegmentReplicationCheckpointPublisher.class);
         IndexShard shard = newStartedShard(true);
         CheckpointRefreshListener refreshListener = new CheckpointRefreshListener(shard, mock);
@@ -482,7 +547,7 @@ public void testRejectCheckpointOnShardRoutingPrimary() throws IOException {
         spy.onNewCheckpoint(new ReplicationCheckpoint(primaryShard.shardId(), 0L, 0L, 0L, Codec.getDefault().getName()), spyShard);
 
         // Verify that checkpoint is not processed as shard routing is primary.
-        verify(spy, times(0)).startReplication(any(), any());
+        verify(spy, times(0)).startReplication(any(), any(), any());
         closeShards(primaryShard);
     }
 
@@ -656,7 +721,7 @@ public void cancel() {
                 }
             };
             when(sourceFactory.get(any())).thenReturn(source);
-            startReplicationAndAssertCancellation(replica, targetService);
+            startReplicationAndAssertCancellation(replica, primary, targetService);
 
             shards.removeReplica(replica);
             closeShards(replica);
@@ -736,11 +801,15 @@ protected void resolveCheckpointInfoResponseListener(ActionListener<CheckpointIn
         }
     }
 
-    protected void startReplicationAndAssertCancellation(IndexShard replica, SegmentReplicationTargetService targetService)
-        throws InterruptedException {
+    protected void startReplicationAndAssertCancellation(
+        IndexShard replica,
+        IndexShard primary,
+        SegmentReplicationTargetService targetService
+    ) throws InterruptedException {
         CountDownLatch latch = new CountDownLatch(1);
         final SegmentReplicationTarget target = targetService.startReplication(
             replica,
+            primary.getLatestReplicationCheckpoint(),
             new SegmentReplicationTargetService.SegmentReplicationListener() {
                 @Override
                 public void onReplicationDone(SegmentReplicationState state) {
diff --git a/server/src/test/java/org/opensearch/index/shard/SegmentReplicationWithNodeToNodeIndexShardTests.java b/server/src/test/java/org/opensearch/index/shard/SegmentReplicationWithNodeToNodeIndexShardTests.java
index 1f40068c11da4..3ab3858068332 100644
--- a/server/src/test/java/org/opensearch/index/shard/SegmentReplicationWithNodeToNodeIndexShardTests.java
+++ b/server/src/test/java/org/opensearch/index/shard/SegmentReplicationWithNodeToNodeIndexShardTests.java
@@ -95,7 +95,7 @@ public void getSegmentFiles(
                 }
             };
             when(sourceFactory.get(any())).thenReturn(source);
-            startReplicationAndAssertCancellation(replica, targetService);
+            startReplicationAndAssertCancellation(replica, primary, targetService);
 
             shards.removeReplica(replica);
             closeShards(replica);
@@ -137,7 +137,7 @@ public void getSegmentFiles(
                 }
             };
             when(sourceFactory.get(any())).thenReturn(source);
-            startReplicationAndAssertCancellation(replica, targetService);
+            startReplicationAndAssertCancellation(replica, primary, targetService);
 
             shards.removeReplica(replica);
             closeShards(replica);
@@ -189,7 +189,7 @@ public void cancel() {
                 }
             };
             when(sourceFactory.get(any())).thenReturn(source);
-            startReplicationAndAssertCancellation(replica, targetService);
+            startReplicationAndAssertCancellation(replica, primary, targetService);
 
             shards.removeReplica(replica);
             closeShards(replica);
@@ -227,7 +227,7 @@ public void getSegmentFiles(
                 ) {}
             };
             when(sourceFactory.get(any())).thenReturn(source);
-            startReplicationAndAssertCancellation(replica, targetService);
+            startReplicationAndAssertCancellation(replica, primary, targetService);
 
             shards.removeReplica(replica);
             closeShards(replica);
@@ -275,7 +275,7 @@ public void getSegmentFiles(
                 }
             };
             when(sourceFactory.get(any())).thenReturn(source);
-            startReplicationAndAssertCancellation(nextPrimary, targetService);
+            startReplicationAndAssertCancellation(nextPrimary, oldPrimary, targetService);
             // wait for replica to finish being promoted, and assert doc counts.
             final CountDownLatch latch = new CountDownLatch(1);
             nextPrimary.acquirePrimaryOperationPermit(new ActionListener<>() {
@@ -422,7 +422,11 @@ public void testTemporaryFilesNotCleanup() throws Exception {
                 runnablePostGetFiles
             );
             when(sourceFactory.get(any())).thenReturn(segmentReplicationSource);
-            targetService.startReplication(replica, getTargetListener(primaryShard, replica, primaryMetadata, countDownLatch));
+            targetService.startReplication(
+                replica,
+                primaryShard.getLatestReplicationCheckpoint(),
+                getTargetListener(primaryShard, replica, primaryMetadata, countDownLatch)
+            );
             countDownLatch.await(30, TimeUnit.SECONDS);
             assertEquals("Replication failed", 0, countDownLatch.getCount());
             shards.assertAllEqual(numDocs);
diff --git a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetServiceTests.java b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetServiceTests.java
index efb8dda201e87..4a04a64196918 100644
--- a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetServiceTests.java
+++ b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetServiceTests.java
@@ -84,6 +84,7 @@ public class SegmentReplicationTargetServiceTests extends IndexShardTestCase {
     private IndicesService indicesService;
 
     private SegmentReplicationState state;
+    private ReplicationCheckpoint initialCheckpoint;
 
     private static final long TRANSPORT_TIMEOUT = 30000;// 30sec
 
@@ -130,7 +131,7 @@ public void setUp() throws Exception {
 
         when(clusterState.nodes()).thenReturn(DiscoveryNodes.builder().add(localNode).build());
         sut = prepareForReplication(primaryShard, replicaShard, transportService, indicesService, clusterService);
-        ReplicationCheckpoint initialCheckpoint = replicaShard.getLatestReplicationCheckpoint();
+        initialCheckpoint = primaryShard.getLatestReplicationCheckpoint();
         aheadCheckpoint = new ReplicationCheckpoint(
             initialCheckpoint.getShardId(),
             initialCheckpoint.getPrimaryTerm(),
@@ -165,19 +166,23 @@ public void tearDown() throws Exception {
 
     public void testsSuccessfulReplication_listenerCompletes() throws InterruptedException {
         CountDownLatch latch = new CountDownLatch(1);
-        sut.startReplication(replicaShard, new SegmentReplicationTargetService.SegmentReplicationListener() {
-            @Override
-            public void onReplicationDone(SegmentReplicationState state) {
-                assertEquals(SegmentReplicationState.Stage.DONE, state.getStage());
-                latch.countDown();
-            }
+        sut.startReplication(
+            replicaShard,
+            primaryShard.getLatestReplicationCheckpoint(),
+            new SegmentReplicationTargetService.SegmentReplicationListener() {
+                @Override
+                public void onReplicationDone(SegmentReplicationState state) {
+                    assertEquals(SegmentReplicationState.Stage.DONE, state.getStage());
+                    latch.countDown();
+                }
 
-            @Override
-            public void onReplicationFailure(SegmentReplicationState state, ReplicationFailedException e, boolean sendShardFailure) {
-                logger.error("Unexpected error", e);
-                Assert.fail("Test should succeed");
+                @Override
+                public void onReplicationFailure(SegmentReplicationState state, ReplicationFailedException e, boolean sendShardFailure) {
+                    logger.error("Unexpected error", e);
+                    Assert.fail("Test should succeed");
+                }
             }
-        });
+        );
         latch.await(2, TimeUnit.SECONDS);
         assertEquals(0, latch.getCount());
     }
@@ -209,6 +214,7 @@ public void getSegmentFiles(
         };
         final SegmentReplicationTarget target = new SegmentReplicationTarget(
             replicaShard,
+            primaryShard.getLatestReplicationCheckpoint(),
             source,
             new SegmentReplicationTargetService.SegmentReplicationListener() {
                 @Override
@@ -233,7 +239,7 @@ public void onReplicationFailure(SegmentReplicationState state, ReplicationFaile
     public void testAlreadyOnNewCheckpoint() {
         SegmentReplicationTargetService spy = spy(sut);
         spy.onNewCheckpoint(replicaShard.getLatestReplicationCheckpoint(), replicaShard);
-        verify(spy, times(0)).startReplication(any(), any());
+        verify(spy, times(0)).startReplication(any(), any(), any());
     }
 
     public void testShardAlreadyReplicating() {
@@ -271,24 +277,22 @@ public void getSegmentFiles(
             }
         };
         final SegmentReplicationTarget target = spy(
-            new SegmentReplicationTarget(replicaShard, source, mock(SegmentReplicationTargetService.SegmentReplicationListener.class))
+            new SegmentReplicationTarget(
+                replicaShard,
+                primaryShard.getLatestReplicationCheckpoint(),
+                source,
+                mock(SegmentReplicationTargetService.SegmentReplicationListener.class)
+            )
         );
+
+        final SegmentReplicationTargetService spy = spy(sut);
+        doReturn(false).when(spy).processLatestReceivedCheckpoint(eq(replicaShard), any());
         // Start first round of segment replication.
-        sut.startReplication(target);
+        spy.startReplication(target);
 
         // Start second round of segment replication, this should fail to start as first round is still in-progress
-        sut.startReplication(replicaShard, new SegmentReplicationTargetService.SegmentReplicationListener() {
-            @Override
-            public void onReplicationDone(SegmentReplicationState state) {
-                Assert.fail("Should not succeed");
-            }
-
-            @Override
-            public void onReplicationFailure(SegmentReplicationState state, ReplicationFailedException e, boolean sendShardFailure) {
-                assertEquals("Shard " + replicaShard.shardId() + " is already replicating", e.getMessage());
-                assertFalse(sendShardFailure);
-            }
-        });
+        spy.onNewCheckpoint(newPrimaryCheckpoint, replicaShard);
+        verify(spy, times(1)).processLatestReceivedCheckpoint(eq(replicaShard), any());
         blockGetCheckpointMetadata.countDown();
     }
 
@@ -337,8 +341,21 @@ public void cancel() {
             }
         };
 
+        final ReplicationCheckpoint updatedCheckpoint = new ReplicationCheckpoint(
+            initialCheckpoint.getShardId(),
+            initialCheckpoint.getPrimaryTerm(),
+            initialCheckpoint.getSegmentsGen(),
+            initialCheckpoint.getSegmentInfosVersion() + 1,
+            primaryShard.getDefaultCodecName()
+        );
+
         final SegmentReplicationTarget targetSpy = spy(
-            new SegmentReplicationTarget(replicaShard, source, mock(SegmentReplicationTargetService.SegmentReplicationListener.class))
+            new SegmentReplicationTarget(
+                replicaShard,
+                updatedCheckpoint,
+                source,
+                mock(SegmentReplicationTargetService.SegmentReplicationListener.class)
+            )
         );
 
         // start replication. This adds the target to on-ongoing replication collection
@@ -352,20 +369,20 @@ public void cancel() {
 
         // ensure the old target is cancelled. and new iteration kicks off.
         verify(targetSpy, times(1)).cancel("Cancelling stuck target after new primary");
-        verify(serviceSpy, times(1)).startReplication(eq(replicaShard), any());
+        verify(serviceSpy, times(1)).startReplication(eq(replicaShard), any(), any());
     }
 
     public void testNewCheckpointBehindCurrentCheckpoint() {
         SegmentReplicationTargetService spy = spy(sut);
         spy.onNewCheckpoint(checkpoint, replicaShard);
-        verify(spy, times(0)).startReplication(any(), any());
+        verify(spy, times(0)).startReplication(any(), any(), any());
     }
 
     public void testShardNotStarted() throws IOException {
         SegmentReplicationTargetService spy = spy(sut);
         IndexShard shard = newShard(false);
         spy.onNewCheckpoint(checkpoint, shard);
-        verify(spy, times(0)).startReplication(any(), any());
+        verify(spy, times(0)).startReplication(any(), any(), any());
         closeShards(shard);
     }
 
@@ -381,7 +398,7 @@ public void testRejectCheckpointOnShardPrimaryMode() throws IOException {
         spy.onNewCheckpoint(aheadCheckpoint, spyShard);
 
         // Verify that checkpoint is not processed as shard is in PrimaryMode.
-        verify(spy, times(0)).startReplication(any(), any());
+        verify(spy, times(0)).startReplication(any(), any(), any());
         closeShards(primaryShard);
     }
 
@@ -406,10 +423,10 @@ public void testStartReplicationListenerSuccess() throws InterruptedException {
         SegmentReplicationTargetService spy = spy(sut);
         CountDownLatch latch = new CountDownLatch(1);
         doAnswer(i -> {
-            ((SegmentReplicationTargetService.SegmentReplicationListener) i.getArgument(1)).onReplicationDone(state);
+            ((SegmentReplicationTargetService.SegmentReplicationListener) i.getArgument(2)).onReplicationDone(state);
             latch.countDown();
             return null;
-        }).when(spy).startReplication(any(), any());
+        }).when(spy).startReplication(any(), any(), any());
         doNothing().when(spy).updateVisibleCheckpoint(eq(0L), any());
         spy.afterIndexShardStarted(replicaShard);
 
@@ -422,14 +439,14 @@ public void testStartReplicationListenerFailure() throws InterruptedException {
         SegmentReplicationTargetService spy = spy(sut);
         CountDownLatch latch = new CountDownLatch(1);
         doAnswer(i -> {
-            ((SegmentReplicationTargetService.SegmentReplicationListener) i.getArgument(1)).onReplicationFailure(
+            ((SegmentReplicationTargetService.SegmentReplicationListener) i.getArgument(2)).onReplicationFailure(
                 state,
                 new ReplicationFailedException(replicaShard, null),
                 false
             );
             latch.countDown();
             return null;
-        }).when(spy).startReplication(any(), any());
+        }).when(spy).startReplication(any(), any(), any());
         doNothing().when(spy).updateVisibleCheckpoint(eq(0L), any());
         spy.afterIndexShardStarted(replicaShard);
 
@@ -570,6 +587,7 @@ public void testForceSegmentSyncHandlerWithFailure_AlreadyClosedException_swallo
     public void testTargetCancelledBeforeStartInvoked() {
         final SegmentReplicationTarget target = new SegmentReplicationTarget(
             replicaShard,
+            primaryShard.getLatestReplicationCheckpoint(),
             mock(SegmentReplicationSource.class),
             new SegmentReplicationTargetService.SegmentReplicationListener() {
                 @Override
diff --git a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetTests.java b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetTests.java
index 176954b6d6b3d..5b996fd774baf 100644
--- a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetTests.java
+++ b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetTests.java
@@ -141,7 +141,7 @@ public void getSegmentFiles(
         SegmentReplicationTargetService.SegmentReplicationListener segRepListener = mock(
             SegmentReplicationTargetService.SegmentReplicationListener.class
         );
-        segrepTarget = new SegmentReplicationTarget(spyIndexShard, segrepSource, segRepListener);
+        segrepTarget = new SegmentReplicationTarget(spyIndexShard, repCheckpoint, segrepSource, segRepListener);
 
         segrepTarget.startReplication(new ActionListener<Void>() {
             @Override
@@ -189,7 +189,7 @@ public void getSegmentFiles(
         SegmentReplicationTargetService.SegmentReplicationListener segRepListener = mock(
             SegmentReplicationTargetService.SegmentReplicationListener.class
         );
-        segrepTarget = new SegmentReplicationTarget(spyIndexShard, segrepSource, segRepListener);
+        segrepTarget = new SegmentReplicationTarget(spyIndexShard, repCheckpoint, segrepSource, segRepListener);
 
         segrepTarget.startReplication(new ActionListener<Void>() {
             @Override
@@ -232,7 +232,7 @@ public void getSegmentFiles(
         SegmentReplicationTargetService.SegmentReplicationListener segRepListener = mock(
             SegmentReplicationTargetService.SegmentReplicationListener.class
         );
-        segrepTarget = new SegmentReplicationTarget(spyIndexShard, segrepSource, segRepListener);
+        segrepTarget = new SegmentReplicationTarget(spyIndexShard, repCheckpoint, segrepSource, segRepListener);
 
         segrepTarget.startReplication(new ActionListener<Void>() {
             @Override
@@ -275,7 +275,7 @@ public void getSegmentFiles(
         SegmentReplicationTargetService.SegmentReplicationListener segRepListener = mock(
             SegmentReplicationTargetService.SegmentReplicationListener.class
         );
-        segrepTarget = new SegmentReplicationTarget(spyIndexShard, segrepSource, segRepListener);
+        segrepTarget = new SegmentReplicationTarget(spyIndexShard, repCheckpoint, segrepSource, segRepListener);
 
         doThrow(exception).when(spyIndexShard).finalizeReplication(any());
 
@@ -320,7 +320,7 @@ public void getSegmentFiles(
         SegmentReplicationTargetService.SegmentReplicationListener segRepListener = mock(
             SegmentReplicationTargetService.SegmentReplicationListener.class
         );
-        segrepTarget = new SegmentReplicationTarget(spyIndexShard, segrepSource, segRepListener);
+        segrepTarget = new SegmentReplicationTarget(spyIndexShard, repCheckpoint, segrepSource, segRepListener);
 
         doThrow(exception).when(spyIndexShard).finalizeReplication(any());
 
@@ -364,7 +364,7 @@ public void getSegmentFiles(
         SegmentReplicationTargetService.SegmentReplicationListener segRepListener = mock(
             SegmentReplicationTargetService.SegmentReplicationListener.class
         );
-        segrepTarget = new SegmentReplicationTarget(spyIndexShard, segrepSource, segRepListener);
+        segrepTarget = new SegmentReplicationTarget(spyIndexShard, repCheckpoint, segrepSource, segRepListener);
         when(spyIndexShard.getSegmentMetadataMap()).thenReturn(SI_SNAPSHOT_DIFFERENT);
         segrepTarget.startReplication(new ActionListener<Void>() {
             @Override
@@ -417,7 +417,7 @@ public void getSegmentFiles(
             SegmentReplicationTargetService.SegmentReplicationListener.class
         );
 
-        segrepTarget = new SegmentReplicationTarget(spyIndexShard, segrepSource, segRepListener);
+        segrepTarget = new SegmentReplicationTarget(spyIndexShard, repCheckpoint, segrepSource, segRepListener);
         when(spyIndexShard.getSegmentMetadataMap()).thenReturn(storeMetadataSnapshots.get(0).asMap());
         segrepTarget.startReplication(new ActionListener<Void>() {
             @Override
diff --git a/server/src/test/java/org/opensearch/recovery/ReplicationCollectionTests.java b/server/src/test/java/org/opensearch/recovery/ReplicationCollectionTests.java
index 776173f73ce5c..9c38c5848e297 100644
--- a/server/src/test/java/org/opensearch/recovery/ReplicationCollectionTests.java
+++ b/server/src/test/java/org/opensearch/recovery/ReplicationCollectionTests.java
@@ -120,11 +120,13 @@ public void testStartMultipleReplicationsForSingleShard() throws Exception {
             shards.recoverReplica(shard);
             final SegmentReplicationTarget target1 = new SegmentReplicationTarget(
                 shard,
+                shards.getPrimary().getLatestReplicationCheckpoint(),
                 mock(SegmentReplicationSource.class),
                 mock(ReplicationListener.class)
             );
             final SegmentReplicationTarget target2 = new SegmentReplicationTarget(
                 shard,
+                shards.getPrimary().getLatestReplicationCheckpoint(),
                 mock(SegmentReplicationSource.class),
                 mock(ReplicationListener.class)
             );
diff --git a/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java b/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java
index 29ecc6b376ad0..7ef460ebbfb50 100644
--- a/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java
@@ -94,6 +94,7 @@
 import org.opensearch.index.engine.EngineFactory;
 import org.opensearch.index.engine.EngineTestCase;
 import org.opensearch.index.engine.InternalEngineFactory;
+import org.opensearch.index.engine.NRTReplicationEngineFactory;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.mapper.SourceToParse;
 import org.opensearch.index.remote.RemoteRefreshSegmentPressureService;
@@ -141,6 +142,7 @@
 import org.opensearch.indices.replication.common.ReplicationFailedException;
 import org.opensearch.indices.replication.common.ReplicationListener;
 import org.opensearch.indices.replication.common.ReplicationState;
+import org.opensearch.indices.replication.common.ReplicationType;
 import org.opensearch.repositories.IndexId;
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.Repository;
@@ -531,6 +533,58 @@ protected IndexShard newShard(
         );
     }
 
+    protected IndexShard newShard(boolean primary, SegmentReplicationCheckpointPublisher checkpointPublisher) throws IOException {
+        final Settings settings = Settings.builder().put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT).build();
+        return newShard(primary, checkpointPublisher, settings);
+    }
+
+    /**
+     * creates a new initializing shard. The shard will be put in its proper path under the
+     * current node id the shard is assigned to.
+     * @param checkpointPublisher               Segment Replication Checkpoint Publisher to publish checkpoint
+     */
+    protected IndexShard newShard(boolean primary, SegmentReplicationCheckpointPublisher checkpointPublisher, Settings settings)
+        throws IOException {
+        final ShardId shardId = new ShardId("index", "_na_", 0);
+        final ShardRouting shardRouting = TestShardRouting.newShardRouting(
+            shardId,
+            randomAlphaOfLength(10),
+            primary,
+            ShardRoutingState.INITIALIZING,
+            primary ? RecoverySource.EmptyStoreRecoverySource.INSTANCE : RecoverySource.PeerRecoverySource.INSTANCE
+        );
+        final NodeEnvironment.NodePath nodePath = new NodeEnvironment.NodePath(createTempDir());
+        ShardPath shardPath = new ShardPath(false, nodePath.resolve(shardId), nodePath.resolve(shardId), shardId);
+
+        Settings indexSettings = Settings.builder()
+            .put(settings)
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+            .put(IndexSettings.INDEX_SOFT_DELETES_RETENTION_OPERATIONS_SETTING.getKey(), between(0, 1000))
+            .put(Settings.EMPTY)
+            .build();
+        IndexMetadata metadata = IndexMetadata.builder(shardRouting.getIndexName())
+            .settings(indexSettings)
+            .primaryTerm(0, primaryTerm)
+            .putMapping("{ \"properties\": {} }")
+            .build();
+        return newShard(
+            shardRouting,
+            shardPath,
+            metadata,
+            null,
+            null,
+            new NRTReplicationEngineFactory(),
+            new EngineConfigFactory(new IndexSettings(metadata, metadata.getSettings())),
+            () -> {},
+            RetentionLeaseSyncer.EMPTY,
+            EMPTY_EVENT_LISTENER,
+            checkpointPublisher,
+            null
+        );
+    }
+
     /**
      * creates a new initializing shard.
      * @param routing                       shard routing to use
@@ -1527,10 +1581,7 @@ public void getCheckpointMetadata(
                 ActionListener<CheckpointInfoResponse> listener
             ) {
                 try {
-                    final CopyState copyState = new CopyState(
-                        ReplicationCheckpoint.empty(primaryShard.shardId, primaryShard.getLatestReplicationCheckpoint().getCodec()),
-                        primaryShard
-                    );
+                    final CopyState copyState = new CopyState(primaryShard.getLatestReplicationCheckpoint(), primaryShard);
                     listener.onResponse(
                         new CheckpointInfoResponse(copyState.getCheckpoint(), copyState.getMetadataMap(), copyState.getInfosBytes())
                     );
@@ -1585,6 +1636,7 @@ protected final List<SegmentReplicationTarget> replicateSegments(IndexShard prim
             final SegmentReplicationTargetService targetService = prepareForReplication(primaryShard, replica);
             final SegmentReplicationTarget target = targetService.startReplication(
                 replica,
+                primaryShard.getLatestReplicationCheckpoint(),
                 getTargetListener(primaryShard, replica, primaryMetadata, countDownLatch)
             );
             ids.add(target);

From 46aaea232556d05fa2e2dda762967800312659e8 Mon Sep 17 00:00:00 2001
From: Vacha Shah <vachshah@amazon.com>
Date: Thu, 3 Aug 2023 17:40:13 +0000
Subject: [PATCH 37/37] Getting latest changes from main

Signed-off-by: Vacha Shah <vachshah@amazon.com>
---
 .../action/ProtobufActionListenerResponseHandler.java         | 2 +-
 .../java/org/opensearch/action/ProtobufActionResponse.java    | 2 +-
 .../action/support/ProtobufChannelActionListener.java         | 2 +-
 .../action/support/nodes/ProtobufBaseNodeResponse.java        | 2 +-
 .../org/opensearch/tasks/ProtobufTaskCancellationService.java | 2 +-
 .../transport/ProtobufEmptyTransportResponseHandler.java      | 4 ++--
 .../TransportServiceDeserializationFailureTests.java          | 2 +-
 .../opensearch/transport/AbstractSimpleTransportTestCase.java | 2 +-
 8 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java b/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
index 02bfe31f32cbb..0e7996dc6ab32 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionListenerResponseHandler.java
@@ -13,7 +13,7 @@
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportResponseHandler;
 import org.opensearch.transport.TransportException;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 import java.util.Objects;
diff --git a/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java b/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java
index cc8c7faf02654..aa2b9705fa01a 100644
--- a/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java
+++ b/server/src/main/java/org/opensearch/action/ProtobufActionResponse.java
@@ -8,7 +8,7 @@
 
 package org.opensearch.action;
 
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 import java.io.IOException;
 
diff --git a/server/src/main/java/org/opensearch/action/support/ProtobufChannelActionListener.java b/server/src/main/java/org/opensearch/action/support/ProtobufChannelActionListener.java
index 27fd929919318..5e1bf4d6e9835 100644
--- a/server/src/main/java/org/opensearch/action/support/ProtobufChannelActionListener.java
+++ b/server/src/main/java/org/opensearch/action/support/ProtobufChannelActionListener.java
@@ -11,7 +11,7 @@
 import org.opensearch.action.ActionListener;
 import org.opensearch.transport.TransportChannel;
 import org.opensearch.transport.TransportRequest;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 /**
  * Listener for transport channel actions
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
index da52d2828edf4..a164d423c5bc7 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/ProtobufBaseNodeResponse.java
@@ -9,7 +9,7 @@
 package org.opensearch.action.support.nodes;
 
 import org.opensearch.cluster.node.DiscoveryNode;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 
 /**
  * A base class for node level operations.
diff --git a/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java b/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
index 09b6566239dc5..ece1190d9a4c7 100644
--- a/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
+++ b/server/src/main/java/org/opensearch/tasks/ProtobufTaskCancellationService.java
@@ -23,7 +23,7 @@
 import org.opensearch.transport.TransportException;
 import org.opensearch.transport.TransportRequest;
 import org.opensearch.transport.ProtobufTransportRequestHandler;
-import org.opensearch.transport.TransportResponse;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
diff --git a/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java b/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java
index 586c94a725566..2e20b818401be 100644
--- a/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java
+++ b/server/src/main/java/org/opensearch/transport/ProtobufEmptyTransportResponseHandler.java
@@ -11,8 +11,8 @@
 import java.io.IOException;
 
 import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.TransportResponse.Empty;
 
 /**
  * Handler for empty transport response
@@ -40,7 +40,7 @@ public String executor() {
     }
 
     @Override
-    public Empty read(StreamInput in) throws IOException {
+    public TransportResponse.Empty read(StreamInput in) throws IOException {
         // TODO Auto-generated method stub
         throw new UnsupportedOperationException("Unimplemented method 'read'");
     }
diff --git a/server/src/test/java/org/opensearch/transport/TransportServiceDeserializationFailureTests.java b/server/src/test/java/org/opensearch/transport/TransportServiceDeserializationFailureTests.java
index 13c7560b270e8..1767238dd2fd5 100644
--- a/server/src/test/java/org/opensearch/transport/TransportServiceDeserializationFailureTests.java
+++ b/server/src/test/java/org/opensearch/transport/TransportServiceDeserializationFailureTests.java
@@ -46,7 +46,7 @@
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.transport.MockTransport;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.TransportResponse.Empty;
+import org.opensearch.core.transport.TransportResponse.Empty;
 
 import java.io.IOException;
 import java.util.Collections;
diff --git a/test/framework/src/main/java/org/opensearch/transport/AbstractSimpleTransportTestCase.java b/test/framework/src/main/java/org/opensearch/transport/AbstractSimpleTransportTestCase.java
index 7a42a0e91caf2..9fd04a741a6b8 100644
--- a/test/framework/src/main/java/org/opensearch/transport/AbstractSimpleTransportTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/transport/AbstractSimpleTransportTestCase.java
@@ -75,7 +75,7 @@
 import org.opensearch.test.transport.StubbableTransport;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.TransportResponse.Empty;
+import org.opensearch.core.transport.TransportResponse.Empty;
 
 import org.junit.After;
 import org.junit.Before;